Expose RtpCodecParameters to VideoMediaInfo stats.

webrtc/media/engine/webrtcvideoengine2.cc

 /*
  *  Copyright (c) 2014 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 1324 matching lines @@
   int64_t now_ms = rtc::TimeMillis();
   if (last_stats_log_ms_ == -1 ||
       now_ms - last_stats_log_ms_ > kStatsLogIntervalMs) {
     last_stats_log_ms_ = now_ms;
     log_stats = true;
   }
 
   info->Clear();
   FillSenderStats(info, log_stats);
   FillReceiverStats(info, log_stats);
+  FillSendAndReceiveCodecStats(info);
   webrtc::Call::Stats stats = call_->GetStats();
   FillBandwidthEstimationStats(stats, info);
   if (stats.rtt_ms != -1) {
     for (size_t i = 0; i < info->senders.size(); ++i) {
       info->senders[i].rtt_ms = stats.rtt_ms;
     }
   }
 
   if (log_stats)
     LOG(LS_INFO) << stats.ToString(now_ms);
@@ skipping 34 matching lines @@
   // Get send stream bitrate stats.
   rtc::CritScope stream_lock(&stream_crit_);
   for (std::map<uint32_t, WebRtcVideoSendStream*>::iterator stream =
            send_streams_.begin();
        stream != send_streams_.end(); ++stream) {
     stream->second->FillBandwidthEstimationInfo(&bwe_info);
   }
   video_media_info->bw_estimations.push_back(bwe_info);
 }
 
+void WebRtcVideoChannel2::FillSendAndReceiveCodecStats(
+    VideoMediaInfo* video_media_info) {
+  // Codec parameters are fetched from streams and from a common list. The
+  // payload type -> parameters maps ensure that there are no duplicates based
+  // on direction and payload type.
+  {
+    // Stream-specific codec parameters
+    rtc::CritScope stream_lock(&stream_crit_);
+    for (const std::pair<uint32_t, WebRtcVideoSendStream*>& pair :
+         send_streams_) {
+      webrtc::RtpParameters stream_params = pair.second->GetRtpParameters();
+      for (const webrtc::RtpCodecParameters& codec_params :
+           stream_params.codecs) {
+        video_media_info->send_codecs.insert(
+            std::make_pair(codec_params.payload_type, codec_params));
+      }
+    }
+    for (const std::pair<uint32_t, WebRtcVideoReceiveStream*>& pair :
+         receive_streams_) {
+      for (const webrtc::VideoReceiveStream::Decoder& decoder :
+           pair.second->config().decoders) {
+        VideoCodec codec(decoder.payload_type, decoder.payload_name);
+        webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
+        video_media_info->receive_codecs.insert(
+            std::make_pair(codec_params.payload_type, codec_params));
+      }
+    }
+  }

[Taylor Brandstetter, 2016/11/08 23:55:44]

I think you can delete this block, since there shouldn't be any difference
between the stream-specific codec and the common one. GetRtpParameters doesn't
even fill any codecs in.

[hbos, 2016/11/11 11:20:05]

Oh, that makes things simpler. Done.

+  // Common codec parameters
+  for (const VideoCodec& codec : send_params_.codecs) {
+    webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
+    video_media_info->send_codecs.insert(
+        std::make_pair(codec_params.payload_type, codec_params));
+  }
+  for (const VideoCodec& codec : recv_params_.codecs) {
+    webrtc::RtpCodecParameters codec_params = codec.ToCodecParameters();
+    video_media_info->receive_codecs.insert(
+        std::make_pair(codec_params.payload_type, codec_params));
+  }
+}
+
 void WebRtcVideoChannel2::OnPacketReceived(
     rtc::CopyOnWriteBuffer* packet,
     const rtc::PacketTime& packet_time) {
   const webrtc::PacketTime webrtc_packet_time(packet_time.timestamp,
                                               packet_time.not_before);
   const webrtc::PacketReceiver::DeliveryStatus delivery_result =
       call_->Receiver()->DeliverPacket(
           webrtc::MediaType::VIDEO,
           packet->cdata(), packet->size(),
           webrtc_packet_time);
@@ skipping 584 matching lines @@
   }
 }
 
 VideoSenderInfo WebRtcVideoChannel2::WebRtcVideoSendStream::GetVideoSenderInfo(
     bool log_stats) {
   VideoSenderInfo info;
   RTC_DCHECK_RUN_ON(&thread_checker_);
   for (uint32_t ssrc : parameters_.config.rtp.ssrcs)
     info.add_ssrc(ssrc);
 
-  if (parameters_.codec_settings)
+  if (parameters_.codec_settings) {
     info.codec_name = parameters_.codec_settings->codec.name;
+    info.codec_payload_type = rtc::Optional<uint32_t>(
+        static_cast<uint32_t>(parameters_.codec_settings->codec.id));
+  }
 
   if (stream_ == NULL)
     return info;
 
   webrtc::VideoSendStream::Stats stats = stream_->GetStats();
 
   if (log_stats)
     LOG(LS_INFO) << stats.ToString(rtc::TimeMillis());
 
   info.adapt_changes = stats.number_of_cpu_adapt_changes;
@@ skipping 395 matching lines @@
 }
 
 VideoReceiverInfo
 WebRtcVideoChannel2::WebRtcVideoReceiveStream::GetVideoReceiverInfo(
     bool log_stats) {
   VideoReceiverInfo info;
   info.ssrc_groups = stream_params_.ssrc_groups;
   info.add_ssrc(config_.rtp.remote_ssrc);
   webrtc::VideoReceiveStream::Stats stats = stream_->GetStats();
   info.decoder_implementation_name = stats.decoder_implementation_name;
+  if (stats.current_payload_type != -1) {
+    info.codec_payload_type = rtc::Optional<uint32_t>(
+        static_cast<uint32_t>(stats.current_payload_type));
+  }
   info.bytes_rcvd = stats.rtp_stats.transmitted.payload_bytes +
                     stats.rtp_stats.transmitted.header_bytes +
                     stats.rtp_stats.transmitted.padding_bytes;
   info.packets_rcvd = stats.rtp_stats.transmitted.packets;
   info.packets_lost = stats.rtcp_stats.cumulative_lost;
   info.fraction_lost =
       static_cast<float>(stats.rtcp_stats.fraction_lost) / (1 << 8);
 
   info.framerate_rcvd = stats.network_frame_rate;
   info.framerate_decoded = stats.decode_frame_rate;
@@ skipping 144 matching lines @@
         rtx_mapping[video_codecs[i].codec.id] !=
             ulpfec_config.red_payload_type) {
       video_codecs[i].rtx_payload_type = rtx_mapping[video_codecs[i].codec.id];
     }
   }
 
   return video_codecs;
 }
 
 }  // namespace cricket