Revert "Fix visible size for V4L2 VDA"

content/common/gpu/media/v4l2_video_decode_accelerator.cc

Index: content/common/gpu/media/v4l2_video_decode_accelerator.cc
diff --git a/content/common/gpu/media/v4l2_video_decode_accelerator.cc b/content/common/gpu/media/v4l2_video_decode_accelerator.cc
index 82acdce7f067c89172a01ae573a574a4bad219bf..019446bbce6467a99384da6a8364142f6cec8f14 100644
--- a/content/common/gpu/media/v4l2_video_decode_accelerator.cc
+++ b/content/common/gpu/media/v4l2_video_decode_accelerator.cc
@@ -21,7 +21,6 @@
 #include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
 #include "media/base/media_switches.h"
 #include "media/filters/h264_parser.h"
-#include "ui/gfx/geometry/rect.h"
 #include "ui/gl/scoped_binders.h"
 
 #define NOTIFY_ERROR(x)                        \
@@ -340,7 +339,7 @@ void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
   // thread is waiting on pictures_assigned_.
   DCHECK(free_output_buffers_.empty());
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
-    DCHECK(buffers[i].size() == coded_size_);
+    DCHECK(buffers[i].size() == frame_buffer_size_);
 
     OutputRecord& output_record = output_buffer_map_[i];
     DCHECK(!output_record.at_device);
@@ -353,7 +352,7 @@ void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
     EGLImageKHR egl_image = device_->CreateEGLImage(egl_display_,
                                                     egl_context_,
                                                     buffers[i].texture_id(),
-                                                    coded_size_,
+                                                    frame_buffer_size_,
                                                     i,
                                                     output_format_fourcc_,
                                                     output_planes_count_);
@@ -730,9 +729,8 @@ bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
 
   // Check and see if we have format info yet.
   struct v4l2_format format;
-  gfx::Size visible_size;
   bool again = false;
