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

webrtc/video/video_receive_stream.cc

 /*
  *  Copyright (c) 2013 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 "webrtc/video/video_receive_stream.h"
 
 #include <stdlib.h>
 
 #include <set>
 #include <string>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
+#include "webrtc/modules/video_coding/utility/ivf_file_writer.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/receive_statistics_proxy.h"
 #include "webrtc/video/vie_remb.h"
 #include "webrtc/video_receive_stream.h"
 
 namespace webrtc {
 
+static const bool kEnableFrameRecording = false;
+
 static bool UseSendSideBwe(const VideoReceiveStream::Config& config) {
   if (!config.rtp.transport_cc)
     return false;
   for (const auto& extension : config.rtp.extensions) {
     if (extension.name == RtpExtension::kTransportSequenceNumber)
       return true;
   }
   return false;
 }
 
@@ skipping 114 matching lines @@
       process_thread_(process_thread),
       clock_(Clock::GetRealTimeClock()),
       decode_thread_(DecodeThreadFunction, this, "DecodingThread"),
       congestion_controller_(congestion_controller),
       call_stats_(call_stats),
       remb_(remb),
       vcm_(VideoCodingModule::Create(clock_,
                                      nullptr,
                                      nullptr,
                                      this,
+                                     this,
                                      this)),
       incoming_video_stream_(0, config.disable_prerenderer_smoothing),
       stats_proxy_(config_, clock_),
       vie_channel_(&transport_adapter_,
                    process_thread,
                    nullptr,
                    vcm_.get(),
                    nullptr,
                    nullptr,
                    nullptr,
@@ skipping 107 matching lines @@
 
     VideoCodec codec = CreateDecoderVideoCodec(decoder);
 
     RTC_CHECK(vie_receiver_->SetReceiveCodec(codec));
     RTC_CHECK_EQ(VCM_OK,
                  vcm_->RegisterReceiveCodec(&codec, num_cpu_cores, false));
   }
 
   vcm_->SetRenderDelay(config.render_delay_ms);
   incoming_video_stream_.SetExpectedRenderDelay(config.render_delay_ms);
-  vcm_->RegisterPreDecodeImageCallback(this);
   incoming_video_stream_.SetExternalCallback(this);
   vie_channel_.SetIncomingVideoStream(&incoming_video_stream_);
   vie_channel_.RegisterPreRenderCallback(this);
 
   process_thread_->RegisterModule(vcm_.get());
   process_thread_->RegisterModule(&vie_sync_);
 }
 
 VideoReceiveStream::~VideoReceiveStream() {
   LOG(LS_INFO) << "~VideoReceiveStream: " << config_.ToString();
   Stop();
 
   process_thread_->DeRegisterModule(&vie_sync_);
   process_thread_->DeRegisterModule(vcm_.get());
 
   // Deregister external decoders so that they are no longer running during
   // destruction. This effectively stops the VCM since the decoder thread is
   // stopped, the VCM is deregistered and no asynchronous decoder threads are
   // running.
   for (const Decoder& decoder : config_.decoders)
     vcm_->RegisterExternalDecoder(nullptr, decoder.payload_type);
 
   vie_channel_.RegisterPreRenderCallback(nullptr);
-  vcm_->RegisterPreDecodeImageCallback(nullptr);
 
   call_stats_->DeregisterStatsObserver(vie_channel_.GetStatsObserver());
   rtp_rtcp_->SetREMBStatus(false);
   remb_->RemoveReceiveChannel(rtp_rtcp_);
 
   congestion_controller_->GetRemoteBitrateEstimator(UseSendSideBwe(config_))
       ->RemoveStream(vie_receiver_->GetRemoteSsrc());
 }
 
 void VideoReceiveStream::Start() {
@@ skipping 71 matching lines @@
 int32_t VideoReceiveStream::Encoded(
     const EncodedImage& encoded_image,
     const CodecSpecificInfo* codec_specific_info,
     const RTPFragmentationHeader* fragmentation) {
   stats_proxy_.OnPreDecode(encoded_image, codec_specific_info);
   if (config_.pre_decode_callback) {
     // TODO(asapersson): Remove EncodedFrameCallbackAdapter.
     encoded_frame_proxy_.Encoded(
         encoded_image, codec_specific_info, fragmentation);
   }
+  if (kEnableFrameRecording) {
+    if (!ivf_writer_.get()) {
+      RTC_DCHECK(codec_specific_info);
+      RtpVideoCodecTypes rtp_codec_type;
+      switch (codec_specific_info->codecType) {
+        case kVideoCodecVP8:
+          rtp_codec_type = kRtpVideoVp8;
+          break;
+        case kVideoCodecVP9:
+          rtp_codec_type = kRtpVideoVp9;
+          break;
+        case kVideoCodecH264:
+          rtp_codec_type = kRtpVideoH264;
+          break;
+        default:
+          rtp_codec_type = kRtpVideoNone;
+          RTC_NOTREACHED() << "Unsupported codec "
+                           << codec_specific_info->codecType;
+      }
+      std::ostringstream oss;
+      oss << "receive_bitstream_ssrc_" << config_.rtp.remote_ssrc << ".ivf";
+      ivf_writer_ = IvfFileWriter::Open(oss.str(), rtp_codec_type);
+    }
+    if (ivf_writer_.get()) {
+      bool ok = ivf_writer_->WriteFrame(encoded_image);
+      RTC_DCHECK(ok);
+    }
+  }
+
   return 0;
 }
 
 void VideoReceiveStream::SignalNetworkState(NetworkState state) {
   rtp_rtcp_->SetRTCPStatus(state == kNetworkUp ? config_.rtp.rtcp_mode
                                                : RtcpMode::kOff);
 }
 
 bool VideoReceiveStream::DecodeThreadFunction(void* ptr) {
   static_cast<VideoReceiveStream*>(ptr)->Decode();
   return true;
 }
 
 void VideoReceiveStream::Decode() {
   static const int kMaxDecodeWaitTimeMs = 50;
   vcm_->Decode(kMaxDecodeWaitTimeMs);
 }
 
 void VideoReceiveStream::SendNack(
     const std::vector<uint16_t>& sequence_numbers) {
   rtp_rtcp_->SendNack(sequence_numbers);
 }
 
 void VideoReceiveStream::RequestKeyFrame() {
   rtp_rtcp_->RequestKeyFrame();
 }
 
 }  // namespace internal
 }  // namespace webrtc