Move src/ -> webrtc/

TBR=niklas.enbom@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/915006

git-svn-id: http://webrtc.googlecode.com/svn/trunk@2963 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/video_coding/codecs/i420/main/interface/i420.h

@@ -0,0 +1,151 @@
+/*
+ *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_I420_H_
+#define WEBRTC_MODULES_VIDEO_CODING_CODECS_I420_H_
+
+#include "video_codec_interface.h"
+#include "typedefs.h"
+
+namespace webrtc {
+
+class I420Encoder : public VideoEncoder {
+public:
+
+  I420Encoder();
+
+  virtual ~I420Encoder();
+
+// Initialize the encoder with the information from the VideoCodec.
+//
+// Input:
+//          - codecSettings     : Codec settings.
+//          - numberOfCores     : Number of cores available for the encoder.
+//          - maxPayloadSize    : The maximum size each payload is allowed
+//                                to have. Usually MTU - overhead.
+//
+// Return value                 : WEBRTC_VIDEO_CODEC_OK if OK.
+//                                <0 - Error
+  virtual int InitEncode(const VideoCodec* codecSettings,
+                         int /*numberOfCores*/,
+                         uint32_t /*maxPayloadSize*/);
+
+// "Encode" an I420 image (as a part of a video stream). The encoded image
+// will be returned to the user via the encode complete callback.
+//
+// Input:
+//          - inputImage        : Image to be encoded.
+//          - codecSpecificInfo : Pointer to codec specific data.
+//          - frameType         : Frame type to be sent (Key /Delta).
+//
+// Return value                 : WEBRTC_VIDEO_CODEC_OK if OK.
+//                                <0 - Error
+  virtual int Encode(const VideoFrame& inputImage,
+                     const CodecSpecificInfo* /*codecSpecificInfo*/,
+                     const std::vector<VideoFrameType>* /*frame_types*/);
+
+// Register an encode complete callback object.
+//
+// Input:
+//          - callback         : Callback object which handles encoded images.
+//
+// Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
+  virtual int RegisterEncodeCompleteCallback(EncodedImageCallback* callback);
+
+// Free encoder memory.
+//
+// Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
+  virtual int Release();
+
+  virtual int SetRates(uint32_t /*newBitRate*/, uint32_t /*frameRate*/)
+    {return WEBRTC_VIDEO_CODEC_OK;}
+
+  virtual int SetChannelParameters(uint32_t /*packetLoss*/, int /*rtt*/)
+    {return WEBRTC_VIDEO_CODEC_OK;}
+
+  virtual int CodecConfigParameters(uint8_t* /*buffer*/, int /*size*/)
+    {return WEBRTC_VIDEO_CODEC_OK;}
+
+private:
+  bool                     _inited;
+  EncodedImage             _encodedImage;
+  EncodedImageCallback*    _encodedCompleteCallback;
+
+}; // end of WebRtcI420DEncoder class
+
+class I420Decoder : public VideoDecoder {
+public:
+
+  I420Decoder();
+
+  virtual ~I420Decoder();
+
+// Initialize the decoder.
+// The user must notify the codec of width and height values.
+//
+// Return value         :  WEBRTC_VIDEO_CODEC_OK.
+//                        <0 - Errors
+  virtual int InitDecode(const VideoCodec* codecSettings,
+                         int /*numberOfCores*/);
+
+  virtual int SetCodecConfigParameters(const uint8_t* /*buffer*/, int /*size*/)
+    {return WEBRTC_VIDEO_CODEC_OK;};
+
+// Decode encoded image (as a part of a video stream). The decoded image
+// will be returned to the user through the decode complete callback.
+//
+// Input:
+//          - inputImage        : Encoded image to be decoded
+//          - missingFrames     : True if one or more frames have been lost
+//                                since the previous decode call.
+//          - codecSpecificInfo : pointer to specific codec data
+//          - renderTimeMs      : Render time in Ms
+//
+// Return value                 : WEBRTC_VIDEO_CODEC_OK if OK
+//                                 <0 - Error
+  virtual int Decode(const EncodedImage& inputImage,
+                     bool missingFrames,
+                     const RTPFragmentationHeader* /*fragmentation*/,
+                     const CodecSpecificInfo* /*codecSpecificInfo*/,
+                     int64_t /*renderTimeMs*/);
+
+// Register a decode complete callback object.
+//
+// Input:
+//          - callback         : Callback object which handles decoded images.
+//
+// Return value                : WEBRTC_VIDEO_CODEC_OK if OK, < 0 otherwise.
+  virtual int RegisterDecodeCompleteCallback(DecodedImageCallback* callback);
+
+// Free decoder memory.
+//
+// Return value                : WEBRTC_VIDEO_CODEC_OK if OK.
+//                                  <0 - Error
+  virtual int Release();
+
+// Reset decoder state and prepare for a new call.
+//
+// Return value         :  WEBRTC_VIDEO_CODEC_OK.
+//                          <0 - Error
+  virtual int Reset();
+
+private:
+
+  VideoFrame                  _decodedImage;
+  int                         _width;
+  int                         _height;
+  bool                        _inited;
+  DecodedImageCallback*       _decodeCompleteCallback;
+
+}; // End of WebRtcI420Decoder class.
+
+} // namespace webrtc
+
+#endif // WEBRTC_MODULES_VIDEO_CODING_CODECS_I420_H_

