Add stats for average QP per frame for VP8 (for received video streams).

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.
  */
 
 #include "webrtc/video/video_receive_stream.h"
 
 #include <stdlib.h>
 
 #include <string>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
 #include "webrtc/system_wrappers/interface/clock.h"
 #include "webrtc/system_wrappers/interface/logging.h"
 #include "webrtc/video/receive_statistics_proxy.h"
-#include "webrtc/video_encoder.h"
 #include "webrtc/video_receive_stream.h"
 
 namespace webrtc {
 std::string VideoReceiveStream::Decoder::ToString() const {
   std::stringstream ss;
   ss << "{decoder: " << (decoder != nullptr ? "(VideoDecoder)" : "nullptr");
   ss << ", payload_type: " << payload_type;
   ss << ", payload_name: " << payload_name;
   ss << ", is_renderer: " << (is_renderer ? "yes" : "no");
   ss << ", expected_delay_ms: " << expected_delay_ms;
@@ skipping 205 matching lines @@
     VideoCodec codec = CreateDecoderVideoCodec(decoder);
 
     RTC_CHECK_EQ(0, vie_channel_->SetReceiveCodec(codec));
   }
 
   incoming_video_stream_.reset(new IncomingVideoStream(0));
   incoming_video_stream_->SetExpectedRenderDelay(config.render_delay_ms);
   incoming_video_stream_->SetExternalCallback(this);
   vie_channel_->SetIncomingVideoStream(incoming_video_stream_.get());
 
-  if (config.pre_decode_callback)
-    vie_channel_->RegisterPreDecodeImageCallback(&encoded_frame_proxy_);
+  vie_channel_->RegisterPreDecodeImageCallback(this);
   vie_channel_->RegisterPreRenderCallback(this);
 }
 
 VideoReceiveStream::~VideoReceiveStream() {
   incoming_video_stream_->Stop();
   vie_channel_->RegisterPreRenderCallback(nullptr);
   vie_channel_->RegisterPreDecodeImageCallback(nullptr);
 
   for (size_t i = 0; i < config_.decoders.size(); ++i)
     vie_channel_->DeRegisterExternalDecoder(config_.decoders[i].payload_type);
@@ skipping 57 matching lines @@
   if (config_.renderer != nullptr)
     config_.renderer->RenderFrame(
         video_frame,
         video_frame.render_time_ms() - clock_->TimeInMilliseconds());
 
   stats_proxy_->OnRenderedFrame(video_frame.width(), video_frame.height());
 
   return 0;
 }
 
+int32_t VideoReceiveStream::Encoded(

[stefan-webrtc, 2015/10/15 12:49:35]

I find it a bit strange that we use an encode callback on the receiver. Should
we at least move the callback class to somewhere different than video_encoder.h?
Or maybe just create a different callback for this purpose?

[åsapersson, 2015/10/16 09:33:59]

Do this in a separate CL? Added comment.

[stefan-webrtc, 2015/10/16 09:40:10]

Sounds good.

+    const EncodedImage& encoded_image,
+    const CodecSpecificInfo* codec_specific_info,
+    const RTPFragmentationHeader* fragmentation) {
+  stats_proxy_->Encoded(encoded_image, codec_specific_info);
+  if (config_.pre_decode_callback) {
+    encoded_frame_proxy_.Encoded(
+        encoded_image, codec_specific_info, fragmentation);
+  }
+  return 0;
+}
+
 void VideoReceiveStream::SignalNetworkState(NetworkState state) {
   if (state == kNetworkUp)
     SetRtcpMode(config_.rtp.rtcp_mode);
   if (state == kNetworkDown)
     vie_channel_->SetRTCPMode(kRtcpOff);
 }
 
 void VideoReceiveStream::SetRtcpMode(newapi::RtcpMode mode) {
   switch (mode) {
     case newapi::kRtcpCompound:
       vie_channel_->SetRTCPMode(kRtcpCompound);
       break;
     case newapi::kRtcpReducedSize:
       vie_channel_->SetRTCPMode(kRtcpNonCompound);
       break;
   }
 }
 }  // namespace internal
 }  // namespace webrtc