Add support for writing raw encoder output to .ivf files.

webrtc/modules/video_coding/video_receiver.cc

Index: webrtc/modules/video_coding/video_receiver.cc
diff --git a/webrtc/modules/video_coding/video_receiver.cc b/webrtc/modules/video_coding/video_receiver.cc
index 136f7d7830816d1737906af590baffb4a0aad1a5..001cbc7e12cf7e8ec57749dc1ea17c282cf9c8d7 100644
--- a/webrtc/modules/video_coding/video_receiver.cc
+++ b/webrtc/modules/video_coding/video_receiver.cc
@@ -20,18 +20,15 @@
 #include "webrtc/modules/video_coding/video_coding_impl.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
-// #define DEBUG_DECODER_BIT_STREAM
-
 namespace webrtc {
 namespace vcm {
 
 VideoReceiver::VideoReceiver(Clock* clock,
                              EventFactory* event_factory,
+                             EncodedImageCallback* pre_decode_image_callback,
                              NackSender* nack_sender,
                              KeyFrameRequestSender* keyframe_request_sender)
     : clock_(clock),
-      process_crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
-      _receiveCritSect(CriticalSectionWrapper::CreateCriticalSection()),
       _timing(clock_),
       _receiver(&_timing,
                 clock_,
@@ -39,50 +36,37 @@ VideoReceiver::VideoReceiver(Clock* clock,
                 nack_sender,
                 keyframe_request_sender),
       _decodedFrameCallback(&_timing, clock_),
-      _frameTypeCallback(NULL),
-      _receiveStatsCallback(NULL),
-      _decoderTimingCallback(NULL),
-      _packetRequestCallback(NULL),
-      render_buffer_callback_(NULL),
-      _decoder(NULL),
-#ifdef DEBUG_DECODER_BIT_STREAM
-      _bitStreamBeforeDecoder(NULL),
-#endif
+      _frameTypeCallback(nullptr),
+      _receiveStatsCallback(nullptr),
+      _decoderTimingCallback(nullptr),
+      _packetRequestCallback(nullptr),
+      render_buffer_callback_(nullptr),
+      _decoder(nullptr),
       _frameFromFile(),
       _scheduleKeyRequest(false),
       drop_frames_until_keyframe_(false),
       max_nack_list_size_(0),
       _codecDataBase(nullptr, nullptr),
-      pre_decode_image_callback_(NULL),
+      pre_decode_image_callback_(pre_decode_image_callback),
       _receiveStatsTimer(1000, clock_),
       _retransmissionTimer(10, clock_),
-      _keyRequestTimer(500, clock_) {
-  assert(clock_);
-#ifdef DEBUG_DECODER_BIT_STREAM
-  _bitStreamBeforeDecoder = fopen("decoderBitStream.bit", "wb");
-#endif
-}
+      _keyRequestTimer(500, clock_) {}
 
-VideoReceiver::~VideoReceiver() {
-  delete _receiveCritSect;
-#ifdef DEBUG_DECODER_BIT_STREAM
-  fclose(_bitStreamBeforeDecoder);
-#endif
-}
+VideoReceiver::~VideoReceiver() {}
 
 void VideoReceiver::Process() {
   // Receive-side statistics
   if (_receiveStatsTimer.TimeUntilProcess() == 0) {
     _receiveStatsTimer.Processed();
-    CriticalSectionScoped cs(process_crit_sect_.get());
-    if (_receiveStatsCallback != NULL) {
+    rtc::CritScope cs(&process_crit_);
+    if (_receiveStatsCallback != nullptr) {
       uint32_t bitRate;
       uint32_t frameRate;
       _receiver.ReceiveStatistics(&bitRate, &frameRate);
       _receiveStatsCallback->OnReceiveRatesUpdated(bitRate, frameRate);
     }
 
-    if (_decoderTimingCallback != NULL) {
+    if (_decoderTimingCallback != nullptr) {
       int decode_ms;
       int max_decode_ms;
       int current_delay_ms;
@@ -110,8 +94,8 @@ void VideoReceiver::Process() {
     _keyRequestTimer.Processed();
     bool request_key_frame = false;
     {
-      CriticalSectionScoped cs(process_crit_sect_.get());
-      request_key_frame = _scheduleKeyRequest && _frameTypeCallback != NULL;
+      rtc::CritScope cs(&process_crit_);
+      request_key_frame = _scheduleKeyRequest && _frameTypeCallback != nullptr;
     }
     if (request_key_frame)
       RequestKeyFrame();
@@ -129,9 +113,9 @@ void VideoReceiver::Process() {
     bool callback_registered = false;
     uint16_t length;
     {
-      CriticalSectionScoped cs(process_crit_sect_.get());
+      rtc::CritScope cs(&process_crit_);
       length = max_nack_list_size_;
-      callback_registered = _packetRequestCallback != NULL;
+      callback_registered = _packetRequestCallback != nullptr;
     }
     if (callback_registered && length > 0) {
       // Collect sequence numbers from the default receiver.
@@ -142,8 +126,8 @@ void VideoReceiver::Process() {
         ret = RequestKeyFrame();
       }
       if (ret == VCM_OK && !nackList.empty()) {
-        CriticalSectionScoped cs(process_crit_sect_.get());
-        if (_packetRequestCallback != NULL) {
+        rtc::CritScope cs(&process_crit_);
+        if (_packetRequestCallback != nullptr) {
           _packetRequestCallback->ResendPackets(&nackList[0], nackList.size());
         }
       }
@@ -168,7 +152,7 @@ int64_t VideoReceiver::TimeUntilNextProcess() {
 }
 
 int32_t VideoReceiver::SetReceiveChannelParameters(int64_t rtt) {
-  CriticalSectionScoped receiveCs(_receiveCritSect);
+  rtc::CritScope cs(&receive_crit_);
   _receiver.UpdateRtt(rtt);
   return 0;
 }
@@ -189,7 +173,7 @@ int32_t VideoReceiver::SetVideoProtection(VCMVideoProtection videoProtection,
     }
 
     case kProtectionNackFEC: {
-      CriticalSectionScoped cs(_receiveCritSect);
+      rtc::CritScope cs(&receive_crit_);
       RTC_DCHECK(enable);
       _receiver.SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
       _receiver.SetDecodeErrorMode(kNoErrors);
@@ -210,14 +194,14 @@ int32_t VideoReceiver::SetVideoProtection(VCMVideoProtection videoProtection,
 // ready for rendering.
 int32_t VideoReceiver::RegisterReceiveCallback(
     VCMReceiveCallback* receiveCallback) {
-  CriticalSectionScoped cs(_receiveCritSect);
+  rtc::CritScope cs(&receive_crit_);
   _decodedFrameCallback.SetUserReceiveCallback(receiveCallback);
   return VCM_OK;
 }
 
 int32_t VideoReceiver::RegisterReceiveStatisticsCallback(
     VCMReceiveStatisticsCallback* receiveStats) {
-  CriticalSectionScoped cs(process_crit_sect_.get());
+  rtc::CritScope cs(&process_crit_);
   _receiver.RegisterStatsCallback(receiveStats);
   _receiveStatsCallback = receiveStats;
   return VCM_OK;
@@ -225,7 +209,7 @@ int32_t VideoReceiver::RegisterReceiveStatisticsCallback(
 
 int32_t VideoReceiver::RegisterDecoderTimingCallback(
     VCMDecoderTimingCallback* decoderTiming) {
-  CriticalSectionScoped cs(process_crit_sect_.get());
+  rtc::CritScope cs(&process_crit_);
   _decoderTimingCallback = decoderTiming;
   return VCM_OK;
 }
@@ -233,10 +217,10 @@ int32_t VideoReceiver::RegisterDecoderTimingCallback(
 // Register an externally defined decoder object.
 void VideoReceiver::RegisterExternalDecoder(VideoDecoder* externalDecoder,
                                             uint8_t payloadType) {
-  CriticalSectionScoped cs(_receiveCritSect);
-  if (externalDecoder == NULL) {
+  rtc::CritScope cs(&receive_crit_);
+  if (externalDecoder == nullptr) {
     // Make sure the VCM updates the decoder next time it decodes.
-    _decoder = NULL;
+    _decoder = nullptr;
     RTC_CHECK(_codecDataBase.DeregisterExternalDecoder(payloadType));
     return;
   }
@@ -246,21 +230,21 @@ void VideoReceiver::RegisterExternalDecoder(VideoDecoder* externalDecoder,
 // Register a frame type request callback.
 int32_t VideoReceiver::RegisterFrameTypeCallback(
     VCMFrameTypeCallback* frameTypeCallback) {
-  CriticalSectionScoped cs(process_crit_sect_.get());
+  rtc::CritScope cs(&process_crit_);
   _frameTypeCallback = frameTypeCallback;
   return VCM_OK;
 }
 
 int32_t VideoReceiver::RegisterPacketRequestCallback(
     VCMPacketRequestCallback* callback) {
-  CriticalSectionScoped cs(process_crit_sect_.get());
+  rtc::CritScope cs(&process_crit_);
   _packetRequestCallback = callback;
   return VCM_OK;
 }
 
 int VideoReceiver::RegisterRenderBufferSizeCallback(
     VCMRenderBufferSizeCallback* callback) {
-  CriticalSectionScoped cs(process_crit_sect_.get());
+  rtc::CritScope cs(&process_crit_);
   render_buffer_callback_ = callback;
   return VCM_OK;
 }
@@ -275,7 +259,7 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
   int64_t nextRenderTimeMs;
   bool prefer_late_decoding = false;
   {
-    CriticalSectionScoped cs(_receiveCritSect);
+    rtc::CritScope cs(&receive_crit_);
     prefer_late_decoding = _codecDataBase.PrefersLateDecoding();
   }
 
@@ -286,7 +270,7 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
     return VCM_FRAME_NOT_READY;
 
   {
-    CriticalSectionScoped cs(process_crit_sect_.get());
+    rtc::CritScope cs(&process_crit_);
     if (drop_frames_until_keyframe_) {
       // Still getting delta frames, schedule another keyframe request as if
       // decode failed.
@@ -298,11 +282,6 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
       drop_frames_until_keyframe_ = false;
     }
   }
-  CriticalSectionScoped cs(_receiveCritSect);
-
-  // If this frame was too late, we should adjust the delay accordingly
-  _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
-                             clock_->TimeInMilliseconds());
 
   if (pre_decode_image_callback_) {
     EncodedImage encoded_image(frame->EncodedImage());
@@ -311,18 +290,13 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
       encoded_image.qp_ = qp;
     }
     pre_decode_image_callback_->Encoded(encoded_image, frame->CodecSpecific(),
-                                        NULL);
+                                        nullptr);
   }
 
-#ifdef DEBUG_DECODER_BIT_STREAM
-  if (_bitStreamBeforeDecoder != NULL) {
-    // Write bit stream to file for debugging purposes
-    if (fwrite(frame->Buffer(), 1, frame->Length(), _bitStreamBeforeDecoder) !=
-        frame->Length()) {
-      return -1;
-    }
-  }
-#endif
+  rtc::CritScope cs(&receive_crit_);
+  // If this frame was too late, we should adjust the delay accordingly
+  _timing.UpdateCurrentDelay(frame->RenderTimeMs(),
+                             clock_->TimeInMilliseconds());
 
   if (first_frame_received_()) {
     LOG(LS_INFO) << "Received first "
@@ -338,8 +312,8 @@ int32_t VideoReceiver::Decode(uint16_t maxWaitTimeMs) {
 int32_t VideoReceiver::RequestSliceLossIndication(
     const uint64_t pictureID) const {
   TRACE_EVENT1("webrtc", "RequestSLI", "picture_id", pictureID);
-  CriticalSectionScoped cs(process_crit_sect_.get());
-  if (_frameTypeCallback != NULL) {
+  rtc::CritScope cs(&process_crit_);
+  if (_frameTypeCallback != nullptr) {
     const int32_t ret =
         _frameTypeCallback->SliceLossIndicationRequest(pictureID);
     if (ret < 0) {
@@ -353,8 +327,8 @@ int32_t VideoReceiver::RequestSliceLossIndication(
 
 int32_t VideoReceiver::RequestKeyFrame() {
   TRACE_EVENT0("webrtc", "RequestKeyFrame");
-  CriticalSectionScoped process_cs(process_crit_sect_.get());
-  if (_frameTypeCallback != NULL) {
+  rtc::CritScope cs(&process_crit_);
+  if (_frameTypeCallback != nullptr) {
     const int32_t ret = _frameTypeCallback->RequestKeyFrame();
     if (ret < 0) {
       return ret;
@@ -372,7 +346,7 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
                           "type", frame.FrameType());
   // Change decoder if payload type has changed
   _decoder = _codecDataBase.GetDecoder(frame, &_decodedFrameCallback);
-  if (_decoder == NULL) {
+  if (_decoder == nullptr) {
     return VCM_NO_CODEC_REGISTERED;
   }
   // Decode a frame
@@ -396,7 +370,7 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
     ret = VCM_OK;
   }
   if (request_key_frame) {
-    CriticalSectionScoped cs(process_crit_sect_.get());
+    rtc::CritScope cs(&process_crit_);
     _scheduleKeyRequest = true;
   }
   TRACE_EVENT_ASYNC_END0("webrtc", "Video", frame.TimeStamp());
@@ -407,8 +381,8 @@ int32_t VideoReceiver::Decode(const VCMEncodedFrame& frame) {
 int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
                                             int32_t numberOfCores,
                                             bool requireKeyFrame) {
-  CriticalSectionScoped cs(_receiveCritSect);
-  if (receiveCodec == NULL) {
+  rtc::CritScope cs(&receive_crit_);
+  if (receiveCodec == nullptr) {
     return VCM_PARAMETER_ERROR;
   }
   if (!_codecDataBase.RegisterReceiveCodec(receiveCodec, numberOfCores,
@@ -420,8 +394,8 @@ int32_t VideoReceiver::RegisterReceiveCodec(const VideoCodec* receiveCodec,
 
 // Get current received codec
 int32_t VideoReceiver::ReceiveCodec(VideoCodec* currentReceiveCodec) const {
-  CriticalSectionScoped cs(_receiveCritSect);
-  if (currentReceiveCodec == NULL) {
+  rtc::CritScope cs(&receive_crit_);
+  if (currentReceiveCodec == nullptr) {
     return VCM_PARAMETER_ERROR;
   }
   return _codecDataBase.ReceiveCodec(currentReceiveCodec) ? 0 : -1;
@@ -429,7 +403,7 @@ int32_t VideoReceiver::ReceiveCodec(VideoCodec* currentReceiveCodec) const {
 
 // Get current received codec
 VideoCodecType VideoReceiver::ReceiveCodec() const {
-  CriticalSectionScoped cs(_receiveCritSect);
+  rtc::CritScope cs(&receive_crit_);
   return _codecDataBase.ReceiveCodec();
 }
 
@@ -441,7 +415,7 @@ int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
     TRACE_EVENT1("webrtc", "VCM::PacketKeyFrame", "seqnum",
                  rtpInfo.header.sequenceNumber);
   }
-  if (incomingPayload == NULL) {
+  if (incomingPayload == nullptr) {
     // The jitter buffer doesn't handle non-zero payload lengths for packets
     // without payload.
     // TODO(holmer): We should fix this in the jitter buffer.
@@ -450,11 +424,12 @@ int32_t VideoReceiver::IncomingPacket(const uint8_t* incomingPayload,
   const VCMPacket packet(incomingPayload, payloadLength, rtpInfo);
   int32_t ret = _receiver.InsertPacket(packet, rtpInfo.type.Video.width,
                                        rtpInfo.type.Video.height);
+
   // TODO(holmer): Investigate if this somehow should use the key frame
   // request scheduling to throttle the requests.
   if (ret == VCM_FLUSH_INDICATOR) {
     {
-      CriticalSectionScoped process_cs(process_crit_sect_.get());
+      rtc::CritScope cs(&process_crit_);
       drop_frames_until_keyframe_ = true;
     }
     RequestKeyFrame();
@@ -491,7 +466,7 @@ uint32_t VideoReceiver::DiscardedPackets() const {
 int VideoReceiver::SetReceiverRobustnessMode(
     ReceiverRobustness robustnessMode,
     VCMDecodeErrorMode decode_error_mode) {
-  CriticalSectionScoped cs(_receiveCritSect);
+  rtc::CritScope cs(&receive_crit_);
   switch (robustnessMode) {
     case VideoCodingModule::kNone:
       _receiver.SetNackMode(kNoNack, -1, -1);
@@ -527,7 +502,7 @@ int VideoReceiver::SetReceiverRobustnessMode(
 }
 
 void VideoReceiver::SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode) {
-  CriticalSectionScoped cs(_receiveCritSect);
+  rtc::CritScope cs(&receive_crit_);
   _receiver.SetDecodeErrorMode(decode_error_mode);
 }
 
@@ -535,7 +510,7 @@ void VideoReceiver::SetNackSettings(size_t max_nack_list_size,
                                     int max_packet_age_to_nack,
                                     int max_incomplete_time_ms) {
   if (max_nack_list_size != 0) {
-    CriticalSectionScoped process_cs(process_crit_sect_.get());
+    rtc::CritScope cs(&process_crit_);
     max_nack_list_size_ = max_nack_list_size;
   }
   _receiver.SetNackSettings(max_nack_list_size, max_packet_age_to_nack,
@@ -546,11 +521,5 @@ 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