Passing Texture backed VideoFrame through WebRTC wrappers

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/metrics/histogram.h"
 #include "base/rand_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
+#include "media/base/bind_to_current_loop.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #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/system_wrappers/interface/tick_util.h"
 
 #define NOTIFY_ERROR(x)                             \
@@ skipping 389 matching lines @@
     NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
     return;
   }
   output_buffers_free_count_--;
 
   // Use webrtc timestamps to ensure correct RTP sender behavior.
   // TODO(hshi): obtain timestamp from the capturer, see crbug.com/350106.
   const int64 capture_time_us = webrtc::TickTime::MicrosecondTimestamp();
 
   // Derive the capture time (in ms) and RTP timestamp (in 90KHz ticks).
-  int64 capture_time_ms = capture_time_us / 1000;
-  uint32_t rtp_timestamp = static_cast<uint32_t>(capture_time_us * 90 / 1000);
+  const int64 capture_time_ms = capture_time_us / 1000;
+  const uint32_t rtp_timestamp =
+      static_cast<uint32_t>(capture_time_us * 90 / 1000);
 
   scoped_ptr<webrtc::EncodedImage> image(new webrtc::EncodedImage(
       reinterpret_cast<uint8_t*>(output_buffer->memory()),
       payload_size,
       output_buffer->mapped_size()));
   image->_encodedWidth = input_visible_size_.width();
   image->_encodedHeight = input_visible_size_.height();
   image->_timeStamp = rtp_timestamp;
   image->capture_time_ms_ = capture_time_ms;
   image->_frameType = (key_frame ? webrtc::kKeyFrame : webrtc::kDeltaFrame);
@@ skipping 37 matching lines @@
   DVLOG(3) << "Impl::EncodeOneFrame()";
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(input_next_frame_);
   DCHECK(!input_buffers_free_.empty());
 
   // EncodeOneFrame() may re-enter EncodeFrameFinished() if VEA::Encode() fails,
   // we receive a VEA::NotifyError(), and the media::VideoFrame we pass to
   // Encode() gets destroyed early.  Handle this by resetting our
   // input_next_frame_* state before we hand off the VideoFrame to the VEA.
   const webrtc::VideoFrame* next_frame = input_next_frame_;
-  bool next_frame_keyframe = input_next_frame_keyframe_;
+  const bool next_frame_keyframe = input_next_frame_keyframe_;
   input_next_frame_ = NULL;
   input_next_frame_keyframe_ = false;
 
   if (!video_encoder_) {
     SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_ERROR);
     return;
   }
 
   const int index = input_buffers_free_.back();
