Histograms for H264EncoderImpl/H264DecoderImpl initialization and errors

webrtc/modules/video_coding/codecs/h264/h264_encoder_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_encoder_impl.h"
 
 #include <limits>
 
 #include "third_party/openh264/src/codec/api/svc/codec_api.h"
 #include "third_party/openh264/src/codec/api/svc/codec_app_def.h"
 #include "third_party/openh264/src/codec/api/svc/codec_def.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/common_video/libyuv/include/webrtc_libyuv.h"
+#include "webrtc/system_wrappers/include/metrics.h"
 
 namespace webrtc {
 
 namespace {
 
 const bool kOpenH264EncoderDetailedLogging = false;
 
+// Used by histograms. Values of entries should not be changed.
+enum H264EncoderImplEvent {
+  kH264EncoderEventInit = 0,
+  kH264EncoderEventError = 1,
+  kH264EncoderEventMax = 16,
+};
+
 int NumberOfThreads(int width, int height, int number_of_cores) {
   // TODO(hbos): In Chromium, multiple threads do not work with sandbox on Mac,
   // see crbug.com/583348. Until further investigated, only use one thread.
 //  if (width * height >= 1920 * 1080 && number_of_cores > 8) {
 //    return 8;  // 8 threads for 1080p on high perf machines.
 //  } else if (width * height > 1280 * 960 && number_of_cores >= 6) {
 //    return 3;  // 3 threads for 1080p.
 //  } else if (width * height > 640 * 480 && number_of_cores >= 3) {
 //    return 2;  // 2 threads for qHD/HD.
 //  } else {
@@ skipping 94 matching lines @@
     // Copy the entire layer's data (including start codes).
     memcpy(encoded_image->_buffer + encoded_image->_length,
            layerInfo.pBsBuf,
            layer_len);
     encoded_image->_length += layer_len;
   }
 }
 
 H264EncoderImpl::H264EncoderImpl()
     : openh264_encoder_(nullptr),
-      encoded_image_callback_(nullptr) {
+      encoded_image_callback_(nullptr),
+      has_reported_init_(false),
+      has_reported_error_(false) {
 }
 
 H264EncoderImpl::~H264EncoderImpl() {
   Release();
 }
 
 int32_t H264EncoderImpl::InitEncode(const VideoCodec* codec_settings,
                                     int32_t number_of_cores,
                                     size_t /*max_payload_size*/) {
+  ReportInit();
   if (!codec_settings ||
       codec_settings->codecType != kVideoCodecH264) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
-  if (codec_settings->maxFramerate == 0)
+  if (codec_settings->maxFramerate == 0) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
-  if (codec_settings->width < 1 || codec_settings->height < 1)
+  }
+  if (codec_settings->width < 1 || codec_settings->height < 1) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
 
   int32_t release_ret = Release();
-  if (release_ret != WEBRTC_VIDEO_CODEC_OK)
+  if (release_ret != WEBRTC_VIDEO_CODEC_OK) {
+    ReportError();
     return release_ret;
+  }
   RTC_DCHECK(!openh264_encoder_);
 
   // Create encoder.
   if (WelsCreateSVCEncoder(&openh264_encoder_) != 0) {
     // Failed to create encoder.
     LOG(LS_ERROR) << "Failed to create OpenH264 encoder";
     RTC_DCHECK(!openh264_encoder_);
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   RTC_DCHECK(openh264_encoder_);
   if (kOpenH264EncoderDetailedLogging) {
     int trace_level = WELS_LOG_DETAIL;
     openh264_encoder_->SetOption(ENCODER_OPTION_TRACE_LEVEL,
                                  &trace_level);
   }
   // else WELS_LOG_DEFAULT is used by default.
 
   codec_settings_ = *codec_settings;
   if (codec_settings_.targetBitrate == 0)
     codec_settings_.targetBitrate = codec_settings_.startBitrate;
 
   // Initialization parameters.
   // There are two ways to initialize. There is SEncParamBase (cleared with
   // memset(&p, 0, sizeof(SEncParamBase)) used in Initialize, and SEncParamExt
   // which is a superset of SEncParamBase (cleared with GetDefaultParams) used
   // in InitializeExt.
   SEncParamExt init_params;
   openh264_encoder_->GetDefaultParams(&init_params);
   if (codec_settings_.mode == kRealtimeVideo) {
     init_params.iUsageType = CAMERA_VIDEO_REAL_TIME;
   } else if (codec_settings_.mode == kScreensharing) {
     init_params.iUsageType = SCREEN_CONTENT_REAL_TIME;
   } else {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
   }
   init_params.iPicWidth = codec_settings_.width;
   init_params.iPicHeight = codec_settings_.height;
   // |init_params| uses bit/s, |codec_settings_| uses kbit/s.
   init_params.iTargetBitrate = codec_settings_.targetBitrate * 1000;
   init_params.iMaxBitrate = codec_settings_.maxBitrate * 1000;
   // Rate Control mode
   init_params.iRCMode = RC_BITRATE_MODE;
   init_params.fMaxFrameRate = static_cast<float>(codec_settings_.maxFramerate);
@@ skipping 20 matching lines @@
   init_params.sSpatialLayers[0].fFrameRate         = init_params.fMaxFrameRate;
   init_params.sSpatialLayers[0].iSpatialBitrate    = init_params.iTargetBitrate;
   init_params.sSpatialLayers[0].iMaxSpatialBitrate = init_params.iMaxBitrate;
   // Slice num according to number of threads.
   init_params.sSpatialLayers[0].sSliceCfg.uiSliceMode = SM_AUTO_SLICE;
 
   // Initialize.
   if (openh264_encoder_->InitializeExt(&init_params) != 0) {
     LOG(LS_ERROR) << "Failed to initialize OpenH264 encoder";
     Release();
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
   int video_format = EVideoFormatType::videoFormatI420;
   openh264_encoder_->SetOption(ENCODER_OPTION_DATAFORMAT,
                                &video_format);
 
   // Initialize encoded image. Default buffer size: size of unencoded data.
   encoded_image_._size = CalcBufferSize(
       kI420, codec_settings_.width, codec_settings_.height);
   encoded_image_._buffer = new uint8_t[encoded_image_._size];
@@ skipping 43 matching lines @@
                                &target_bitrate);
   float max_framerate = static_cast<float>(codec_settings_.maxFramerate);
   openh264_encoder_->SetOption(ENCODER_OPTION_FRAME_RATE,
                                &max_framerate);
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264EncoderImpl::Encode(
     const VideoFrame& frame, const CodecSpecificInfo* codec_specific_info,
     const std::vector<FrameType>* frame_types) {
-  if (!IsInitialized())
+  if (!IsInitialized()) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
-  if (frame.IsZeroSize())
+  }
+  if (frame.IsZeroSize()) {
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_PARAMETER;
+  }
   if (!encoded_image_callback_) {
     LOG(LS_WARNING) << "InitEncode() has been called, but a callback function "
                     << "has not been set with RegisterEncodeCompleteCallback()";
+    ReportError();
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (frame.width()  != codec_settings_.width ||
       frame.height() != codec_settings_.height) {
     LOG(LS_WARNING) << "Encoder initialized for " << codec_settings_.width
                     << "x" << codec_settings_.height << " but trying to encode "
                     << frame.width() << "x" << frame.height() << " frame.";
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERR_SIZE;
   }
 
   bool force_key_frame = false;
   if (frame_types != nullptr) {
     // We only support a single stream.
     RTC_DCHECK_EQ(frame_types->size(), static_cast<size_t>(1));
     // Skip frame?
     if ((*frame_types)[0] == kEmptyFrame) {
       return WEBRTC_VIDEO_CODEC_OK;
@@ skipping 24 matching lines @@
 
   // EncodeFrame output.
   SFrameBSInfo info;
   memset(&info, 0, sizeof(SFrameBSInfo));
 
   // Encode!
   int enc_ret = openh264_encoder_->EncodeFrame(&picture, &info);
   if (enc_ret != 0) {
     LOG(LS_ERROR) << "OpenH264 frame encoding failed, EncodeFrame returned "
                   << enc_ret << ".";
+    ReportError();
     return WEBRTC_VIDEO_CODEC_ERROR;
   }
 
   encoded_image_._encodedWidth = frame.width();
   encoded_image_._encodedHeight = frame.height();
   encoded_image_._timeStamp = frame.timestamp();
   encoded_image_.ntp_time_ms_ = frame.ntp_time_ms();
   encoded_image_.capture_time_ms_ = frame.render_time_ms();
   encoded_image_._frameType = EVideoFrameType_to_FrameType(info.eFrameType);
 
@@ skipping 12 matching lines @@
                                      &codec_specific,
                                      &frag_header);
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 bool H264EncoderImpl::IsInitialized() const {
   return openh264_encoder_ != nullptr;
 }
 
+void H264EncoderImpl::ReportInit() {
+  if (has_reported_init_)
+    return;
+  RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264EncoderImpl.Event",
+                            kH264EncoderEventInit,
+                            kH264EncoderEventMax);
+  has_reported_init_ = true;
+}
+
+void H264EncoderImpl::ReportError() {
+  if (has_reported_error_)
+    return;
+  RTC_HISTOGRAM_ENUMERATION("WebRTC.Video.H264EncoderImpl.Event",
+                            kH264EncoderEventError,
+                            kH264EncoderEventMax);
+  has_reported_error_ = true;
+}
+
 int32_t H264EncoderImpl::SetChannelParameters(
     uint32_t packet_loss, int64_t rtt) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t H264EncoderImpl::SetPeriodicKeyFrames(bool enable) {
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void H264EncoderImpl::OnDroppedFrame() {
 }
 
 }  // namespace webrtc