Expose codec implementation names in stats.

webrtc/modules/video_coding/main/source/generic_encoder.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 135 matching lines @@
   rotation_ = inputFrame.rotation();
 
   if (vcm_encoded_frame_callback_) {
     // Keep track of the current frame rotation and apply to the output of the
     // encoder. There might not be exact as the encoder could have one frame
     // delay but it should be close enough.
     vcm_encoded_frame_callback_->SetRotation(rotation_);
   }
 
   int32_t result = encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
+
+  if (vcm_encoded_frame_callback_) {
+    vcm_encoded_frame_callback_->SignalLastEncoderImplementationUsed(
+        encoder_->ImplementationName());

[hta-webrtc, 2015/10/29 11:35:03]

Does this imply that the extra thread-hop to fetch implementation name is done
for each frame?

[pbos-webrtc, 2015/10/29 16:08:05]

Implementation name is (if not constant) expected to be gathered on InitEncode
at the latest. ImplementationName should be fast and simply return a string.

+  }
+
   if (is_screenshare_ &&
       result == WEBRTC_VIDEO_CODEC_TARGET_BITRATE_OVERSHOOT) {
     // Target bitrate exceeded, encoder state has been reset - try again.
     return encoder_->Encode(inputFrame, codecSpecificInfo, &frameTypes);
   }
 
   return result;
 }
 
 int32_t
@@ skipping 82 matching lines @@
 
 int VCMGenericEncoder::GetTargetFramerate() {
   return encoder_->GetTargetFramerate();
 }
 
  /***************************
   * Callback Implementation
   ***************************/
 VCMEncodedFrameCallback::VCMEncodedFrameCallback(
     EncodedImageCallback* post_encode_callback)
-    : _sendCallback(),
+    : send_callback_(),
       _mediaOpt(NULL),
       _payloadType(0),
       _internalSource(false),
       _rotation(kVideoRotation_0),
       post_encode_callback_(post_encode_callback)
 #ifdef DEBUG_ENCODER_BIT_STREAM
       ,
       _bitStreamAfterEncoder(NULL)
 #endif
 {
 #ifdef DEBUG_ENCODER_BIT_STREAM
     _bitStreamAfterEncoder = fopen("encoderBitStream.bit", "wb");
 #endif
 }
 
 VCMEncodedFrameCallback::~VCMEncodedFrameCallback()
 {
 #ifdef DEBUG_ENCODER_BIT_STREAM
     fclose(_bitStreamAfterEncoder);
 #endif
 }
 
 int32_t
 VCMEncodedFrameCallback::SetTransportCallback(VCMPacketizationCallback* transport)
 {
-    _sendCallback = transport;
+    send_callback_ = transport;
     return VCM_OK;
 }
 
 int32_t VCMEncodedFrameCallback::Encoded(
-    const EncodedImage& encodedImage,
+    const EncodedImage& encoded_image,
     const CodecSpecificInfo* codecSpecificInfo,
     const RTPFragmentationHeader* fragmentationHeader) {
-  RTC_DCHECK(encodedImage._frameType == kVideoFrameKey ||
-             encodedImage._frameType == kVideoFrameDelta);
-  post_encode_callback_->Encoded(encodedImage, NULL, NULL);
+  RTC_DCHECK(encoded_image._frameType == kVideoFrameKey ||
+             encoded_image._frameType == kVideoFrameDelta);
+  post_encode_callback_->Encoded(encoded_image, NULL, NULL);
 
-  if (_sendCallback == NULL) {
+  if (send_callback_ == NULL) {
     return VCM_UNINITIALIZED;
   }
 
 #ifdef DEBUG_ENCODER_BIT_STREAM
   if (_bitStreamAfterEncoder != NULL) {
-    fwrite(encodedImage._buffer, 1, encodedImage._length,
+    fwrite(encoded_image._buffer, 1, encoded_image._length,
            _bitStreamAfterEncoder);
   }
 #endif
 
   RTPVideoHeader rtpVideoHeader;
   memset(&rtpVideoHeader, 0, sizeof(RTPVideoHeader));
   RTPVideoHeader* rtpVideoHeaderPtr = &rtpVideoHeader;
   if (codecSpecificInfo) {
     CopyCodecSpecific(codecSpecificInfo, rtpVideoHeaderPtr);
   }
   rtpVideoHeader.rotation = _rotation;
 
-  int32_t callbackReturn = _sendCallback->SendData(
-      _payloadType, encodedImage, *fragmentationHeader, rtpVideoHeaderPtr);
+  int32_t callbackReturn = send_callback_->SendData(
+      _payloadType, encoded_image, *fragmentationHeader, rtpVideoHeaderPtr);
   if (callbackReturn < 0) {
     return callbackReturn;
   }
 
   if (_mediaOpt != NULL) {
-    _mediaOpt->UpdateWithEncodedData(encodedImage);
+    _mediaOpt->UpdateWithEncodedData(encoded_image);
     if (_internalSource)
       return _mediaOpt->DropFrame();  // Signal to encoder to drop next frame.
   }
   return VCM_OK;
 }
 
-void
-VCMEncodedFrameCallback::SetMediaOpt(
-    media_optimization::MediaOptimization *mediaOpt)
-{
-    _mediaOpt = mediaOpt;
+void VCMEncodedFrameCallback::SetMediaOpt(
+    media_optimization::MediaOptimization* mediaOpt) {
+  _mediaOpt = mediaOpt;
+}
+
+void VCMEncodedFrameCallback::SignalLastEncoderImplementationUsed(
+    const char* implementation_name) {
+  if (send_callback_)
+    send_callback_->OnEncoderImplementationName(implementation_name);
 }
 
 }  // namespace webrtc