-  if (!GetFormatInfo(&format, &visible_size, &again))
+  if (!GetFormatInfo(&format, &again))
     return false;
 
   if (again) {
@@ -745,7 +743,7 @@ bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
   if (decoder_state_ == kInitialized) {
     DVLOG(3) << "DecodeBufferInitial(): running initialization";
     // Success! Setup our parameters.
-    if (!CreateBuffersForFormat(format, visible_size))
+    if (!CreateBuffersForFormat(format))
       return false;
 
     // We expect to process the initial buffer once during stream init to
@@ -1087,7 +1085,7 @@ void V4L2VideoDecodeAccelerator::Dequeue() {
                << " as picture_id=" << output_record.picture_id;
       const media::Picture& picture =
           media::Picture(output_record.picture_id, dqbuf.timestamp.tv_sec,
-                         gfx::Rect(visible_size_), false);
+                         gfx::Rect(frame_buffer_size_), false);
       pending_picture_ready_.push(
           PictureRecord(output_record.cleared, picture));
       SendPictureReady();
@@ -1535,15 +1533,14 @@ void V4L2VideoDecodeAccelerator::FinishResolutionChange() {
 
   struct v4l2_format format;
   bool again;
-  gfx::Size visible_size;
-  bool ret = GetFormatInfo(&format, &visible_size, &again);
+  bool ret = GetFormatInfo(&format, &again);
   if (!ret || again) {
     LOG(ERROR) << "Couldn't get format information after resolution change";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
-  if (!CreateBuffersForFormat(format, visible_size)) {
+  if (!CreateBuffersForFormat(format)) {
     LOG(ERROR) << "Couldn't reallocate buffers after resolution change";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
@@ -1618,8 +1615,7 @@ void V4L2VideoDecodeAccelerator::SetErrorState(Error error) {
 }
 
 bool V4L2VideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
-                                               gfx::Size* visible_size,
-                                               bool* again) {
+                                                 bool* again) {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 
   *again = false;
@@ -1643,22 +1639,17 @@ bool V4L2VideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
     return false;
   }
 
-  gfx::Size coded_size(format->fmt.pix_mp.width, format->fmt.pix_mp.height);
-  if (!GetVisibleSize(coded_size, visible_size))
-    *visible_size = coded_size;
-
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::CreateBuffersForFormat(
-    const struct v4l2_format& format,
-    const gfx::Size& visible_size) {
+    const struct v4l2_format& format) {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   output_planes_count_ = format.fmt.pix_mp.num_planes;
-  coded_size_.SetSize(format.fmt.pix_mp.width, format.fmt.pix_mp.height);
-  visible_size_ = visible_size;
+  frame_buffer_size_.SetSize(
+      format.fmt.pix_mp.width, format.fmt.pix_mp.height);
   DVLOG(3) << "CreateBuffersForFormat(): new resolution: "
-           << coded_size_.ToString();
+           << frame_buffer_size_.ToString();
 
   if (!CreateOutputBuffers())
     return false;
@@ -1666,40 +1657,6 @@ bool V4L2VideoDecodeAccelerator::CreateBuffersForFormat(
   return true;
 }
 
-bool V4L2VideoDecodeAccelerator::GetVisibleSize(const gfx::Size& coded_size,
-                                                gfx::Size* visible_size) {
-  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
-
-  struct v4l2_crop crop_arg;
-  memset(&crop_arg, 0, sizeof(crop_arg));
-  crop_arg.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_G_CROP, &crop_arg);
-
-  gfx::Rect rect(crop_arg.c.left, crop_arg.c.top, crop_arg.c.width,
-                 crop_arg.c.height);
-  DVLOG(3) << "visible rectangle is " << rect.ToString();
-  if (!gfx::Rect(coded_size).Contains(rect)) {
-    DLOG(ERROR) << "visible rectangle " << rect.ToString()
-                << " is not inside coded size " << coded_size.ToString();
-    return false;
-  }
-  if (rect.IsEmpty()) {
-    DLOG(ERROR) << "visible size is empty";
-    return false;
-  }
-
-  // Chrome assume picture frame is coded at (0, 0).
-  if (!rect.origin().IsOrigin()) {
-    DLOG(ERROR) << "Unexpected visible rectangle " << rect.ToString()
-                << ", top-left is not origin";
-    return false;
-  }
-  *visible_size = rect.size();
-
-  return true;
-}
-
 bool V4L2VideoDecodeAccelerator::CreateInputBuffers() {
   DVLOG(3) << "CreateInputBuffers()";
   // We always run this as we prepare to initialize.
@@ -1829,12 +1786,13 @@ bool V4L2VideoDecodeAccelerator::CreateOutputBuffers() {
 
   DVLOG(3) << "CreateOutputBuffers(): ProvidePictureBuffers(): "
            << "buffer_count=" << output_buffer_map_.size()
-           << ", coded_size=" << coded_size_.ToString();
+           << ", width=" << frame_buffer_size_.width()
+           << ", height=" << frame_buffer_size_.height();
   child_message_loop_proxy_->PostTask(FROM_HERE,
                                       base::Bind(&Client::ProvidePictureBuffers,
                                                  client_,
                                                  output_buffer_map_.size(),
-                                                 coded_size_,
+                                                 frame_buffer_size_,
                                                  device_->GetTextureTarget()));
 
   // Wait for the client to call AssignPictureBuffers() on the Child thread.
@@ -2007,16 +1965,15 @@ bool V4L2VideoDecodeAccelerator::IsResolutionChangeNecessary() {
     return true;
   }
   struct v4l2_format format;
-  gfx::Size visible_size;
   bool again = false;
-  bool ret = GetFormatInfo(&format, &visible_size, &again);
+  bool ret = GetFormatInfo(&format, &again);
   if (!ret || again) {
     DVLOG(3) << "IsResolutionChangeNecessary(): GetFormatInfo() failed";
     return false;
   }
-  gfx::Size new_coded_size(base::checked_cast<int>(format.fmt.pix_mp.width),
-                           base::checked_cast<int>(format.fmt.pix_mp.height));
-  if (coded_size_ != new_coded_size) {
+  gfx::Size new_size(base::checked_cast<int>(format.fmt.pix_mp.width),
+                     base::checked_cast<int>(format.fmt.pix_mp.height));
+  if (frame_buffer_size_ != new_size) {
     DVLOG(3) << "IsResolutionChangeNecessary(): Resolution change detected";
     return true;
   }