Expose codec implementation names in stats.

webrtc/modules/video_coding/generic_decoder.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.
  */
 
 #include "webrtc/base/logging.h"
 #include "webrtc/base/trace_event.h"
 #include "webrtc/modules/video_coding/include/video_coding.h"
 #include "webrtc/modules/video_coding/generic_decoder.h"
 #include "webrtc/modules/video_coding/internal_defines.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 VCMDecodedFrameCallback::VCMDecodedFrameCallback(VCMTiming& timing,
                                                  Clock* clock)
-:
-_critSect(CriticalSectionWrapper::CreateCriticalSection()),
-_clock(clock),
-_receiveCallback(NULL),
-_timing(timing),
-_timestampMap(kDecoderFrameMemoryLength),
-_lastReceivedPictureID(0)
-{
-}
+    : _critSect(CriticalSectionWrapper::CreateCriticalSection()),
+      _clock(clock),
+      _receiveCallback(NULL),
+      _timing(timing),
+      _timestampMap(kDecoderFrameMemoryLength),
+      _lastReceivedPictureID(0) {}
 
 VCMDecodedFrameCallback::~VCMDecodedFrameCallback()
 {
     delete _critSect;
 }
 
 void VCMDecodedFrameCallback::SetUserReceiveCallback(
     VCMReceiveCallback* receiveCallback)
 {
     CriticalSectionScoped cs(_critSect);
@@ skipping 67 matching lines @@
 {
     _lastReceivedPictureID = pictureId;
     return 0;
 }
 
 uint64_t VCMDecodedFrameCallback::LastReceivedPictureID() const
 {
     return _lastReceivedPictureID;
 }
 
+void VCMDecodedFrameCallback::OnDecoderImplementationName(
+    const char* implementation_name) {
+  CriticalSectionScoped cs(_critSect);
+  if (_receiveCallback)
+    _receiveCallback->OnDecoderImplementationName(implementation_name);
+}
+
 void VCMDecodedFrameCallback::Map(uint32_t timestamp,
                                   VCMFrameInformation* frameInfo) {
   CriticalSectionScoped cs(_critSect);
   _timestampMap.Add(timestamp, frameInfo);
 }
 
 int32_t VCMDecodedFrameCallback::Pop(uint32_t timestamp)
 {
     CriticalSectionScoped cs(_critSect);
     if (_timestampMap.Pop(timestamp) == NULL)
@@ skipping 36 matching lines @@
     _frameInfos[_nextFrameInfoIdx].rotation = frame.rotation();
     _callback->Map(frame.TimeStamp(), &_frameInfos[_nextFrameInfoIdx]);
 
     _nextFrameInfoIdx = (_nextFrameInfoIdx + 1) % kDecoderFrameMemoryLength;
     int32_t ret = _decoder.Decode(frame.EncodedImage(),
                                         frame.MissingFrame(),
                                         frame.FragmentationHeader(),
                                         frame.CodecSpecific(),
                                         frame.RenderTimeMs());
 
+    _callback->OnDecoderImplementationName(_decoder.ImplementationName());
     if (ret < WEBRTC_VIDEO_CODEC_OK)
     {
         LOG(LS_WARNING) << "Failed to decode frame with timestamp "
                         << frame.TimeStamp() << ", error code: " << ret;
         _callback->Pop(frame.TimeStamp());
         return ret;
     }
     else if (ret == WEBRTC_VIDEO_CODEC_NO_OUTPUT ||
              ret == WEBRTC_VIDEO_CODEC_REQUEST_SLI)
     {
@@ skipping 19 matching lines @@
     _callback = callback;
     return _decoder.RegisterDecodeCompleteCallback(callback);
 }
 
 bool VCMGenericDecoder::External() const
 {
     return _isExternal;
 }
 
 }  // namespace