Expose Ivf logging through the native API

webrtc/video/video_send_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_send_stream.h"
 
 #include <algorithm>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "webrtc/base/checks.h"
+#include "webrtc/base/file.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/bitrate_controller/include/bitrate_controller.h"
 #include "webrtc/modules/congestion_controller/include/congestion_controller.h"
 #include "webrtc/modules/pacing/packet_router.h"
 #include "webrtc/modules/rtp_rtcp/include/rtp_rtcp.h"
 #include "webrtc/modules/utility/include/process_thread.h"
 #include "webrtc/modules/video_coding/utility/ivf_file_writer.h"
 #include "webrtc/video/call_stats.h"
 #include "webrtc/video/vie_remb.h"
@@ skipping 231 matching lines @@
   void DeRegisterProcessThread();
 
   void SignalNetworkState(NetworkState state);
   bool DeliverRtcp(const uint8_t* packet, size_t length);
   void Start();
   void Stop();
 
   void SignalEncoderConfigurationChanged(const VideoEncoderConfig& config);
   VideoSendStream::RtpStateMap GetRtpStates() const;
 
+  void SetLogFiles(rtc::PlatformFile file1 = rtc::kInvalidPlatformFileValue,
+                   rtc::PlatformFile file2 = rtc::kInvalidPlatformFileValue,
+                   rtc::PlatformFile file3 = rtc::kInvalidPlatformFileValue);
+
  private:
   class CheckEncoderActivityTask;
 
   // Implements BitrateAllocatorObserver.
   uint32_t OnBitrateUpdated(uint32_t bitrate_bps,
                             uint8_t fraction_loss,
                             int64_t rtt) override;
 
   // Implements webrtc::VCMProtectionCallback.
   int ProtectionRequest(const FecProtectionParams* delta_params,
@@ skipping 24 matching lines @@
   rtc::TaskQueue* const worker_queue_;
 
   rtc::CriticalSection encoder_activity_crit_sect_;
   CheckEncoderActivityTask* check_encoder_activity_task_
       GUARDED_BY(encoder_activity_crit_sect_);
   CallStats* const call_stats_;
   CongestionController* const congestion_controller_;
   BitrateAllocator* const bitrate_allocator_;
   VieRemb* const remb_;
 
-  static const bool kEnableFrameRecording = false;
+  rtc::CriticalSection ivf_writers_crit_;
   static const int kMaxLayers = 3;
-  std::unique_ptr<IvfFileWriter> file_writers_[kMaxLayers];
+  std::unique_ptr<IvfFileWriter> file_writers_[kMaxLayers] GUARDED_BY(
+      ivf_writers_crit_);
 
   int max_padding_bitrate_;
   int encoder_min_bitrate_bps_;
   uint32_t encoder_max_bitrate_bps_;
   uint32_t encoder_target_rate_bps_;
 
   ViEEncoder* const vie_encoder_;
   EncoderStateFeedback encoder_feedback_;
   ProtectionBitrateCalculator protection_bitrate_calculator_;
 
@@ skipping 264 matching lines @@
           &state_map, std::move(send_stream_), &thread_sync_event_)));
   thread_sync_event_.Wait(rtc::Event::kForever);
   return state_map;
 }
 
 bool VideoSendStream::DeliverRtcp(const uint8_t* packet, size_t length) {
   // Called on a network thread.
   return send_stream_->DeliverRtcp(packet, length);
 }
 
