Histograms for H264EncoderImpl/H264DecoderImpl initialization and errors

webrtc/modules/video_coding/codecs/h264/h264_decoder_impl.cc

 /*
  *  Copyright (c) 2015 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/modules/video_coding/codecs/h264/h264_decoder_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 extern "C" {
 #include "third_party/ffmpeg/libavcodec/avcodec.h"
 #include "third_party/ffmpeg/libavformat/avformat.h"
 #include "third_party/ffmpeg/libavutil/imgutils.h"
 }  // extern "C"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/keep_ref_until_done.h"
 #include "webrtc/base/logging.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
 namespace {
 
 const AVPixelFormat kPixelFormat = AV_PIX_FMT_YUV420P;
 const size_t kYPlaneIndex = 0;
 const size_t kUPlaneIndex = 1;
 const size_t kVPlaneIndex = 2;
 
+// Used by histograms. Values of entries should not be changed.
+enum H264DecoderImplEvent {
+  kH264DecoderEventInit = 0,
+  kH264DecoderEventError = 1,
+  kH264DecoderEventMax = 16,

[hbos, 2016/02/23 15:01:22]

The example I looked at was WebRTC.Video.Encoder.CodecType which had a much
higher "Max" than the number of enum entries (64). I thought the margin was in
case more entries are added in the future and also used a higher value. But
perhaps this is not necessary, and max should be either 1 or 2 depending on if
its inclusive or exclusive. Do any of you know why a higher Max value was used
in that case and if it makes sense in this case?

[hlundin-webrtc, 2016/02/24 09:17:57]

I don't know the history behind CodecType. The description in metrics.h says
"|boundary| should be above the max enumerator sample" which is interpret as
being exclusive. I don't know what happens if you later on want to add more enum
values and have to raise the boundary.

[hbos, 2016/02/24 11:11:25]

Ok. Landed as-is. rkaplow if you know I could adjust "Max" in a follow-up if
necessary?

[rkaplow, 2016/02/24 16:10:08]

usually people don't even set the numbers here manually.
It should be fine to adjust the max value, yes.

+};
+
 #if defined(WEBRTC_INITIALIZE_FFMPEG)
 
 rtc::CriticalSection ffmpeg_init_lock;
 bool ffmpeg_initialized = false;
 
 // Called by FFmpeg to do mutex operations if initialized using
 // |InitializeFFmpeg|.
 int LockManagerOperation(void** lock, AVLockOp op)
     EXCLUSIVE_LOCK_FUNCTION() UNLOCK_FUNCTION() {
   switch (op) {
@@ skipping 55 matching lines @@
   // (top-left corner) after decoding to avoid visible borders to the right and
   // bottom of the actual image.
   avcodec_align_dimensions(context, &width, &height);
 
   RTC_CHECK_GE(width, 0);
   RTC_CHECK_GE(height, 0);
   int ret = av_image_check_size(static_cast<unsigned int>(width),
                                 static_cast<unsigned int>(height), 0, nullptr);
   if (ret < 0) {
     LOG(LS_ERROR) << "Invalid picture size " << width << "x" << height;
+    decoder->ReportError();
     return ret;
   }
 
   // The video frame is stored in |video_frame|. |av_frame| is FFmpeg's version
   // of a video frame and will be set up to reference |video_frame|'s buffers.
   VideoFrame* video_frame = new VideoFrame();
   // FFmpeg expects the initial allocation to be zero-initialized according to
   // http://crbug.com/390941. Our pool is set up to zero-initialize new buffers.
   video_frame->set_video_frame_buffer(
       decoder->pool_.CreateBuffer(width, height));
@@ skipping 29 matching lines @@
 
 void H264DecoderImpl::AVFreeBuffer2(void* opaque, uint8_t* data) {
   // The buffer pool recycles the buffer used by |video_frame| when there are no
   // more references to it. |video_frame| is a thin buffer holder and is not
   // recycled.
   VideoFrame* video_frame = static_cast<VideoFrame*>(opaque);
   delete video_frame;
 }
 
 H264DecoderImpl::H264DecoderImpl() : pool_(true),
-                                     decoded_image_callback_(nullptr) {
+                                     decoded_image_callback_(nullptr),
+                                     has_reported_init_(false),
+                                     has_reported_error_(false) {
 }
 
 H264DecoderImpl::~H264DecoderImpl() {
   Release();
 }
 
 int32_t H264DecoderImpl::InitDecode(const VideoCodec* codec_settings,
                                     int32_t number_of_cores) {
+  ReportInit();
   if (codec_settings &&
       codec_settings->codecType != kVideoCodecH264) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   // FFmpeg must have been initialized (with |av_lockmgr_register| and
   // |av_register_all|) before we proceed. |InitializeFFmpeg| does this, which
   // makes sense for WebRTC standalone. In other cases, such as Chromium, FFmpeg
   // is initialized externally and calling |InitializeFFmpeg| would be
   // thread-unsafe and result in FFmpeg being initialized twice, which could
   // break other FFmpeg usage. See the |rtc_initialize_ffmpeg| flag.
 #if defined(WEBRTC_INITIALIZE_FFMPEG)
   // Make sure FFmpeg has been initialized. Subsequent |InitializeFFmpeg| calls
   // do nothing.
   InitializeFFmpeg();
 #endif
 
   // Release necessary in case of re-initializing.
   int32_t ret = Release();
-  if (ret != WEBRTC_VIDEO_CODEC_OK)
+  if (ret != WEBRTC_VIDEO_CODEC_OK) {
+    ReportError();
     return ret;
+  }
   RTC_DCHECK(!av_context_);
 
   // Initialize AVCodecContext.
   av_context_.reset(avcodec_alloc_context3(nullptr));
 
   av_context_->codec_type = AVMEDIA_TYPE_VIDEO;
   av_context_->codec_id = AV_CODEC_ID_H264;
   if (codec_settings) {
     av_context_->coded_width = codec_settings->width;
     av_context_->coded_height = codec_settings->height;
@@ skipping 14 matching lines @@
   av_context_->opaque = this;
   // Use ref counted frames (av_frame_unref).
   av_context_->refcounted_frames = 1;  // true
 
   AVCodec* codec = avcodec_find_decoder(av_context_->codec_id);
   if (!codec) {
     // This is an indication that FFmpeg has not been initialized or it has not
     // been compiled/initialized with the correct set of codecs.
     LOG(LS_ERROR) << "FFmpeg H.264 decoder not found.";
     Release();
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   int res = avcodec_open2(av_context_.get(), codec, nullptr);
   if (res < 0) {
     LOG(LS_ERROR) << "avcodec_open2 error: " << res;
     Release();
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   av_frame_.reset(av_frame_alloc());
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264DecoderImpl::Release() {
   av_context_.reset();
   av_frame_.reset();
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264DecoderImpl::RegisterDecodeCompleteCallback(
     DecodedImageCallback* callback) {
   decoded_image_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264DecoderImpl::Decode(const EncodedImage& input_image,
                                 bool /*missing_frames*/,
                                 const RTPFragmentationHeader* /*fragmentation*/,
                                 const CodecSpecificInfo* codec_specific_info,
                                 int64_t /*render_time_ms*/) {
-  if (!IsInitialized())
+  if (!IsInitialized()) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
+  }
   if (!decoded_image_callback_) {
     LOG(LS_WARNING) << "InitDecode() has been called, but a callback function "
         "has not been set with RegisterDecodeCompleteCallback()";
+    ReportError();
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
-  if (!input_image._buffer || !input_image._length)
+  if (!input_image._buffer || !input_image._length) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
   if (codec_specific_info &&
       codec_specific_info->codecType != kVideoCodecH264) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
 
   // FFmpeg requires padding due to some optimized bitstream readers reading 32
   // or 64 bits at once and could read over the end. See avcodec_decode_video2.
   RTC_CHECK_GE(input_image._size, input_image._length +
                    EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
   // "If the first 23 bits of the additional bytes are not 0, then damaged MPEG
   // bitstreams could cause overread and segfault." See
   // AV_INPUT_BUFFER_PADDING_SIZE. We'll zero the entire padding just in case.
   memset(input_image._buffer + input_image._length,
          0,
          EncodedImage::GetBufferPaddingBytes(kVideoCodecH264));
 
   AVPacket packet;
   av_init_packet(&packet);
   packet.data = input_image._buffer;
   if (input_image._length >
       static_cast<size_t>(std::numeric_limits<int>::max())) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   packet.size = static_cast<int>(input_image._length);
   av_context_->reordered_opaque = input_image.ntp_time_ms_ * 1000;  // ms -> μs
 
   int frame_decoded = 0;
   int result = avcodec_decode_video2(av_context_.get(),
                                      av_frame_.get(),
                                      &frame_decoded,
                                      &packet);
   if (result < 0) {
     LOG(LS_ERROR) << "avcodec_decode_video2 error: " << result;
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   // |result| is number of bytes used, which should be all of them.
   if (result != packet.size) {
     LOG(LS_ERROR) << "avcodec_decode_video2 consumed " << result << " bytes "
         "when " << packet.size << " bytes were expected.";
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   if (!frame_decoded) {
     LOG(LS_WARNING) << "avcodec_decode_video2 successful but no frame was "
         "decoded.";
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   // Obtain the |video_frame| containing the decoded image.
@@ skipping 29 matching lines @@
     LOG(LS_WARNING) << "DecodedImageCallback::Decoded returned " << ret;
     return ret;
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool H264DecoderImpl::IsInitialized() const {
   return av_context_ != nullptr;
 }
 
+void H264DecoderImpl::ReportInit() {
+  if (has_reported_init_)
+    return;
+  RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264DecoderImpl.Event",
+                            kH264DecoderEventInit,
+                            kH264DecoderEventMax);
+  has_reported_init_ = true;
+}
+
+void H264DecoderImpl::ReportError() {
+  if (has_reported_error_)
+    return;
+  RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264DecoderImpl.Event",
+                            kH264DecoderEventError,
+                            kH264DecoderEventMax);
+  has_reported_error_ = true;
+}
+
 }  // namespace webrtc