Expose Ivf logging through the native API

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.
  */
 
@@ skipping 13 matching lines @@
 #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_receive_stream.h"
 #include "webrtc/voice_engine/include/voe_video_sync.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.uri == RtpExtension::kTransportSequenceNumberUri)
       return true;
   }
   return false;
 }
 
@@ skipping 312 matching lines @@
 EncodedImageCallback::Result VideoReceiveStream::OnEncodedImage(
     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) {
     config_.pre_decode_callback->EncodedFrameCallback(
         EncodedFrame(encoded_image._buffer, encoded_image._length,
                      encoded_image._frameType));
   }
-  if (kEnableFrameRecording) {
-    if (!ivf_writer_.get()) {
+  {
+    rtc::CritScope lock(&ivf_writer_lock_);
+    if (ivf_writer_.get()) {
       RTC_DCHECK(codec_specific_info);
-      std::ostringstream oss;
-      oss << "receive_bitstream_ssrc_" << config_.rtp.remote_ssrc << ".ivf";
-      ivf_writer_ =
-          IvfFileWriter::Open(oss.str(), codec_specific_info->codecType);
-    }
-    if (ivf_writer_.get()) {
-      bool ok = ivf_writer_->WriteFrame(encoded_image);
+      bool ok = ivf_writer_->WriteFrame(encoded_image,
+                                        codec_specific_info->codecType);
       RTC_DCHECK(ok);
     }
   }
 
   return Result(Result::OK, encoded_image._timeStamp);
 }
 
 bool VideoReceiveStream::DecodeThreadFunction(void* ptr) {
   static_cast<VideoReceiveStream*>(ptr)->Decode();
   return true;
 }
 
 void VideoReceiveStream::Decode() {
   static const int kMaxDecodeWaitTimeMs = 50;
   video_receiver_.Decode(kMaxDecodeWaitTimeMs);
 }
 
 void VideoReceiveStream::SendNack(
     const std::vector<uint16_t>& sequence_numbers) {
   rtp_stream_receiver_.RequestPacketRetransmit(sequence_numbers);
 }
 
+void VideoReceiveStream::EnableEncodedFrameRecording(rtc::PlatformFile file,
+                                                     size_t byte_limit) {
+  {
+    rtc::CritScope lock(&ivf_writer_lock_);
+    if (file == rtc::kInvalidPlatformFileValue) {
+      ivf_writer_.reset();
+    } else {
+      ivf_writer_ = IvfFileWriter::Wrap(rtc::File(file), byte_limit);
+    }
+  }
+
+  if (file != rtc::kInvalidPlatformFileValue) {
+    // Make a keyframe appear as early as possible in the logs, to give actually
+    // decodable output.
+    RequestKeyFrame();
+  }
+}
+
 void VideoReceiveStream::RequestKeyFrame() {
   rtp_stream_receiver_.RequestKeyFrame();
 }
 
 }  // namespace internal
 }  // namespace webrtc