Reland: Copy based on coded size in VideoTrackRecorder::VEAEncoder

content/renderer/media_recorder/video_track_recorder.cc

 // Copyright 2015 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_recorder/video_track_recorder.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 447 matching lines @@
   // Shared memory buffers for output with the VEA as FIFO.
   std::queue<std::unique_ptr<base::SharedMemory>> input_buffers_;
 
   // Tracks error status.
   bool error_notified_;
 
   // Tracks the last frame that we delay the encode.
   std::unique_ptr<VideoFrameAndTimestamp> last_frame_;
 
   // Size used to initialize encoder.
-  gfx::Size input_size_;
+  gfx::Size input_visible_size_;
 
   // Coded size that encoder requests as input.
-  gfx::Size vea_requested_input_size_;
+  gfx::Size vea_requested_input_coded_size_;
 
   // Frames and corresponding timestamps in encode as FIFO.
   std::queue<VideoParamsAndTimestamp> frames_in_encode_;
 };
 
 // Class encapsulating all libvpx interactions for VP8/VP9 encoding.
 class VpxEncoder final : public VideoTrackRecorder::Encoder {
  public:
   static void ShutdownEncoder(std::unique_ptr<base::Thread> encoding_thread,
                               ScopedVpxCodecCtxPtr encoder);
@@ skipping 141 matching lines @@
                             base::Unretained(this), &release_waiter));
   release_waiter.Wait();
 }
 
 void VEAEncoder::RequireBitstreamBuffers(unsigned int /*input_count*/,
                                          const gfx::Size& input_coded_size,
                                          size_t output_buffer_size) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
-  vea_requested_input_size_ = input_coded_size;
+  vea_requested_input_coded_size_ = input_coded_size;
   output_buffers_.clear();
   std::queue<std::unique_ptr<base::SharedMemory>>().swap(input_buffers_);
 
   for (int i = 0; i < kVEAEncoderOutputBufferCount; ++i) {
     std::unique_ptr<base::SharedMemory> shm =
         gpu_factories_->CreateSharedMemory(output_buffer_size);
     if (shm)
       output_buffers_.push_back(base::WrapUnique(shm.release()));
   }
 
@@ skipping 45 matching lines @@
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   input_buffers_.push(std::move(shm));
 }
 
 void VEAEncoder::EncodeOnEncodingTaskRunner(
    scoped_refptr<VideoFrame> frame,
     base::TimeTicks capture_timestamp) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
 
-  if (input_size_ != frame->visible_rect().size() && video_encoder_)
+  if (input_visible_size_ != frame->visible_rect().size() && video_encoder_)
     video_encoder_.reset();
 
   if (!video_encoder_)
     ConfigureEncoderOnEncodingTaskRunner(frame->visible_rect().size());
 
   if (error_notified_) {
     DVLOG(3) << "An error occurred in VEA encoder";
     return;
   }
 
@@ skipping 13 matching lines @@
     EncodeOnEncodingTaskRunner(last_frame->first, last_frame->second);
   }
 
   // Lower resolutions may fall back to SW encoder in some platforms, i.e. Mac.
   // In that case, the encoder expects more frames before returning result.
   // Therefore, a copy is necessary to release the current frame.
   // Only STORAGE_SHMEM backed frames can be shared with GPU process, therefore
   // a copy is required for other storage types.
   scoped_refptr<media::VideoFrame> video_frame = frame;
   if (video_frame->storage_type() != VideoFrame::STORAGE_SHMEM ||
-      vea_requested_input_size_ != input_size_ ||
-      input_size_.width() < kVEAEncoderMinResolutionWidth ||
-      input_size_.height() < kVEAEncoderMinResolutionHeight) {
+      vea_requested_input_coded_size_ != frame->coded_size() ||
+      input_visible_size_.width() < kVEAEncoderMinResolutionWidth ||
+      input_visible_size_.height() < kVEAEncoderMinResolutionHeight) {
     // Create SharedMemory backed input buffers as necessary. These SharedMemory
     // instances will be shared with GPU process.
     std::unique_ptr<base::SharedMemory> input_buffer;
     const size_t desired_mapped_size = media::VideoFrame::AllocationSize(
-        media::PIXEL_FORMAT_I420, vea_requested_input_size_);
+        media::PIXEL_FORMAT_I420, vea_requested_input_coded_size_);
     if (input_buffers_.empty()) {
       input_buffer = gpu_factories_->CreateSharedMemory(desired_mapped_size);
     } else {
       do {
         input_buffer = std::move(input_buffers_.front());
         input_buffers_.pop();
       } while (!input_buffers_.empty() &&
                input_buffer->mapped_size() < desired_mapped_size);
       if (!input_buffer || input_buffer->mapped_size() < desired_mapped_size)
         return;
     }
 
     video_frame = media::VideoFrame::WrapExternalSharedMemory(
-        media::PIXEL_FORMAT_I420, vea_requested_input_size_,
-        gfx::Rect(input_size_), input_size_,
+        media::PIXEL_FORMAT_I420, vea_requested_input_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,
         frame->timestamp());
     video_frame->AddDestructionObserver(media::BindToCurrentLoop(
         base::Bind(&VEAEncoder::FrameFinished, this,
                    base::Passed(std::move(input_buffer)))));
     libyuv::I420Copy(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),
                      video_frame->visible_data(media::VideoFrame::kYPlane),
                      video_frame->stride(media::VideoFrame::kYPlane),
                      video_frame->visible_data(media::VideoFrame::kUPlane),
                      video_frame->stride(media::VideoFrame::kUPlane),
                      video_frame->visible_data(media::VideoFrame::kVPlane),
                      video_frame->stride(media::VideoFrame::kVPlane),
-                     input_size_.width(), input_size_.height());
+                     input_visible_size_.width(), input_visible_size_.height());
   }
   frames_in_encode_.push(std::make_pair(
       media::WebmMuxer::VideoParameters(frame), capture_timestamp));
 
   video_encoder_->Encode(video_frame, false);
 }
 
 void VEAEncoder::ConfigureEncoderOnEncodingTaskRunner(const gfx::Size& size) {
   DVLOG(3) << __func__;
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   DCHECK(gpu_factories_->GetTaskRunner()->BelongsToCurrentThread());
   DCHECK_GT(bits_per_second_, 0);
 
-  input_size_ = size;
+  input_visible_size_ = size;
   video_encoder_ = gpu_factories_->CreateVideoEncodeAccelerator();
   if (!video_encoder_ ||
-      !video_encoder_->Initialize(media::PIXEL_FORMAT_I420, input_size_, codec_,
-                                  bits_per_second_, this)) {
+      !video_encoder_->Initialize(media::PIXEL_FORMAT_I420, input_visible_size_,
+                                  codec_, bits_per_second_, this)) {
     NotifyError(media::VideoEncodeAccelerator::kPlatformFailureError);
   }
 }
 
 void VEAEncoder::DestroyOnEncodingTaskRunner(
     base::WaitableEvent* async_waiter) {
   DCHECK(encoding_task_runner_->BelongsToCurrentThread());
   video_encoder_.reset();
   async_waiter->Signal();
 }
@@ skipping 533 matching lines @@
       base::Bind(&VideoTrackRecorder::Encoder::StartFrameEncode, encoder_),
       false);
 }
 
 bool VideoTrackRecorder::CanEncodeAlphaChannelForTesting() {
   DCHECK(encoder_);
   return encoder_->CanEncodeAlphaChannel();
 }
 
 }  // namespace content