webrtc/modules/video_coding/codecs/i420/main/source/Android.mk

@@ -0,0 +1,41 @@
+# Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+LOCAL_PATH := $(call my-dir)
+
+include $(CLEAR_VARS)
+
+include $(LOCAL_PATH)/../../../../../../../android-webrtc.mk
+
+LOCAL_MODULE_CLASS := STATIC_LIBRARIES
+LOCAL_MODULE := libwebrtc_i420
+LOCAL_MODULE_TAGS := optional
+LOCAL_CPP_EXTENSION := .cc
+LOCAL_SRC_FILES := i420.cc
+
+# Flags passed to both C and C++ files.
+LOCAL_CFLAGS := \
+    $(MY_WEBRTC_COMMON_DEFS)
+
+# Include paths placed before CFLAGS/CPPFLAGS
+LOCAL_C_INCLUDES := \
+    $(LOCAL_PATH)/../interface \
+    $(LOCAL_PATH)/../../../interface \
+    $(LOCAL_PATH)/../../../../../.. \
+    $(LOCAL_PATH)/../../../../../../common_video/interface \
+    $(LOCAL_PATH)/../../../../../../system_wrappers/interface 
+
+LOCAL_SHARED_LIBRARIES := \
+    libcutils \
+    libdl \
+    libstlport
+
+ifndef NDK_ROOT
+include external/stlport/libstlport.mk
+endif
+include $(BUILD_STATIC_LIBRARY)

webrtc/modules/video_coding/codecs/i420/main/source/i420.cc

