Support for H264 HW offload for webRTC.

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"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "media/filters/gpu_video_accelerator_factories.h"
+#include "media/filters/h264_parser.h"
 #include "media/video/video_encode_accelerator.h"
 #include "third_party/webrtc/system_wrappers/interface/tick_util.h"
 
 #define NOTIFY_ERROR(x)                             \
   do {                                              \
     DLOG(ERROR) << "calling NotifyError(): " << x;  \
     NotifyError(x);                                 \
   } while (0)
 
 namespace content {
 
+namespace {
+
+void GetRTPFragmentationHeaderH264(

[Pawel Osciak, 2014/08/10 00:30:30]

Please document.

[hshi1, 2014/08/12 01:06:55]

Done.

+    webrtc::RTPFragmentationHeader& header, uint8_t* data, uint32_t length) {
+  media::H264Parser parser;
+  parser.SetStream(data, length);
+
+  std::vector<media::H264NALU> nalu_vector;
+  while (true) {
+    media::H264NALU nalu;
+    media::H264Parser::Result result;
+    result = parser.AdvanceToNextNALU(&nalu);
+    if (result == media::H264Parser::kOk) {

[Pawel Osciak, 2014/08/10 00:30:30]

Nit: switch?

[hshi1, 2014/08/10 00:36:10]

I thought about that but then a "break" in the switch block would just break out
of the switch, not the "while" loop. I'd need a goto or a local bool to be able
to break out.

+      nalu_vector.push_back(nalu);
+    } else if (result == media::H264Parser::kEOStream) {
+      break;
+    } else {
+      DLOG(ERROR) << "Unexpected H264 parser result";
+      break;

[Pawel Osciak, 2014/08/10 00:30:29]

I think we should handle errors? What happens if there is an error in the
stream?

[hshi1, 2014/08/12 01:06:55]

Should errors be expected? The stream is returned by the GpuVEA and not by user
input. I think a DLOG here should suffice?

[Pawel Osciak, 2014/08/12 11:06:38]

Well, we check for this anyway, and I'd expect things to not work too well if we
just pass this along, especially with incorrect fragmentation header. And if we
assume GpuVEA is always right, should have even less issue with having a
NotifyError() here, or at least dropping it...
What do you think?

[hshi1, 2014/08/12 18:08:22]

Sounds reasonable. Note that this function is in the anonymous namespace. I'm
making it return a bool to indicate error.

+    }
+  }
+
+  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;
+  }
+}
+
+}  // 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
 // |gpu_factories_| provides for accelerator operations (presently the media
 // thread).  The RTCVideoEncoder class can be deleted directly by WebRTC, while
@@ skipping 601 matching lines @@
                                          int32 bitstream_buffer_id,
                                          uint16 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::RTPFragmentationHeader header;
+  memset(&header, 0, sizeof(header));
+  switch (video_codec_type_) {
+    case webrtc::kVideoCodecVP8:
+    case webrtc::kVideoCodecGeneric:

[Pawel Osciak, 2014/08/10 00:30:30]

Generic wasn't here before. And given that it's treated the same as H264 in the
other file, why is it together with VP8 here?
Also, do we really need both? Could we fix webrtc to not use both instead?

[hshi1, 2014/08/10 00:36:10]

We're keeping Generic (and the payload type "CAST1") for v1 casting until we're
ready to deprecate it. Currently v1 casting is still being used on Stable.

[Pawel Osciak, 2014/08/10 01:14:34]

Generic is treated as H264 in the format conversion change, but not as H264
here...

[hshi1, 2014/08/11 17:43:00]

You're correct that Generic is treated differently from H264. In webrtc point of
view, "Generic" means opaque payloads not subject to the H.264 packetization
logic, they are always passed as a whole chunk with no fragmentation info
available. This is what we use for castV1.

We only get RTP fragmentation headers for the "real" H264 codec type.

[Pawel Osciak, 2014/08/12 11:06:38]

Ok, I'm fine with this, but please add a comment about this.

[hshi1, 2014/08/12 18:08:22]

Done.

+      header.VerifyAndAllocateFragmentationHeader(1);
+      header.fragmentationOffset[0] = 0;
+      header.fragmentationLength[0] = image->_length;
+      header.fragmentationPlType[0] = 0;
+      header.fragmentationTimeDiff[0] = 0;
+      break;
+    case webrtc::kVideoCodecH264:
+      GetRTPFragmentationHeaderH264(header, image->_buffer, image->_length);
+      break;
+    default:
+      NOTREACHED() << "Invalid video codec type";
+      return;
+  }
+
   webrtc::CodecSpecificInfo info;
   memset(&info, 0, sizeof(info));
   info.codecType = video_codec_type_;
   if (video_codec_type_ == webrtc::kVideoCodecVP8) {
     info.codecSpecific.VP8.pictureId = picture_id;
     info.codecSpecific.VP8.tl0PicIdx = -1;
     info.codecSpecific.VP8.keyIdx = -1;
   }
 
-  // Generate a header describing a single fragment.
-  webrtc::RTPFragmentationHeader header;
-  memset(&header, 0, sizeof(header));
-  header.VerifyAndAllocateFragmentationHeader(1);
-  header.fragmentationOffset[0] = 0;
-  header.fragmentationLength[0] = image->_length;
-  header.fragmentationPlType[0] = 0;
-  header.fragmentationTimeDiff[0] = 0;
-
   int32_t retval = encoded_image_callback_->Encoded(*image, &info, &header);
   if (retval < 0) {
     DVLOG(2) << "ReturnEncodedImage(): encoded_image_callback_ returned "
              << retval;
   }
 
   // The call through webrtc::EncodedImageCallback is synchronous, so we can
   // immediately recycle the output buffer back to the Impl.
   gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
@@ skipping 16 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