-  base::SharedMemory* input_buffer = input_buffers_[index];
-  scoped_refptr<media::VideoFrame> frame =
-      media::VideoFrame::WrapExternalSharedMemory(
-          media::VideoFrame::I420,
-          input_frame_coded_size_,
-          gfx::Rect(input_visible_size_),
-          input_visible_size_,
-          reinterpret_cast<uint8*>(input_buffer->memory()),
-          input_buffer->mapped_size(),
-          input_buffer->handle(),
-          0,
-          base::TimeDelta());
-  frame->AddDestructionObserver(
-      base::Bind(&RTCVideoEncoder::Impl::EncodeFrameFinished, this, index));
-  if (!frame.get()) {
-    DLOG(ERROR) << "Impl::EncodeOneFrame(): failed to create frame";
-    NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
-    return;
+  scoped_refptr<media::VideoFrame> frame;
+  if (next_frame->native_handle()) {
+    frame = static_cast<media::VideoFrame*>(next_frame->native_handle());
+  } else {
+    base::SharedMemory* input_buffer = input_buffers_[index];
+    frame = media::VideoFrame::WrapExternalSharedMemory(
+        media::VideoFrame::I420,
+        input_frame_coded_size_,
+        gfx::Rect(input_visible_size_),
+        input_visible_size_,
+        reinterpret_cast<uint8*>(input_buffer->memory()),
+        input_buffer->mapped_size(),
+        input_buffer->handle(),
+        0,
+        base::TimeDelta());
+      frame->AddDestructionObserver(
+          base::Bind(&RTCVideoEncoder::Impl::EncodeFrameFinished, this, index));
+    if (!frame.get()) {
+      DLOG(ERROR) << "Impl::EncodeOneFrame(): failed to create frame";
+      NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
+      return;
+    }
+    // Do a strided copy of the input frame to match the input requirements for
+    // the encoder.
+    // TODO(sheu): support zero-copy from WebRTC.  http://crbug.com/269312
+    if (libyuv::I420Copy(next_frame->buffer(webrtc::kYPlane),
+                         next_frame->stride(webrtc::kYPlane),
+                         next_frame->buffer(webrtc::kUPlane),
+                         next_frame->stride(webrtc::kUPlane),
+                         next_frame->buffer(webrtc::kVPlane),
+                         next_frame->stride(webrtc::kVPlane),
+                         frame->data(media::VideoFrame::kYPlane),
+                         frame->stride(media::VideoFrame::kYPlane),
+                         frame->data(media::VideoFrame::kUPlane),
+                         frame->stride(media::VideoFrame::kUPlane),
+                         frame->data(media::VideoFrame::kVPlane),
+                         frame->stride(media::VideoFrame::kVPlane),
+                         next_frame->width(), next_frame->height())) {
+      DLOG(ERROR) << "Failed to copy buffer";
+      NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
+      return;
+    }
   }
-
-  // Do a strided copy of the input frame to match the input requirements for
-  // the encoder.
-  // TODO(sheu): support zero-copy from WebRTC.  http://crbug.com/269312
-  if (libyuv::I420Copy(next_frame->buffer(webrtc::kYPlane),
-                       next_frame->stride(webrtc::kYPlane),
-                       next_frame->buffer(webrtc::kUPlane),
-                       next_frame->stride(webrtc::kUPlane),
-                       next_frame->buffer(webrtc::kVPlane),
-                       next_frame->stride(webrtc::kVPlane),
-                       frame->data(media::VideoFrame::kYPlane),
-                       frame->stride(media::VideoFrame::kYPlane),
-                       frame->data(media::VideoFrame::kUPlane),
-                       frame->stride(media::VideoFrame::kUPlane),
-                       frame->data(media::VideoFrame::kVPlane),
-                       frame->stride(media::VideoFrame::kVPlane),
-                       next_frame->width(),
-                       next_frame->height())) {
-    DLOG(ERROR) << "Failed to copy buffer";
-    NOTIFY_ERROR(media::VideoEncodeAccelerator::kPlatformFailureError);
-    return;
-  }
-
+  frame->AddDestructionObserver(media::BindToCurrentLoop(

[mcasas, 2015/06/26 23:52:56]

This will register EncodeFrameFinished() a second time
for memory-backed VideoFrames, after l. 511. Is that
what we want?

[emircan, 2015/06/27 00:37:17]

Thanks for pointing out, I removed l.511. I must have missed it while rebasing.

+      base::Bind(&RTCVideoEncoder::Impl::EncodeFrameFinished, this, index)));
   video_encoder_->Encode(frame, next_frame_keyframe);
   input_buffers_free_.pop_back();
   SignalAsyncWaiter(WEBRTC_VIDEO_CODEC_OK);
 }
 
 void RTCVideoEncoder::Impl::EncodeFrameFinished(int index) {
   DVLOG(3) << "Impl::EncodeFrameFinished(): index=" << index;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_GE(index, 0);
   DCHECK_LT(index, static_cast<int>(input_buffers_.size()));
@@ skipping 48 matching lines @@
 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;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!impl_.get());
 
-  media::VideoCodecProfile profile = WebRTCVideoCodecToVideoCodecProfile(
-      video_codec_type_, codec_settings);
+  const media::VideoCodecProfile profile =
+      WebRTCVideoCodecToVideoCodecProfile(video_codec_type_, codec_settings);
 
   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),
@@ skipping 11 matching lines @@
 int32_t RTCVideoEncoder::Encode(
     const webrtc::VideoFrame& input_image,
     const webrtc::CodecSpecificInfo* codec_specific_info,
     const std::vector<webrtc::VideoFrameType>* frame_types) {
   DVLOG(3) << "Encode()";
   if (!impl_.get()) {
     DVLOG(3) << "Encode(): returning impl_status_=" << impl_status_;
     return impl_status_;
   }
 
-  bool want_key_frame = frame_types && frame_types->size() &&
+  const bool want_key_frame = frame_types && frame_types->size() &&
                         frame_types->front() == webrtc::kKeyFrame;
   base::WaitableEvent encode_waiter(true, false);
   int32_t encode_retval = WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   gpu_factories_->GetTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::Enqueue,
                  impl_,
                  &input_image,
                  want_key_frame,
                  &encode_waiter,
@@ skipping 131 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