RtcVideoEncoder: determine video codec profile at InitEncode time.

content/renderer/media/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/rtc_video_encoder.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
@@ skipping 44 matching lines @@
   header->VerifyAndAllocateFragmentationHeader(nalu_vector.size());
   for (size_t i = 0; i < nalu_vector.size(); ++i) {
     header->fragmentationOffset[i] = nalu_vector[i].data - data;
     header->fragmentationLength[i] = nalu_vector[i].size;
     header->fragmentationPlType[i] = 0;
     header->fragmentationTimeDiff[i] = 0;
   }
   return true;
 }
 
+// Maps webrtc::VideoCodecProfile to media::VideoCodecProfile for H264 codec.

[Pawel Osciak, 2014/10/20 06:28:43]

Could we instead have a method that takes both profile and type from webrtc and
converts to media::VideoCodecProfile and unify with the existing method in
RtcVEFactory?

Or actually, since we should move type/codec to InitEncode entirely, probably
unify it here and remove from factory.

[hshi1, 2014/10/20 16:55:50]

The |profile_| is of media::VideoCodecProfile type; it is internal to chrome
media code and not recognized by WebRTC.

The reason for RtcVE to retain a member |profile_| at its constructor is because
that is the only place where RtcVEFactory interacts with the RtcVE instance. If
we don't save |profile| there it would be lost, as webRTC code has no idea about
its existence.

[Pawel Osciak, 2014/10/21 13:41:46]

Yes. My suggestion though was that it would be nice to try to delay translation
from WebRTC's [codec,profile] pair into media::VCP until InitEncode, when we
have both, instead of translating from codec and then doing a fixup in
InitEncode and do it in RTCVE::InitEncode. Especially since RTCVE constructor
doesn't really do anything with it.
Yes, although could we maybe change the factory to do what I'm suggesting in
comment below, unless I'm missing something?

[hshi1, 2014/10/22 19:01:16]

Done.

+media::VideoCodecProfile GetH264CodecProfile(
+    webrtc::VideoCodecProfile profile) {
+  switch (profile) {
+    case webrtc::kProfileBase:
+      return media::H264PROFILE_BASELINE;

[Pawel Osciak, 2014/10/20 06:28:43]

Is this actually baseline or constrained baseline?

[hshi1, 2014/10/20 16:55:50]

This is the actual baseline, however as I commented in the bug, the HW encoder
is free to implement a proper subset of the requested profile (e.g.
ConstrainedBaseline) and still be compliant.

[Pawel Osciak, 2014/10/21 13:41:46]

The issue is, what if an encoder does non-constrained and receiver can't decode
it... There is no way to pass this information/negotiate through media::VCP, or
WebRTC, or between devices, as far as I can tell? No matter whether it's CBP or
BP, we always say BP... It's true that it's a superset so technically ok, but we
may lose opportunity to decode if it's CBP and we treat it as BP, or may fail
unexpectedly if we always treat as CBP.

[hshi1, 2014/10/22 19:01:16]

But there's no constrained baseline profile definition in media code, so even if
we want to pass CBP down to GpuVEA there's no enums defined at the moment (see
media/base/video_decoder_config.h)

[Pawel Osciak, 2014/10/25 01:29:57]

Right, but that's a bug (crbug.com/345569) so perhaps it might be a good time to
consider looking into it (separately from this CL). I'm just explaining
consequences here and in crbug.com/424828 and hoping whomever is more
knowledgeable of what we should be expecting from decoders/encoders we use for
this to weigh the priority of looking into it.

+    case webrtc::kProfileMain:
+      return media::H264PROFILE_MAIN;
+    default:
+      DLOG(ERROR) << "Unrecognized H264 video codec profile";
+  }
+  return media::H264PROFILE_BASELINE;

[Pawel Osciak, 2014/10/20 06:28:43]

notreached.

[hshi1, 2014/10/20 16:55:50]

Acknowledged.

+}
+
 }  // namespace
 
 // This private class of RTCVideoEncoder does the actual work of communicating
 // with a media::VideoEncodeAccelerator for handling video encoding.  It can
 // be created on any thread, but should subsequently be posted to (and Destroy()
 // called on) a single thread.  Callbacks to RTCVideoEncoder are posted to the
 // thread on which the instance was constructed.
 //
 // This class separates state related to the thread that RTCVideoEncoder
 // operates on (presently the libjingle worker thread) from the thread that
@@ skipping 492 matching lines @@
 int32_t RTCVideoEncoder::InitEncode(const webrtc::VideoCodec* codec_settings,
                                     int32_t number_of_cores,
                                     uint32_t max_payload_size) {
   DVLOG(1) << "InitEncode(): codecType=" << codec_settings->codecType
            << ", width=" << codec_settings->width
            << ", height=" << codec_settings->height
            << ", startBitrate=" << codec_settings->startBitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!impl_.get());
 
+  if (codec_settings->codecType == webrtc::kVideoCodecH264) {

[Pawel Osciak, 2014/10/20 06:28:43]

If we can't determine profile on construction, can we remove it from the
constructor?

[hshi1, 2014/10/20 16:55:50]

No we can't because of the way webRTC defines the VideoEncoder interface. webRTC
does not explicitly define video codec profiles (the H264 profile enum is only
added by holmer@ very recently, and it is part of the codecSpecific struct, not
a general concept).

[Pawel Osciak, 2014/10/21 13:41:46]

We could perhaps store webrtc codec in RTCVE constructor and translate only once
we get webrtc profile here from both (or just codec for VP8), and not in the
factory?

[hshi1, 2014/10/22 19:01:16]

Done.

+    video_codec_profile_ =
+        GetH264CodecProfile(codec_settings->codecSpecific.H264.profile);
+  }
+
   weak_factory_.InvalidateWeakPtrs();
   impl_ = new Impl(weak_factory_.GetWeakPtr(), gpu_factories_);
   base::WaitableEvent initialization_waiter(true, false);
   int32_t initialization_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::CreateAndInitializeVEA,
                  impl_,
                  gfx::Size(codec_settings->width, codec_settings->height),
                  codec_settings->startBitrate,
@@ skipping 162 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",
                               video_codec_profile_,
                               media::VIDEO_CODEC_PROFILE_MAX + 1);
   }
 }
 
 }  // namespace content