Wire up currently-received video codec to stats.

webrtc/video_engine/vie_channel.cc

 /*
  *  Copyright (c) 2012 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 87 matching lines @@
       module_process_thread_(module_process_thread),
       crit_(CriticalSectionWrapper::CreateCriticalSection()),
       send_payload_router_(new PayloadRouter()),
       vcm_protection_callback_(new ViEChannelProtectionCallback(this)),
       vcm_(VideoCodingModule::Create(Clock::GetRealTimeClock(),
                                      nullptr,
                                      nullptr)),
       vie_receiver_(channel_id, vcm_, remote_bitrate_estimator, this),
       vie_sync_(vcm_),
       stats_observer_(new ChannelStatsObserver(this)),
-      vcm_receive_stats_callback_(NULL),
+      receive_stats_callback_(nullptr),
       incoming_video_stream_(nullptr),
-      codec_observer_(NULL),
       intra_frame_observer_(intra_frame_observer),
       rtt_stats_(rtt_stats),
       paced_sender_(paced_sender),
       packet_router_(packet_router),
       bandwidth_observer_(bandwidth_observer),
       send_time_observer_(send_time_observer),
-      decoder_reset_(true),
       nack_history_size_sender_(kSendSidePacketHistorySize),
       max_nack_reordering_threshold_(kMaxPacketAgeToNack),
       pre_render_callback_(NULL),
       report_block_stats_sender_(new ReportBlockStats()),
       time_of_first_rtt_ms_(-1),
       rtt_sum_ms_(0),
       num_rtts_(0),
       rtp_rtcp_modules_(
           CreateRtpRtcpModules(ViEModuleId(engine_id_, channel_id_),
                                !sender,
@@ skipping 302 matching lines @@
       video_codec.codecType != kVideoCodecULPFEC) {
     // Register codec type with VCM, but do not register RED or ULPFEC.
     if (vcm_->RegisterReceiveCodec(&video_codec, number_of_cores_, false) !=
         VCM_OK) {
       return -1;
     }
   }
   return 0;
 }
 
-int32_t ViEChannel::RegisterCodecObserver(ViEDecoderObserver* observer) {
-  CriticalSectionScoped cs(crit_.get());
-  if (observer) {
-    if (codec_observer_) {
-      LOG_F(LS_ERROR) << "Observer already registered.";
-      return -1;
-    }
-    codec_observer_ = observer;
-  } else {
-    codec_observer_ = NULL;
-  }
-  return 0;
-}
-
 int32_t ViEChannel::RegisterExternalDecoder(const uint8_t pl_type,
                                             VideoDecoder* decoder,
                                             bool buffered_rendering,
                                             int32_t render_delay) {
   DCHECK(!sender_);
   int32_t result;
   result = vcm_->RegisterExternalDecoder(decoder, pl_type, buffered_rendering);
   if (result != VCM_OK) {
     return result;
   }
@@ skipping 571 matching lines @@
   return stats_observer_.get();
 }
 
 // Do not acquire the lock of |vcm_| in this function. Decode callback won't
 // necessarily be called from the decoding thread. The decoding thread may have
 // held the lock when calling VideoDecoder::Decode, Reset, or Release. Acquiring
 // the same lock in the path of decode callback can deadlock.
 int32_t ViEChannel::FrameToRender(VideoFrame& video_frame) {  // NOLINT
   CriticalSectionScoped cs(crit_.get());
 
-  if (decoder_reset_) {
-    // Trigger a callback to the user if the incoming codec has changed.
-    if (codec_observer_) {
-      // The codec set by RegisterReceiveCodec might not be the size we're
-      // actually decoding.
-      receive_codec_.width = static_cast<uint16_t>(video_frame.width());
-      receive_codec_.height = static_cast<uint16_t>(video_frame.height());
-      codec_observer_->IncomingCodecChanged(channel_id_, receive_codec_);
-    }
-    decoder_reset_ = false;
-  }
-
   if (pre_render_callback_ != NULL)
     pre_render_callback_->FrameCallback(&video_frame);
 
   incoming_video_stream_->RenderFrame(channel_id_, video_frame);
   return 0;
 }
 
 int32_t ViEChannel::ReceivedDecodedReferenceFrame(
   const uint64_t picture_id) {
   return rtp_rtcp_modules_[0]->SendRTCPReferencePictureSelection(picture_id);
 }
 
-void ViEChannel::IncomingCodecChanged(const VideoCodec& codec) {
+void ViEChannel::OnIncomingPayloadType(int payload_type) {
   CriticalSectionScoped cs(crit_.get());
-  receive_codec_ = codec;
+  if (receive_stats_callback_)
+    receive_stats_callback_->OnIncomingPayloadType(payload_type);
 }
 
 void ViEChannel::OnReceiveRatesUpdated(uint32_t bit_rate, uint32_t frame_rate) {
   CriticalSectionScoped cs(crit_.get());
-  if (codec_observer_)
-    codec_observer_->IncomingRate(channel_id_, frame_rate, bit_rate);
+  if (receive_stats_callback_)
+    receive_stats_callback_->OnIncomingRate(frame_rate, bit_rate);
 }
 
 void ViEChannel::OnDiscardedPacketsUpdated(int discarded_packets) {
   CriticalSectionScoped cs(crit_.get());
-  if (vcm_receive_stats_callback_ != NULL)
-    vcm_receive_stats_callback_->OnDiscardedPacketsUpdated(discarded_packets);
+  if (receive_stats_callback_)
+    receive_stats_callback_->OnDiscardedPacketsUpdated(discarded_packets);
 }
 
 void ViEChannel::OnFrameCountsUpdated(const FrameCounts& frame_counts) {
   CriticalSectionScoped cs(crit_.get());
   receive_frame_counts_ = frame_counts;
-  if (vcm_receive_stats_callback_ != NULL)
-    vcm_receive_stats_callback_->OnFrameCountsUpdated(frame_counts);
+  if (receive_stats_callback_)
+    receive_stats_callback_->OnFrameCountsUpdated(frame_counts);
 }
 
 void ViEChannel::OnDecoderTiming(int decode_ms,
                                  int max_decode_ms,
                                  int current_delay_ms,
                                  int target_delay_ms,
                                  int jitter_buffer_ms,
                                  int min_playout_delay_ms,
                                  int render_delay_ms) {
   CriticalSectionScoped cs(crit_.get());
-  if (!codec_observer_)
+  if (!receive_stats_callback_)
     return;
-  codec_observer_->DecoderTiming(decode_ms,
-                                 max_decode_ms,
-                                 current_delay_ms,
-                                 target_delay_ms,
-                                 jitter_buffer_ms,
-                                 min_playout_delay_ms,
-                                 render_delay_ms);
+  receive_stats_callback_->OnDecoderTiming(
+      decode_ms, max_decode_ms, current_delay_ms, target_delay_ms,
+      jitter_buffer_ms, min_playout_delay_ms, render_delay_ms);
 }
 
 int32_t ViEChannel::RequestKeyFrame() {
   return rtp_rtcp_modules_[0]->RequestKeyFrame();
 }
 
 int32_t ViEChannel::SliceLossIndicationRequest(
   const uint64_t picture_id) {
   return rtp_rtcp_modules_[0]->SendRTCPSliceLossIndication(
       static_cast<uint8_t>(picture_id));
@@ skipping 134 matching lines @@
     I420FrameCallback* pre_render_callback) {
   CriticalSectionScoped cs(crit_.get());
   pre_render_callback_ = pre_render_callback;
 }
 
 void ViEChannel::RegisterPreDecodeImageCallback(
     EncodedImageCallback* pre_decode_callback) {
   vcm_->RegisterPreDecodeImageCallback(pre_decode_callback);
 }
 
+// TODO(pbos): Remove OnInitializeDecoder which is called from the RTP module,
+// any decoder resetting should be handled internally within the VCM.
 int32_t ViEChannel::OnInitializeDecoder(
     const int32_t id,
     const int8_t payload_type,
     const char payload_name[RTP_PAYLOAD_NAME_SIZE],
     const int frequency,
     const uint8_t channels,
     const uint32_t rate) {
   LOG(LS_INFO) << "OnInitializeDecoder " << static_cast<int>(payload_type)
                << " " << payload_name;
   vcm_->ResetDecoder();
 
-  CriticalSectionScoped cs(crit_.get());
-  decoder_reset_ = true;
   return 0;
 }
 
 void ViEChannel::OnIncomingSSRCChanged(const int32_t id, const uint32_t ssrc) {
   DCHECK_EQ(channel_id_, ChannelId(id));
   rtp_rtcp_modules_[0]->SetRemoteSSRC(ssrc);
 }
 
 void ViEChannel::OnIncomingCSRCChanged(const int32_t id,
                                        const uint32_t CSRC,
                                        const bool added) {
   DCHECK_EQ(channel_id_, ChannelId(id));
   CriticalSectionScoped cs(crit_.get());
 }
 
 void ViEChannel::RegisterSendFrameCountObserver(
     FrameCountObserver* observer) {
   send_frame_count_observer_.Set(observer);
 }
 
 void ViEChannel::RegisterReceiveStatisticsProxy(
     ReceiveStatisticsProxy* receive_statistics_proxy) {
   CriticalSectionScoped cs(crit_.get());
-  vcm_receive_stats_callback_ = receive_statistics_proxy;
+  receive_stats_callback_ = receive_statistics_proxy;
 }
 
 void ViEChannel::SetIncomingVideoStream(
     IncomingVideoStream* incoming_video_stream) {
   CriticalSectionScoped cs(crit_.get());
   incoming_video_stream_ = incoming_video_stream;
 }
 }  // namespace webrtc