+void VideoSendStream::SetLogFiles(rtc::PlatformFile file1,
+                                  rtc::PlatformFile file2,
+                                  rtc::PlatformFile file3) {
+  send_stream_->SetLogFiles(file1, file2, file3);
+}
+
 VideoSendStreamImpl::VideoSendStreamImpl(
     SendStatisticsProxy* stats_proxy,
     rtc::TaskQueue* worker_queue,
     CallStats* call_stats,
     CongestionController* congestion_controller,
     BitrateAllocator* bitrate_allocator,
     SendDelayStats* send_delay_stats,
     VieRemb* remb,
     ViEEncoder* vie_encoder,
     RtcEventLog* event_log,
@@ skipping 246 matching lines @@
   {
     rtc::CritScope lock(&encoder_activity_crit_sect_);
     if (check_encoder_activity_task_)
       check_encoder_activity_task_->UpdateEncoderActivity();
   }
 
   protection_bitrate_calculator_.UpdateWithEncodedData(encoded_image);
   EncodedImageCallback::Result result = payload_router_.OnEncodedImage(
       encoded_image, codec_specific_info, fragmentation);
 
-  if (kEnableFrameRecording) {
-    int layer = codec_specific_info->codecType == kVideoCodecVP8
-                    ? codec_specific_info->codecSpecific.VP8.simulcastIdx
-                    : 0;
-    IvfFileWriter* file_writer;
-    {
-      if (file_writers_[layer] == nullptr) {
-        std::ostringstream oss;
-        oss << "send_bitstream_ssrc";
-        for (uint32_t ssrc : config_->rtp.ssrcs)
-          oss << "_" << ssrc;
-        oss << "_layer" << layer << ".ivf";
-        file_writers_[layer] =
-            IvfFileWriter::Open(oss.str(), codec_specific_info->codecType);
-      }
-      file_writer = file_writers_[layer].get();
-    }
-    if (file_writer) {
-      bool ok = file_writer->WriteFrame(encoded_image);
+  RTC_DCHECK(codec_specific_info);
+
+  int layer = codec_specific_info->codecType == kVideoCodecVP8
+                  ? codec_specific_info->codecSpecific.VP8.simulcastIdx
+                  : 0;
+  {
+    rtc::CritScope lock(&ivf_writers_crit_);
+    if (file_writers_[layer].get()) {
+      bool ok = file_writers_[layer]->WriteFrame(
+          encoded_image, codec_specific_info->codecType);
       RTC_DCHECK(ok);
     }
   }
 
   return result;
 }
 
 void VideoSendStreamImpl::ConfigureProtection() {
   RTC_DCHECK_RUN_ON(worker_queue_);
   // Enable NACK, FEC or both.
@@ skipping 134 matching lines @@
       bitrate_bps, stats_proxy_->GetSendFrameRate(), fraction_loss, rtt);
   uint32_t protection_bitrate = bitrate_bps - encoder_target_rate_bps_;
 
   encoder_target_rate_bps_ =
       std::min(encoder_max_bitrate_bps_, encoder_target_rate_bps_);
   vie_encoder_->OnBitrateUpdated(encoder_target_rate_bps_, fraction_loss, rtt);
   stats_proxy_->OnSetEncoderTargetRate(encoder_target_rate_bps_);
   return protection_bitrate;
 }
 
+void VideoSendStreamImpl::SetLogFiles(rtc::PlatformFile file1,
+                                      rtc::PlatformFile file2,
+                                      rtc::PlatformFile file3) {
+  {
+    rtc::CritScope lock(&ivf_writers_crit_);
+    if (file1 == rtc::kInvalidPlatformFileValue) {
+      file_writers_[0].reset();
+    } else {
+      file_writers_[0] = IvfFileWriter::Wrap(rtc::File(file1));
+    }
+
+    if (file2 == rtc::kInvalidPlatformFileValue) {
+      file_writers_[1].reset();
+    } else {
+      file_writers_[1] = IvfFileWriter::Wrap(rtc::File(file2));
+    }
+
+    if (file3 == rtc::kInvalidPlatformFileValue) {
+      file_writers_[2].reset();
+    } else {
+      file_writers_[2] = IvfFileWriter::Wrap(rtc::File(file3));
+    }
+  }
+
+  if (file1 != rtc::kInvalidPlatformFileValue ||
+      file2 != rtc::kInvalidPlatformFileValue ||
+      file3 != rtc::kInvalidPlatformFileValue) {
+    vie_encoder_->SendKeyFrame();
+  }
+}
+
 int VideoSendStreamImpl::ProtectionRequest(
     const FecProtectionParams* delta_params,
     const FecProtectionParams* key_params,
     uint32_t* sent_video_rate_bps,
     uint32_t* sent_nack_rate_bps,
     uint32_t* sent_fec_rate_bps) {
   RTC_DCHECK_RUN_ON(worker_queue_);
   *sent_video_rate_bps = 0;
   *sent_nack_rate_bps = 0;
   *sent_fec_rate_bps = 0;
   for (RtpRtcp* rtp_rtcp : rtp_rtcp_modules_) {
     uint32_t not_used = 0;
     uint32_t module_video_rate = 0;
     uint32_t module_fec_rate = 0;
     uint32_t module_nack_rate = 0;
     rtp_rtcp->SetFecParameters(delta_params, key_params);
     rtp_rtcp->BitrateSent(&not_used, &module_video_rate, &module_fec_rate,
                           &module_nack_rate);
     *sent_video_rate_bps += module_video_rate;
     *sent_nack_rate_bps += module_nack_rate;
     *sent_fec_rate_bps += module_fec_rate;
   }
   return 0;
 }
 
 }  // namespace internal
 }  // namespace webrtc