@@ -0,0 +1,201 @@
+/*
+ *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "modules/video_coding/codecs/i420/main/interface/i420.h"
+
+#include <string.h>
+
+#include "common_video/libyuv/include/webrtc_libyuv.h"
+
+
+namespace webrtc
+{
+
+I420Encoder::I420Encoder():
+_inited(false),
+_encodedImage(),
+_encodedCompleteCallback(NULL)
+{}
+
+I420Encoder::~I420Encoder() {
+  _inited = false;
+  if (_encodedImage._buffer != NULL) {
+    delete [] _encodedImage._buffer;
+    _encodedImage._buffer = NULL;
+  }
+}
+
+int I420Encoder::Release() {
+  // Should allocate an encoded frame and then release it here, for that we
+  // actually need an init flag.
+  if (_encodedImage._buffer != NULL) {
+    delete [] _encodedImage._buffer;
+    _encodedImage._buffer = NULL;
+  }
+  _inited = false;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int I420Encoder::InitEncode(const VideoCodec* codecSettings,
+                            int /*numberOfCores*/,
+                            uint32_t /*maxPayloadSize */) {
+  if (codecSettings == NULL) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
+  if (codecSettings->width < 1 || codecSettings->height < 1) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
+
+  // Allocating encoded memory.
+  if (_encodedImage._buffer != NULL) {
+    delete [] _encodedImage._buffer;
+    _encodedImage._buffer = NULL;
+    _encodedImage._size = 0;
+  }
+  const uint32_t newSize = CalcBufferSize(kI420,
+                                          codecSettings->width,
+                                          codecSettings->height);
+  uint8_t* newBuffer = new uint8_t[newSize];
+  if (newBuffer == NULL) {
+    return WEBRTC_VIDEO_CODEC_MEMORY;
+  }
+  _encodedImage._size = newSize;
+  _encodedImage._buffer = newBuffer;
+
+  // If no memory allocation, no point to init.
+  _inited = true;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+
+int I420Encoder::Encode(const VideoFrame& inputImage,
+                    const CodecSpecificInfo* /*codecSpecificInfo*/,
+                    const std::vector<VideoFrameType>* /*frame_types*/) {
+  if (!_inited) {
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+  if (_encodedCompleteCallback == NULL) {
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+
+  _encodedImage._frameType = kKeyFrame; // No coding.
+  _encodedImage._timeStamp = inputImage.TimeStamp();
+  _encodedImage._encodedHeight = inputImage.Height();
+  _encodedImage._encodedWidth = inputImage.Width();
+  if (inputImage.Length() > _encodedImage._size) {
+
+    // Allocating encoded memory.
+    if (_encodedImage._buffer != NULL) {
+      delete [] _encodedImage._buffer;
+      _encodedImage._buffer = NULL;
+      _encodedImage._size = 0;
+    }
+    const uint32_t newSize = CalcBufferSize(kI420,
+                                            _encodedImage._encodedWidth,
+                                            _encodedImage._encodedHeight);
+    uint8_t* newBuffer = new uint8_t[newSize];
+    if (newBuffer == NULL) {
+      return WEBRTC_VIDEO_CODEC_MEMORY;
+    }
+    _encodedImage._size = newSize;
+    _encodedImage._buffer = newBuffer;
+  }
+  memcpy(_encodedImage._buffer, inputImage.Buffer(), inputImage.Length());
+  _encodedImage._length = inputImage.Length();
+  _encodedCompleteCallback->Encoded(_encodedImage);
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+int
+I420Encoder::RegisterEncodeCompleteCallback(EncodedImageCallback* callback) {
+  _encodedCompleteCallback = callback;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+I420Decoder::I420Decoder():
+_decodedImage(),
+_width(0),
+_height(0),
+_inited(false),
+_decodeCompleteCallback(NULL)
+{}
+
+I420Decoder::~I420Decoder() {
+  Release();
+}
+
+int
+I420Decoder::Reset() {
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+
+int
+I420Decoder::InitDecode(const VideoCodec* codecSettings,
+                        int /*numberOfCores */) {
+  if (codecSettings == NULL) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  } else if (codecSettings->width < 1 || codecSettings->height < 1) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
+  _width = codecSettings->width;
+  _height = codecSettings->height;
+  _inited = true;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int
+I420Decoder::Decode(const EncodedImage& inputImage,
+                    bool /*missingFrames*/,
+                    const RTPFragmentationHeader* /*fragmentation*/,
+                    const CodecSpecificInfo* /*codecSpecificInfo*/,
+                    int64_t /*renderTimeMs*/) {
+  if (inputImage._buffer == NULL) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
+  if (_decodeCompleteCallback == NULL) {
+    return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+  if (inputImage._length <= 0) {
+    return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
+  if (!_inited) {
+   return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
+
+  // Set decoded image parameters.
+  if (_decodedImage.CopyFrame(inputImage._length, inputImage._buffer) < 0) {
+    return WEBRTC_VIDEO_CODEC_MEMORY;
+  }
+  _decodedImage.SetHeight(_height);
+  _decodedImage.SetWidth(_width);
+  _decodedImage.SetTimeStamp(inputImage._timeStamp);
+
+  _decodeCompleteCallback->Decoded(_decodedImage);
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int
+I420Decoder::RegisterDecodeCompleteCallback(DecodedImageCallback* callback) {
+  _decodeCompleteCallback = callback;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+int
+I420Decoder::Release() {
+  _decodedImage.Free();
+  _inited = false;
+  return WEBRTC_VIDEO_CODEC_OK;
+}
+
+}

webrtc/modules/video_coding/codecs/i420/main/source/i420.gypi

@@ -0,0 +1,40 @@
+# Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+{
+  'targets': [
+    {
+      'target_name': 'webrtc_i420',
+      'type': '<(library)',
+      'dependencies': [
+        '<(webrtc_root)/system_wrappers/source/system_wrappers.gyp:system_wrappers',
+      ],
+      'include_dirs': [
+        '../interface',
+        '../../../interface',
+        '../../../../../../common_video/interface',
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '../interface',
+          '../../../../../../common_video/interface',
+        ],
+      },
+      'sources': [
+        '../interface/i420.h',
+        'i420.cc',
+      ],
+    },
+  ],
+}
+
+# Local Variables:
+# tab-width:2
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=2 shiftwidth=2: