Implement and test EncodedImageCallback in new ViE API.

R=mflodman@webrtc.org, pbos@webrtc.org, stefan@webrtc.org

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

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

webrtc/modules/video_coding/main/source/generic_encoder.cc

@@ -12,6 +12,7 @@
 #include "webrtc/modules/video_coding/main/source/encoded_frame.h"
 #include "webrtc/modules/video_coding/main/source/generic_encoder.h"
 #include "webrtc/modules/video_coding/main/source/media_optimization.h"
+#include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 
 namespace webrtc {
 
@@ -147,7 +148,9 @@ _mediaOpt(NULL),
 _encodedBytes(0),
 _payloadType(0),
 _codecType(kVideoCodecUnknown),
-_internalSource(false)
+_internalSource(false),
+post_encode_callback_lock_(CriticalSectionWrapper::CreateCriticalSection()),
+post_encode_callback_(NULL)
 #ifdef DEBUG_ENCODER_BIT_STREAM
 , _bitStreamAfterEncoder(NULL)
 #endif
@@ -177,6 +180,12 @@ VCMEncodedFrameCallback::Encoded(
     const CodecSpecificInfo* codecSpecificInfo,
     const RTPFragmentationHeader* fragmentationHeader)
 {
+    {
+      CriticalSectionScoped cs(post_encode_callback_lock_.get());
+      if (post_encode_callback_) {
+        post_encode_callback_->Encoded(encodedImage);
+      }
+    }
     FrameType frameType = VCMEncodedFrame::ConvertFrameType(encodedImage._frameType);
 
     uint32_t encodedBytes = 0;
@@ -271,4 +280,10 @@ void VCMEncodedFrameCallback::CopyCodecSpecific(const CodecSpecificInfo& info,
       return;
   }
 }
+
+void VCMEncodedFrameCallback::RegisterPostEncodeImageCallback(
+    EncodedImageCallback* callback) {
+  CriticalSectionScoped cs(post_encode_callback_lock_.get());
+  post_encode_callback_ = callback;
+}
 }  // namespace webrtc

webrtc/modules/video_coding/main/source/generic_encoder.h

@@ -15,9 +15,13 @@
 
 #include <stdio.h>
 
+#include "webrtc/system_wrappers/interface/scoped_ptr.h"
+
 namespace webrtc
 {
 
+class CriticalSectionWrapper;
+
 namespace media_optimization {
 class MediaOptimization;
 }  // namespace media_optimization
@@ -55,6 +59,8 @@ public:
     void SetCodecType(VideoCodecType codecType) {_codecType = codecType;};
     void SetInternalSource(bool internalSource) { _internalSource = internalSource; };
 
+    void RegisterPostEncodeImageCallback(EncodedImageCallback* callback);
+
 private:
     /*
      * Map information from info into rtp. If no relevant information is found
@@ -69,6 +75,10 @@ private:
     uint8_t _payloadType;
     VideoCodecType _codecType;
     bool _internalSource;
+
+    scoped_ptr<CriticalSectionWrapper> post_encode_callback_lock_;
+    EncodedImageCallback* post_encode_callback_;
+
 #ifdef DEBUG_ENCODER_BIT_STREAM
     FILE* _bitStreamAfterEncoder;
 #endif

webrtc/modules/video_coding/main/source/video_coding_impl.cc

@@ -319,6 +319,16 @@ class VideoCodingModuleImpl : public VideoCodingModule {
     return receiver_->SetReceiveChannelParameters(rtt);
   }
 
+  virtual void RegisterPreDecodeImageCallback(
+      EncodedImageCallback* observer) OVERRIDE {
+    receiver_->RegisterPreDecodeImageCallback(observer);
+  }
+
+  virtual void RegisterPostEncodeImageCallback(
+      EncodedImageCallback* observer) OVERRIDE {
+    sender_->RegisterPostEncodeImageCallback(observer);
+  }
+
  private:
   scoped_ptr<vcm::VideoSender> sender_;
   scoped_ptr<vcm::VideoReceiver> receiver_;

webrtc/modules/video_coding/main/source/video_coding_impl.h

@@ -27,6 +27,9 @@
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 
 namespace webrtc {
+
+class EncodedFrameObserver;
+
 namespace vcm {
 
 class VCMProcessTimer {
@@ -98,6 +101,9 @@ class VideoSender {
   void SuspendBelowMinBitrate();
   bool VideoSuspended() const;
 
+  void RegisterPostEncodeImageCallback(
+      EncodedImageCallback* post_encode_callback);
+
   int32_t TimeUntilNextProcess();
   int32_t Process();
 
@@ -173,6 +179,8 @@ class VideoReceiver {
   int32_t TimeUntilNextProcess();
   int32_t Process();
 
+  void RegisterPreDecodeImageCallback(EncodedImageCallback* observer);
+
  protected:
   int32_t Decode(const webrtc::VCMEncodedFrame& frame);
   int32_t RequestKeyFrame();
@@ -213,6 +221,7 @@ class VideoReceiver {
   VCMKeyRequestMode _keyRequestMode;
   bool _scheduleKeyRequest;
   size_t max_nack_list_size_;
+  EncodedImageCallback* pre_decode_image_callback_;
 
   VCMCodecDataBase _codecDataBase;
   VCMProcessTimer _receiveStatsTimer;

webrtc/modules/video_coding/main/source/video_receiver.cc

@@ -52,6 +52,7 @@ VideoReceiver::VideoReceiver(const int32_t id,
       _keyRequestMode(kKeyOnError),
       _scheduleKeyRequest(false),
       max_nack_list_size_(0),
+      pre_decode_image_callback_(NULL),
       _codecDataBase(id),
       _receiveStatsTimer(1000, clock_),
       _retransmissionTimer(10, clock_),
@@ -400,6 +401,11 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
     _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
                                clock_->TimeInMilliseconds());
 
+    if (pre_decode_image_callback_) {
+      EncodedImage encoded_image(frame->EncodedImage());
+      pre_decode_image_callback_->Encoded(encoded_image);
+    }
+
 #ifdef DEBUG_DECODER_BIT_STREAM
     if (_bitStreamBeforeDecoder != NULL) {
       // Write bit stream to file for debugging purposes
@@ -815,5 +821,11 @@ int VideoReceiver::SetMinReceiverDelay(int desired_delay_ms) {
   return _receiver.SetMinReceiverDelay(desired_delay_ms);
 }
 
+void VideoReceiver::RegisterPreDecodeImageCallback(
+    EncodedImageCallback* observer) {
+  CriticalSectionScoped cs(_receiveCritSect);
+  pre_decode_image_callback_ = observer;
+}
+
 }  // namespace vcm
 }  // namespace webrtc

webrtc/modules/video_coding/main/source/video_sender.cc

@@ -446,5 +446,11 @@ bool VideoSender::VideoSuspended() const {
   return _mediaOpt.video_suspended();
 }
 
+void VideoSender::RegisterPostEncodeImageCallback(
+    EncodedImageCallback* observer) {
+  CriticalSectionScoped cs(_sendCritSect);
+  _encodedFrameCallback.RegisterPostEncodeImageCallback(observer);
+}
+
 }  // namespace vcm
 }  // namespace webrtc