RTCVideoEncoder.SupportsNativeHandle() should return true

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 <deque>
 #include <memory>
@@ skipping 602 matching lines @@
                 ->getMediaVideoFrame();
     requires_copy = RequiresSizeChange(frame) ||
                     frame->storage_type() != media::VideoFrame::STORAGE_SHMEM;
   } else {
     requires_copy = true;
   }
 
   if (requires_copy) {
     const base::TimeDelta timestamp =
         frame ? frame->timestamp()
               : base::TimeDelta::FromMilliseconds(next_frame->ntp_time_ms());

[emircan, 2017/06/12 20:06:16]

We were hitting DCHECK before because next_frame->ntp_time_ms() was 0. We should
still handle this case if webrtc makes a copy and drops the media::VideoFrame
reference somehow, i.e. simulcast was doing that before.

I am not sure what to use here, maybe nisse@ can help. We need to input a
strictly increasing presentation timestamp to HW encoders.
next_frame->timestamp() is in 90 kHz; we can't use here and 90 kHz domain is why
we need to map back and forth. 

[magjed_chromium, 2017/06/12 20:28:13]

Can we land this CL to fix the immediate issues and discuss the timestamp issue
in a follow-up CL?

[nisse-chromium (ooo August 14), 2017/06/13 08:06:44]

I don't quite understand the context here, but in general, the timestamp_us()
method should give you a valid and increasing timestamp.

     base::SharedMemory* input_buffer = input_buffers_[index].get();
     frame = media::VideoFrame::WrapExternalSharedMemory(
         media::PIXEL_FORMAT_I420, input_frame_coded_size_,
         gfx::Rect(input_visible_size_), input_visible_size_,
         reinterpret_cast<uint8_t*>(input_buffer->memory()),
         input_buffer->mapped_size(), input_buffer->handle(), 0, timestamp);
     if (!frame.get()) {
       LogAndNotifyError(FROM_HERE, "failed to create frame",
                         media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
 
     // Do a strided copy and scale (if necessary) the input frame to match
     // the input requirements for the encoder.
     // TODO(sheu): Support zero-copy from WebRTC. http://crbug.com/269312
     // TODO(magjed): Downscale with kFilterBox in an image pyramid instead.
-    if (libyuv::I420Scale(next_frame->video_frame_buffer()->DataY(),
-                          next_frame->video_frame_buffer()->StrideY(),
-                          next_frame->video_frame_buffer()->DataU(),
-                          next_frame->video_frame_buffer()->StrideU(),
-                          next_frame->video_frame_buffer()->DataV(),
-                          next_frame->video_frame_buffer()->StrideV(),
+    rtc::scoped_refptr<webrtc::I420BufferInterface> i420_buffer =

[nisse-chromium (ooo August 14), 2017/06/13 08:06:44]

Do we intend to change ToI420 to a const method? If so, could use

rtc::scoped_refptr<const webrtc::I420BufferInterface> 

here, right away.

+        next_frame->video_frame_buffer()->ToI420();
+    if (libyuv::I420Scale(i420_buffer->DataY(), i420_buffer->StrideY(),
+                          i420_buffer->DataU(), i420_buffer->StrideU(),
+                          i420_buffer->DataV(), i420_buffer->StrideV(),
                           next_frame->width(), next_frame->height(),
                           frame->visible_data(media::VideoFrame::kYPlane),
                           frame->stride(media::VideoFrame::kYPlane),
                           frame->visible_data(media::VideoFrame::kUPlane),
                           frame->stride(media::VideoFrame::kUPlane),
                           frame->visible_data(media::VideoFrame::kVPlane),
                           frame->stride(media::VideoFrame::kVPlane),
                           frame->visible_rect().width(),
-                          frame->visible_rect().height(),
-                          libyuv::kFilterBox)) {
+                          frame->visible_rect().height(), libyuv::kFilterBox)) {
       LogAndNotifyError(FROM_HERE, "Failed to copy buffer",
                         media::VideoEncodeAccelerator::kPlatformFailureError);
       return;
     }
   }
   frame->AddDestructionObserver(media::BindToCurrentLoop(
       base::Bind(&RTCVideoEncoder::Impl::EncodeFrameFinished, this, index)));
   if (!failed_timestamp_match_) {
     DCHECK(std::find_if(pending_timestamps_.begin(), pending_timestamps_.end(),
                         [&frame](const RTCTimestamps& entry) {
@@ skipping 260 matching lines @@
 
   gpu_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&RTCVideoEncoder::Impl::RequestEncodingParametersChange,
                  impl_,
                  new_bit_rate,
                  frame_rate));
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
+bool RTCVideoEncoder::SupportsNativeHandle() const {
+  return true;
+}
+
 void RTCVideoEncoder::RecordInitEncodeUMA(
     int32_t init_retval, media::VideoCodecProfile profile) {
   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