Log configs when creating video streams in Call.

Adds VideoReceiveStream::Config::ToString and logs configs in both
Call::CreateVideoSendStream and Call::CreateVideoReceiverStream.

R=mflodman@webrtc.org
BUG=1667

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

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

webrtc/video/call.cc

@@ -22,6 +22,7 @@
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/system_wrappers/interface/rw_lock_wrapper.h"
 #include "webrtc/system_wrappers/interface/scoped_ptr.h"
 #include "webrtc/system_wrappers/interface/trace.h"
@@ -219,6 +220,7 @@ PacketReceiver* Call::Receiver() { return this; }
 VideoSendStream* Call::CreateVideoSendStream(
     const VideoSendStream::Config& config,
     const VideoEncoderConfig& encoder_config) {
+  LOG(LS_INFO) << "CreateVideoSendStream: " << config.ToString();
   assert(config.rtp.ssrcs.size() > 0);
 
   // TODO(mflodman): Base the start bitrate on a current bandwidth estimate, if
@@ -274,6 +276,7 @@ void Call::DestroyVideoSendStream(webrtc::VideoSendStream* send_stream) {
 
 VideoReceiveStream* Call::CreateVideoReceiveStream(
     const VideoReceiveStream::Config& config) {
+  LOG(LS_INFO) << "CreateVideoReceiveStream: " << config.ToString();
   VideoReceiveStream* receive_stream =
       new VideoReceiveStream(video_engine_,
                              config,

webrtc/video/video_receive_stream.cc

@@ -31,6 +31,74 @@
 #include "webrtc/video_receive_stream.h"
 
 namespace webrtc {
+std::string VideoReceiveStream::Decoder::ToString() const {
+  std::stringstream ss;
+  ss << "{decoder: " << (decoder != NULL ? "(VideoDecoder)" : "NULL");
+  ss << ", payload_type: " << payload_type;
+  ss << ", payload_name: " << payload_name;
+  ss << ", is_renderer: " << (is_renderer ? "yes" : "no");
+  ss << ", expected_delay_ms: " << expected_delay_ms;
+  ss << '}';
+
+  return ss.str();
+}
+
+std::string VideoReceiveStream::Config::ToString() const {
+  std::stringstream ss;
+  ss << "{decoders: [";
+  for (size_t i = 0; i < decoders.size(); ++i) {
+    ss << decoders[i].ToString();
+    if (i != decoders.size() - 1)
+      ss << ", ";
+  }
+  ss << ']';
+  ss << ", rtp: " << rtp.ToString();
+  ss << ", renderer: " << (renderer != NULL ? "(renderer)" : "NULL");
+  ss << ", render_delay_ms: " << render_delay_ms;
+  ss << ", audio_channel_id: " << audio_channel_id;
+  ss << ", pre_decode_callback: "
+     << (pre_decode_callback != NULL ? "(EncodedFrameObserver)" : "NULL");
+  ss << ", pre_render_callback: "
+     << (pre_render_callback != NULL ? "(I420FrameCallback)" : "NULL");
+  ss << ", target_delay_ms: " << target_delay_ms;
+  ss << '}';
+
+  return ss.str();
+}
+
+std::string VideoReceiveStream::Config::Rtp::ToString() const {
+  std::stringstream ss;
+  ss << "{remote_ssrc: " << remote_ssrc;
+  ss << ", local_ssrc: " << local_ssrc;
+  ss << ", rtcp_mode: " << (rtcp_mode == newapi::kRtcpCompound
+                                ? "kRtcpCompound"
+                                : "kRtcpReducedSize");
+  ss << ", rtcp_xr: ";
+  ss << "{receiver_reference_time_report: "
+     << (rtcp_xr.receiver_reference_time_report ? "on" : "off");
+  ss << '}';
+  ss << ", remb: " << (remb ? "on" : "off");
+  ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
+  ss << ", fec: " << fec.ToString();
+  ss << ", rtx: {";
+  for (auto& kv : rtx) {
+    ss << kv.first << " -> ";
+    ss << "{ssrc: " << kv.second.ssrc;
+    ss << ", payload_type: " << kv.second.payload_type;
+    ss << '}';
+  }
+  ss << '}';
+  ss << ", extensions: [";
+  for (size_t i = 0; i < extensions.size(); ++i) {
+    ss << extensions[i].ToString();
+    if (i != extensions.size() - 1)
+      ss << ", ";
+  }
+  ss << ']';
+  ss << '}';
+  return ss.str();
+}
+
 namespace internal {
 namespace {
 VideoCodec CreateDecoderVideoCodec(const VideoReceiveStream::Decoder& decoder) {
@@ -173,11 +241,8 @@ VideoReceiveStream::VideoReceiveStream(webrtc::VideoEngine* video_engine,
   for (size_t i = 0; i < config_.decoders.size(); ++i) {
     const Decoder& decoder = config_.decoders[i];
     if (external_codec_->RegisterExternalReceiveCodec(
-            channel_,
+            channel_, decoder.payload_type, decoder.decoder,
-            decoder.payload_type,
+            decoder.is_renderer, decoder.expected_delay_ms) != 0) {
-            decoder.decoder,
-            decoder.renderer,
-            decoder.expected_delay_ms) != 0) {
       // TODO(pbos): Abort gracefully? Can this be a runtime error?
       abort();
     }

webrtc/video/video_send_stream.cc

@@ -33,8 +33,7 @@ VideoSendStream::Config::EncoderSettings::ToString() const {
   std::stringstream ss;
   ss << "{payload_name: " << payload_name;
   ss << ", payload_type: " << payload_type;
-  if (encoder != NULL)
+  ss << ", encoder: " << (encoder != NULL ? "(VideoEncoder)" : "NULL");
-    ss << ", encoder: " << (encoder != NULL ? "(encoder)" : "NULL");
   ss << '}';
   return ss.str();
 }
@@ -42,13 +41,13 @@ VideoSendStream::Config::EncoderSettings::ToString() const {
 std::string VideoSendStream::Config::Rtp::Rtx::ToString()
     const {
   std::stringstream ss;
-  ss << "{ssrcs: {";
+  ss << "{ssrcs: [";
   for (size_t i = 0; i < ssrcs.size(); ++i) {
     ss << ssrcs[i];
     if (i != ssrcs.size() - 1)
-      ss << "}, {";
+      ss << ", ";
   }
-  ss << '}';
+  ss << ']';
 
   ss << ", payload_type: " << payload_type;
   ss << '}';
@@ -57,31 +56,25 @@ std::string VideoSendStream::Config::Rtp::Rtx::ToString()
 
 std::string VideoSendStream::Config::Rtp::ToString() const {
   std::stringstream ss;
-  ss << "{ssrcs: {";
+  ss << "{ssrcs: [";
   for (size_t i = 0; i < ssrcs.size(); ++i) {
     ss << ssrcs[i];
     if (i != ssrcs.size() - 1)
-      ss << "}, {";
+      ss << ", ";
   }
-  ss << '}';
+  ss << ']';
-
   ss << ", max_packet_size: " << max_packet_size;
-
+  ss << ", extensions: [";
-  ss << ", extensions: {";
   for (size_t i = 0; i < extensions.size(); ++i) {
     ss << extensions[i].ToString();
     if (i != extensions.size() - 1)
-      ss << "}, {";
+      ss << ", ";
   }
-  ss << '}';
+  ss << ']';
 
-  if (nack.rtp_history_ms != 0)
+  ss << ", nack: {rtp_history_ms: " << nack.rtp_history_ms << '}';
-    ss << ", nack.rtp_history_ms: " << nack.rtp_history_ms;
-  if (fec.ulpfec_payload_type != -1 || fec.red_payload_type != -1)
   ss << ", fec: " << fec.ToString();
-  if (rtx.payload_type != 0 || !rtx.ssrcs.empty())
   ss << ", rtx: " << rtx.ToString();
-  if (c_name != "")
   ss << ", c_name: " << c_name;
   ss << '}';
   return ss.str();
@@ -91,17 +84,16 @@ std::string VideoSendStream::Config::ToString() const {
   std::stringstream ss;
   ss << "{encoder_settings: " << encoder_settings.ToString();
   ss << ", rtp: " << rtp.ToString();
-  if (pre_encode_callback != NULL)
+  ss << ", pre_encode_callback: "
-    ss << ", (pre_encode_callback)";
+     << (pre_encode_callback != NULL ? "(I420FrameCallback)" : "NULL");
-  if (post_encode_callback != NULL)
+  ss << ", post_encode_callback: "
-    ss << ", (post_encode_callback)";
+     << (post_encode_callback != NULL ? "(EncodedFrameObserver)" : "NULL");
-  if (local_renderer != NULL) {
+  ss << "local_renderer: " << (local_renderer != NULL ? "(VideoRenderer)"
-    ss << ", (local_renderer, render_delay_ms: " << render_delay_ms << ")";
+                                                      : "NULL");
-  }
+  ss << ", render_delay_ms: " << render_delay_ms;
-  if (target_delay_ms > 0)
   ss << ", target_delay_ms: " << target_delay_ms;
-  if (suspend_below_min_bitrate)
+  ss << ", suspend_below_min_bitrate: " << (suspend_below_min_bitrate ? "on"
-    ss << ", suspend_below_min_bitrate: on";
+                                                                      : "off");
   ss << '}';
   return ss.str();
 }

webrtc/video_receive_stream.h

@@ -39,8 +39,9 @@ class VideoReceiveStream {
     Decoder()
         : decoder(NULL),
           payload_type(0),
-          renderer(false),
+          is_renderer(false),
           expected_delay_ms(0) {}
+    std::string ToString() const;
 
     // The actual decoder instance.
     VideoDecoder* decoder;
@@ -54,7 +55,7 @@ class VideoReceiveStream {
     std::string payload_name;
 
     // 'true' if the decoder handles rendering as well.
-    bool renderer;
+    bool is_renderer;
 
     // The expected delay for decoding and rendering, i.e. the frame will be
     // delivered this many milliseconds, if possible, earlier than the ideal
@@ -89,6 +90,7 @@ class VideoReceiveStream {
           pre_decode_callback(NULL),
           pre_render_callback(NULL),
           target_delay_ms(0) {}
+    std::string ToString() const;
 
     // Decoders for every payload that we can receive.
     std::vector<Decoder> decoders;
@@ -100,6 +102,7 @@ class VideoReceiveStream {
             local_ssrc(0),
             rtcp_mode(newapi::kRtcpReducedSize),
             remb(true) {}
+      std::string ToString() const;
 
       // Synchronization source (stream identifier) to be received.
       uint32_t remote_ssrc;

webrtc/video_send_stream.h

@@ -70,7 +70,7 @@ class VideoSendStream {
 
       // Uninitialized VideoEncoder instance to be used for encoding. Will be
       // initialized from inside the VideoSendStream.
-      webrtc::VideoEncoder* encoder;
+      VideoEncoder* encoder;
     } encoder_settings;
 
     static const size_t kDefaultMaxPacketSize = 1500 - 40;  // TCP over IPv4.