RTCVideoEncoder: Report H264 profile information to WebRTC

content/renderer/media/gpu/rtc_video_encoder.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/gpu/rtc_video_encoder.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 14 matching lines @@
 #include "media/filters/h264_parser.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "media/video/video_encode_accelerator.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/webrtc/base/timeutils.h"
 
 namespace content {
 
 namespace {
 
-// Translate from webrtc::VideoCodecType and webrtc::VideoCodec to
-// media::VideoCodecProfile.
-media::VideoCodecProfile WebRTCVideoCodecToVideoCodecProfile(
-    webrtc::VideoCodecType type,
-    const webrtc::VideoCodec* codec_settings) {
-  DCHECK_EQ(type, codec_settings->codecType);
-  switch (type) {
-    case webrtc::kVideoCodecVP8:
-      return media::VP8PROFILE_ANY;
-    case webrtc::kVideoCodecH264:
-      // TODO(magjed): WebRTC is only using Baseline profile for now. Update
-      // once http://crbug/webrtc/6337 is fixed.
-      return media::H264PROFILE_BASELINE;
-    default:
-      NOTREACHED() << "Unrecognized video codec type";
-      return media::VIDEO_CODEC_PROFILE_UNKNOWN;
-  }
-}
-
 // Populates struct webrtc::RTPFragmentationHeader for H264 codec.
 // Each entry specifies the offset and length (excluding start code) of a NALU.
 // Returns true if successful.
 bool GetRTPFragmentationHeaderH264(webrtc::RTPFragmentationHeader* header,
                                    const uint8_t* data, uint32_t length) {
   media::H264Parser parser;
   parser.SetStream(data, length);
 
   std::vector<media::H264NALU> nalu_vector;
   while (true) {
@@ skipping 27 matching lines @@
 // called on) a single thread.
 //
 // This class separates state related to the thread that RTCVideoEncoder
 // operates on from the thread that |gpu_factories_| provides for accelerator
 // operations (presently the media thread).
 class RTCVideoEncoder::Impl
     : public media::VideoEncodeAccelerator::Client,
       public base::RefCountedThreadSafe<RTCVideoEncoder::Impl> {
  public:
   Impl(media::GpuVideoAcceleratorFactories* gpu_factories,
-       webrtc::VideoCodecType video_codec_type);
+       const media::VideoCodecProfile& profile);
 
   // Create the VEA and call Initialize() on it.  Called once per instantiation,
   // and then the instance is bound forevermore to whichever thread made the
   // call.
   // RTCVideoEncoder expects to be able to call this function synchronously from
   // its own thread, hence the |async_waiter| and |async_retval| arguments.
   void CreateAndInitializeVEA(const gfx::Size& input_visible_size,
                               uint32_t bitrate,
                               media::VideoCodecProfile profile,
                               base::WaitableEvent* async_waiter,
@@ skipping 18 matching lines @@
                                       int32_t* async_retval,
                                       webrtc::EncodedImageCallback* callback);
 
   // Destroy this Impl's encoder.  The destructor is not explicitly called, as
   // Impl is a base::RefCountedThreadSafe.
   void Destroy(base::WaitableEvent* async_waiter);
 
   // Return the status of Impl. One of WEBRTC_VIDEO_CODEC_XXX value.
   int32_t GetStatus() const;
 
-  webrtc::VideoCodecType video_codec_type() { return video_codec_type_; }
-
   // media::VideoEncodeAccelerator::Client implementation.
   void RequireBitstreamBuffers(unsigned int input_count,
                                const gfx::Size& input_coded_size,
                                size_t output_buffer_size) override;
   void BitstreamBufferReady(int32_t bitstream_buffer_id,
                             size_t payload_size,
                             bool key_frame,
                             base::TimeDelta timestamp) override;
   void NotifyError(media::VideoEncodeAccelerator::Error error) override;
 
@@ skipping 79 matching lines @@
   // encoder.
   int output_buffers_free_count_;
 
   // 15 bits running index of the VP8 frames. See VP8 RTP spec for details.
   uint16_t picture_id_;
 
   // webrtc::VideoEncoder encode complete callback.
   webrtc::EncodedImageCallback* encoded_image_callback_;
 
   // The video codec type, as reported to WebRTC.
-  const webrtc::VideoCodecType video_codec_type_;
+  const media::VideoCodecProfile profile_;
 
   // Protect |status_|. |status_| is read or written on |gpu_task_runner_| in
   // Impl. It can be read in RTCVideoEncoder on other threads.
   mutable base::Lock status_lock_;
 
   // We cannot immediately return error conditions to the WebRTC user of this
   // class, as there is no error callback in the webrtc::VideoEncoder interface.
   // Instead, we cache an error status here and return it the next time an
   // interface entry point is called. This is protected by |status_lock_|.
   int32_t status_;
 
   DISALLOW_COPY_AND_ASSIGN(Impl);
 };
 
-RTCVideoEncoder::Impl::Impl(media::GpuVideoAcceleratorFactories* gpu_factories,
-                            webrtc::VideoCodecType video_codec_type)
+RTCVideoEncoder::Impl::Impl(
+    media::GpuVideoAcceleratorFactories* gpu_factories,
+    const media::VideoCodecProfile& profile)
     : gpu_factories_(gpu_factories),
       async_waiter_(NULL),
       async_retval_(NULL),
       input_next_frame_(NULL),
       input_next_frame_keyframe_(false),
       output_buffers_free_count_(0),
       encoded_image_callback_(nullptr),
-      video_codec_type_(video_codec_type),
+      profile_(profile),
       status_(WEBRTC_VIDEO_CODEC_UNINITIALIZED) {
   thread_checker_.DetachFromThread();
   // Picture ID should start on a random number.
   picture_id_ = static_cast<uint16_t>(base::RandInt(0, 0x7FFF));
 }
 
 void RTCVideoEncoder::Impl::CreateAndInitializeVEA(
     const gfx::Size& input_visible_size,
     uint32_t bitrate,
     media::VideoCodecProfile profile,
@@ skipping 398 matching lines @@
     int32_t bitstream_buffer_id,
     uint16_t picture_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DVLOG(3) << "ReturnEncodedImage(): "
            << "bitstream_buffer_id=" << bitstream_buffer_id
            << ", picture_id=" << picture_id;
 
   if (!encoded_image_callback_)
     return;
 
+  webrtc::CodecSpecificInfo info;
   webrtc::RTPFragmentationHeader header;
+  memset(&info, 0, sizeof(info));
   memset(&header, 0, sizeof(header));
-  switch (video_codec_type_) {
-    case webrtc::kVideoCodecVP8:
-      // Generate a header describing a single fragment.
-      header.VerifyAndAllocateFragmentationHeader(1);
-      header.fragmentationOffset[0] = 0;
-      header.fragmentationLength[0] = image._length;
-      header.fragmentationPlType[0] = 0;
-      header.fragmentationTimeDiff[0] = 0;
-      break;
-    case webrtc::kVideoCodecH264:
-      if (!GetRTPFragmentationHeaderH264(&header, image._buffer,
-                                         image._length)) {
-        DLOG(ERROR) << "Failed to get RTP fragmentation header for H264";
-        NotifyError(
-            (media::VideoEncodeAccelerator::Error)WEBRTC_VIDEO_CODEC_ERROR);
-        return;
-      }
-      break;
-    default:
-      NOTREACHED() << "Invalid video codec type";
-      return;
-  }
+  if (profile_ >= media::VP8PROFILE_MIN && profile_ <= media::VP8PROFILE_MAX) {

[Pawel Osciak, 2016/11/17 07:30:05]

I think we can store just media::VideoCodec in Impl instead of profile, then we
could simplify the conditions here.

[magjed_chromium, 2016/11/17 13:08:03]

Done. I kept it as a webrtc::VideoCodecType in Impl to simplify the conditions
here and minimize the diff.

+    // Generate a header describing a single fragment.
+    header.VerifyAndAllocateFragmentationHeader(1);
+    header.fragmentationOffset[0] = 0;
+    header.fragmentationLength[0] = image._length;
+    header.fragmentationPlType[0] = 0;
+    header.fragmentationTimeDiff[0] = 0;
 
-  webrtc::CodecSpecificInfo info;
-  memset(&info, 0, sizeof(info));
-  info.codecType = video_codec_type_;
-  if (video_codec_type_ == webrtc::kVideoCodecVP8) {
+    info.codecType = webrtc::kVideoCodecVP8;
     info.codecSpecific.VP8.pictureId = picture_id;
     info.codecSpecific.VP8.tl0PicIdx = -1;
     info.codecSpecific.VP8.keyIdx = -1;
+  } else if (profile_ >= media::H264PROFILE_MIN &&
+             profile_ <= media::H264PROFILE_MAX) {
+    info.codecType = webrtc::kVideoCodecH264;
+    if (!GetRTPFragmentationHeaderH264(&header, image._buffer, image._length)) {
+      DLOG(ERROR) << "Failed to get RTP fragmentation header for H264";
+      NotifyError(
+          (media::VideoEncodeAccelerator::Error)WEBRTC_VIDEO_CODEC_ERROR);
+      return;
+    }
+  } else {
+    NOTREACHED() << "Invalid video codec type";
+    return;
   }
 
   const auto result =
       encoded_image_callback_->OnEncodedImage(image, &info, &header);
   if (result.error != webrtc::EncodedImageCallback::Result::OK) {
     DVLOG(2)
         << "ReturnEncodedImage(): webrtc::EncodedImageCallback::Result.error = "
         << result.error;
   }
 
   UseOutputBitstreamBufferId(bitstream_buffer_id);
 }
 
 RTCVideoEncoder::RTCVideoEncoder(
-    webrtc::VideoCodecType type,
+    const media::VideoCodecProfile& profile,
     media::GpuVideoAcceleratorFactories* gpu_factories)
-    : video_codec_type_(type),
+    : profile_(profile),
       gpu_factories_(gpu_factories),
       gpu_task_runner_(gpu_factories->GetTaskRunner()) {
-  DVLOG(1) << "RTCVideoEncoder(): codec type=" << type;
+  DVLOG(1) << "RTCVideoEncoder(): profile=" << GetProfileName(profile);
 }
 
 RTCVideoEncoder::~RTCVideoEncoder() {
   DVLOG(3) << "~RTCVideoEncoder";
   Release();
   DCHECK(!impl_.get());
 }
 
 int32_t RTCVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings,
                                     int32_t number_of_cores,
                                     size_t max_payload_size) {
   DVLOG(1) << "InitEncode(): codecType=" << codec_settings->codecType
            << ", width=" << codec_settings->width
            << ", height=" << codec_settings->height
            << ", startBitrate=" << codec_settings->startBitrate;
   if (impl_) {
     DVLOG(1) << "Release because of reinitialization";
     Release();
   }
 
-  impl_ = new Impl(gpu_factories_, video_codec_type_);
-  const media::VideoCodecProfile profile = WebRTCVideoCodecToVideoCodecProfile(
-      impl_->video_codec_type(), codec_settings);
+  impl_ = new Impl(gpu_factories_, profile_);
 
   base::WaitableEvent initialization_waiter(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   int32_t initialization_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::CreateAndInitializeVEA,
                  impl_,
                  gfx::Size(codec_settings->width, codec_settings->height),
                  codec_settings->startBitrate,
-                 profile,
+                 profile_,
                  &initialization_waiter,
                  &initialization_retval));
 
   // webrtc::VideoEncoder expects this call to be synchronous.
   initialization_waiter.Wait();
-  RecordInitEncodeUMA(initialization_retval, profile);
+  RecordInitEncodeUMA(initialization_retval, profile_);
   return initialization_retval;
 }
 
 int32_t RTCVideoEncoder::Encode(
     const webrtc::VideoFrame& input_image,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     const std::vector<webrtc::FrameType>* frame_types) {
   DVLOG(3) << "Encode()";
   if (!impl_.get()) {
     DVLOG(3) << "Encoder is not initialized";
@@ skipping 93 matching lines @@
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoEncoderInitEncodeSuccess",
                         init_retval == WEBRTC_VIDEO_CODEC_OK);
   if (init_retval == WEBRTC_VIDEO_CODEC_OK) {
     UMA_HISTOGRAM_ENUMERATION("Media.RTCVideoEncoderProfile",
                               profile,
                               media::VIDEO_CODEC_PROFILE_MAX + 1);
   }
 }
 
 }  // namespace content