Support for H264 HW offload for webRTC.

content/renderer/media/rtc_video_encoder.cc

Index: content/renderer/media/rtc_video_encoder.cc
diff --git a/content/renderer/media/rtc_video_encoder.cc b/content/renderer/media/rtc_video_encoder.cc
index 1b33fc54c90abe6881a48565c6d9fbb4aa58b513..182877129f084d2e8ca029dd48c3a95fc0ff6e15 100644
--- a/content/renderer/media/rtc_video_encoder.cc
+++ b/content/renderer/media/rtc_video_encoder.cc
@@ -16,6 +16,7 @@
 #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"
 
@@ -27,6 +28,43 @@
 
 namespace content {
 
+namespace {
+
+// 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, uint8_t* data, uint32_t length) {

[DaleCurtis, 2014/08/15 16:48:50]

non-const& not allowed. make it a pointer. Data can be const?

[hshi1, 2014/08/15 20:14:56]

Done.

+  media::H264Parser parser;
+  parser.SetStream(data, length);
+
+  std::vector<media::H264NALU> nalu_vector;
+  while (true) {
+    media::H264NALU nalu;
+    media::H264Parser::Result result;

[DaleCurtis, 2014/08/15 16:48:49]

Combine line with result = below. const result if you like.

[hshi1, 2014/08/15 20:14:56]

Done.

+    result = parser.AdvanceToNextNALU(&nalu);
+    if (result == media::H264Parser::kOk) {
+      nalu_vector.push_back(nalu);
+    } else if (result == media::H264Parser::kEOStream) {
+      break;
+    } else {
+      DLOG(ERROR) << "Unexpected H264 parser result";
+      return false;
+    }
+  }
+
+  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;
+}
+
+}  // 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()
@@ -648,6 +686,32 @@ void RTCVideoEncoder::ReturnEncodedImage(scoped_ptr<webrtc::EncodedImage> image,
   if (!encoded_image_callback_)
     return;
 
+  webrtc::RTPFragmentationHeader header;

[DaleCurtis, 2014/08/15 16:48:50]

Instead of using memset just add a = {0} here.

[hshi1, 2014/08/15 20:14:56]

Sorry I'm afraid I can't do that. RTPFragmentationHeader is a class, not a
struct. "= {0}" is not allowed.

If I attempt that I get compiler error "error: could not convert '{0}' from
'<brace-enclosed initializer list>' to 'webrtc::RTPFragmentationHeader'".

[DaleCurtis, 2014/08/18 17:34:48]

Hmm, I don't think this is the right way to zero out header if it's a class
then. It should self initialize its member variables or be a struct.  Since this
is already done in this file, it's okay to fix in a followup.

+  memset(&header, 0, sizeof(header));
+  switch (video_codec_type_) {
+    case webrtc::kVideoCodecVP8:
+    case webrtc::kVideoCodecGeneric:
+      // Generate a header describing a single fragment.
+      // Note that webrtc treats the generic-type payload as an opaque buffer.
+      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(WEBRTC_VIDEO_CODEC_ERROR);
+        return;
+      }
+      break;
+    default:
+      NOTREACHED() << "Invalid video codec type";
+      return;
+  }
+
   webrtc::CodecSpecificInfo info;
   memset(&info, 0, sizeof(info));

[DaleCurtis, 2014/08/15 16:48:49]

Ditto.

[hshi1, 2014/08/15 20:14:56]

Ditto, not allowed.

   info.codecType = video_codec_type_;
@@ -657,15 +721,6 @@ void RTCVideoEncoder::ReturnEncodedImage(scoped_ptr<webrtc::EncodedImage> image,
     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 "