PepperVideoSourceHost: Use natural_size instead of visible_rect.size

content/renderer/pepper/pepper_video_source_host.cc

 // Copyright (c) 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/pepper/pepper_video_source_host.h"
 
 #include "base/bind.h"
 #include "base/numerics/safe_conversions.h"
 #include "content/public/renderer/renderer_ppapi_host.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/proxy/host_dispatcher.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/ppb_image_data_proxy.h"
 #include "ppapi/shared_impl/scoped_pp_resource.h"
 #include "ppapi/thunk/enter.h"
 #include "ppapi/thunk/ppb_image_data_api.h"
 #include "third_party/libyuv/include/libyuv/convert.h"
+#include "third_party/libyuv/include/libyuv/scale.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 using ppapi::host::HostMessageContext;
 using ppapi::host::ReplyMessageContext;
 
 namespace content {
 
 PepperVideoSourceHost::FrameReceiver::FrameReceiver(
     const base::WeakPtr<PepperVideoSourceHost>& host)
     : host_(host) {}
@@ skipping 76 matching lines @@
 int32_t PepperVideoSourceHost::OnHostMsgClose(HostMessageContext* context) {
   Close();
   return PP_OK;
 }
 
 void PepperVideoSourceHost::SendGetFrameReply() {
   DCHECK(get_frame_pending_);
   get_frame_pending_ = false;
 
   DCHECK(last_frame_.get());
-  scoped_refptr<media::VideoFrame> frame(last_frame_);
-  last_frame_ = NULL;
-
-  const int dst_width = frame->visible_rect().width();
-  const int dst_height = frame->visible_rect().height();
+  const gfx::Size dst_size = last_frame_->natural_size();
 
   // Note: We try to reuse the shared memory for the previous frame here. This
   // means that the previous frame may be overwritten and is no longer valid
   // after calling this function again.
   IPC::PlatformFileForTransit image_handle;
   uint32_t byte_count;
-  if (shared_image_.get() && dst_width == shared_image_->width() &&
-      dst_height == shared_image_->height()) {
+  if (shared_image_.get() && dst_size.width() == shared_image_->width() &&
+      dst_size.height() == shared_image_->height()) {
     // We have already allocated the correct size in shared memory. We need to
     // duplicate the handle for IPC however, which will close down the
     // duplicated handle when it's done.
     int local_fd = 0;
     if (shared_image_->GetSharedMemory(&local_fd, &byte_count) != PP_OK) {
       SendGetFrameErrorReply(PP_ERROR_FAILED);
       return;
     }
 
     ppapi::proxy::HostDispatcher* dispatcher =
@@ skipping 14 matching lines @@
   } else {
     // We need to allocate new shared memory.
     shared_image_ = NULL;  // Release any previous image.
 
     ppapi::ScopedPPResource resource(
         ppapi::ScopedPPResource::PassRef(),
         ppapi::proxy::PPB_ImageData_Proxy::CreateImageData(
             pp_instance(),
             ppapi::PPB_ImageData_Shared::SIMPLE,
             PP_IMAGEDATAFORMAT_BGRA_PREMUL,
-            PP_MakeSize(dst_width, dst_height),
+            PP_MakeSize(dst_size.width(), dst_size.height()),
             false /* init_to_zero */,
             &shared_image_desc_,
             &image_handle,
             &byte_count));
     if (!resource) {
       SendGetFrameErrorReply(PP_ERROR_FAILED);
       return;
     }
 
     ppapi::thunk::EnterResourceNoLock<ppapi::thunk::PPB_ImageData_API>
@@ skipping 23 matching lines @@
     SendGetFrameErrorReply(PP_ERROR_FAILED);
     return;
   }
 
   uint8_t* bitmap_pixels = static_cast<uint8_t*>(bitmap->getPixels());
   if (!bitmap_pixels) {
     SendGetFrameErrorReply(PP_ERROR_FAILED);
     return;
   }
 
-  // Calculate that portion of the |frame| that should be copied into
-  // |bitmap|. If |frame| has been cropped,
-  // frame->coded_size() != frame->visible_rect().
-  const int src_width = frame->coded_size().width();
-  const int src_height = frame->coded_size().height();
-  DCHECK(src_width >= dst_width && src_height >= dst_height);
-
-  const int horiz_crop = frame->visible_rect().x();
-  const int vert_crop = frame->visible_rect().y();
-
-  const uint8* src_y = frame->data(media::VideoFrame::kYPlane) +
-                       (src_width * vert_crop + horiz_crop);
-  const int center = (src_width + 1) / 2;
-  const uint8* src_u = frame->data(media::VideoFrame::kUPlane) +
-                       (center * vert_crop + horiz_crop) / 2;
-  const uint8* src_v = frame->data(media::VideoFrame::kVPlane) +
-                       (center * vert_crop + horiz_crop) / 2;
+  // Calculate the portion of the |last_frame_| that should be copied into
+  // |bitmap|. If |last_frame_| is lazily scaled, then
+  // last_frame_->visible_rect()._size() != last_frame_.natural_size().
+  scoped_refptr<media::VideoFrame> frame;
+  if (dst_size == last_frame_->visible_rect().size()) {
+    // No scaling is needed, convert directly from last_frame_.
+    frame = last_frame_;
+    // Frame resolution doesn't change frequently, so don't keep any unnecessary
+    // buffers around.
+    scaled_frame_ = NULL;
+  } else {
+    // We need to create an intermediate scaled frame. Make sure we have
+    // allocated one of correct size.
+    if (!scaled_frame_.get() || scaled_frame_->coded_size() != dst_size) {
+      scaled_frame_ = media::VideoFrame::CreateFrame(
+          media::VideoFrame::I420, dst_size, gfx::Rect(dst_size), dst_size,
+          last_frame_->timestamp());
+      if (!scaled_frame_.get()) {
+        LOG(ERROR) << "Failed to allocate a media::VideoFrame";
+        SendGetFrameErrorReply(PP_ERROR_FAILED);
+        return;
+      }
+    }
+    libyuv::I420Scale(last_frame_->visible_data(media::VideoFrame::kYPlane),
+                      last_frame_->stride(media::VideoFrame::kYPlane),
+                      last_frame_->visible_data(media::VideoFrame::kUPlane),
+                      last_frame_->stride(media::VideoFrame::kUPlane),
+                      last_frame_->visible_data(media::VideoFrame::kVPlane),
+                      last_frame_->stride(media::VideoFrame::kVPlane),
+                      last_frame_->visible_rect().width(),
+                      last_frame_->visible_rect().height(),
+                      scaled_frame_->data(media::VideoFrame::kYPlane),
+                      scaled_frame_->stride(media::VideoFrame::kYPlane),
+                      scaled_frame_->data(media::VideoFrame::kUPlane),
+                      scaled_frame_->stride(media::VideoFrame::kUPlane),
+                      scaled_frame_->data(media::VideoFrame::kVPlane),
+                      scaled_frame_->stride(media::VideoFrame::kVPlane),
+                      dst_size.width(),
+                      dst_size.height(),
+                      libyuv::kFilterBilinear);
+    frame = scaled_frame_;
+  }
+  last_frame_ = NULL;
 
   // TODO(magjed): Chrome OS is not ready for switching from BGRA to ARGB.
   // Remove this once http://crbug/434007 is fixed. We have a corresponding
   // problem when we receive frames from the effects plugin in PpFrameWriter.
 #if defined(OS_CHROMEOS)
   auto libyuv_i420_to_xxxx = &libyuv::I420ToBGRA;
 #else
   auto libyuv_i420_to_xxxx = &libyuv::I420ToARGB;
 #endif
-  libyuv_i420_to_xxxx(src_y,
+  libyuv_i420_to_xxxx(frame->visible_data(media::VideoFrame::kYPlane),
                       frame->stride(media::VideoFrame::kYPlane),
-                      src_u,
+                      frame->visible_data(media::VideoFrame::kUPlane),
                       frame->stride(media::VideoFrame::kUPlane),
-                      src_v,
+                      frame->visible_data(media::VideoFrame::kVPlane),
                       frame->stride(media::VideoFrame::kVPlane),
                       bitmap_pixels,
                       bitmap->rowBytes(),
-                      dst_width,
-                      dst_height);
+                      dst_size.width(),
+                      dst_size.height());
 
   ppapi::HostResource host_resource;
   host_resource.SetHostResource(pp_instance(), shared_image_->GetReference());
 
   // Convert a video timestamp to a PP_TimeTicks (a double, in seconds).
   const PP_TimeTicks timestamp = frame->timestamp().InSecondsF();
 
   ppapi::proxy::SerializedHandle serialized_handle;
   serialized_handle.set_shmem(image_handle, byte_count);
   reply_context_.params.AppendHandle(serialized_handle);
@@ skipping 18 matching lines @@
   if (source_handler_.get() && !stream_url_.empty())
     source_handler_->Close(frame_receiver_.get());
 
   source_handler_.reset(NULL);
   stream_url_.clear();
 
   shared_image_ = NULL;
 }
 
 }  // namespace content