Revert of Add support for converting I420 software frames into NV12 hardware frames

media/video/gpu_memory_buffer_video_frame_pool.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 "media/video/gpu_memory_buffer_video_frame_pool.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 
 #include <algorithm>
@@ skipping 143 matching lines @@
 // output size is |kBytesPerCopyTarget| bytes and run in parallel.
 const size_t kBytesPerCopyTarget = 1024 * 1024;  // 1MB
 
 // Return the GpuMemoryBuffer format to use for a specific VideoPixelFormat
 // and plane.
 gfx::BufferFormat GpuMemoryBufferFormat(VideoPixelFormat format, size_t plane) {
   switch (format) {
     case PIXEL_FORMAT_I420:
       DCHECK_LE(plane, 2u);
       return gfx::BufferFormat::R_8;
-    case PIXEL_FORMAT_NV12:
-      DCHECK_LE(plane, 1u);
-      return gfx::BufferFormat::YUV_420_BIPLANAR;
     case PIXEL_FORMAT_UYVY:
       DCHECK_EQ(0u, plane);
       return gfx::BufferFormat::UYVY_422;
     default:
       NOTREACHED();
       return gfx::BufferFormat::BGRA_8888;
   }
 }
 
 unsigned ImageInternalFormat(VideoPixelFormat format, size_t plane) {
   switch (format) {
     case PIXEL_FORMAT_I420:
       DCHECK_LE(plane, 2u);
       return GL_R8_EXT;
-    case PIXEL_FORMAT_NV12:
-      DCHECK_LE(plane, 1u);
-      DLOG(WARNING) << "NV12 format not supported yet";
-      return 0;  // TODO(andresantoso): Implement extension for NV12.
     case PIXEL_FORMAT_UYVY:
       DCHECK_EQ(0u, plane);
       return GL_RGB_YCBCR_422_CHROMIUM;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
-// The number of output planes to be copied in each iteration.
-size_t PlanesPerCopy(VideoPixelFormat format) {
-  switch (format) {
-    case PIXEL_FORMAT_I420:
-    case PIXEL_FORMAT_UYVY:
-      return 1;
-    case PIXEL_FORMAT_NV12:
-      return 2;
-    default:
-      NOTREACHED();
-      return 0;
-  }
-}
-
-// The number of output rows to be copied in each iteration.
-int RowsPerCopy(size_t plane, VideoPixelFormat format, int width) {
-  int bytes_per_row = VideoFrame::RowBytes(plane, format, width);
-  if (format == PIXEL_FORMAT_NV12) {
-    DCHECK_EQ(0u, plane);
-    bytes_per_row += VideoFrame::RowBytes(1, format, width);
-  }
-  // Copy an even number of lines, and at least one.
-  return std::max<size_t>((kBytesPerCopyTarget / bytes_per_row) & ~1, 1);
-}
-
 void CopyRowsToI420Buffer(int first_row,
                           int rows,
                           int bytes_per_row,
                           const uint8* source,
                           int source_stride,
                           uint8* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToI420Buffer", "bytes_per_row", bytes_per_row,
                "rows", rows);
   DCHECK_NE(dest_stride, 0);
   DCHECK_LE(bytes_per_row, std::abs(dest_stride));
   DCHECK_LE(bytes_per_row, source_stride);
   for (int row = first_row; row < first_row + rows; ++row) {
     memcpy(output + dest_stride * row, source + source_stride * row,
            bytes_per_row);
   }
   done.Run();
 }
 
-void CopyRowsToNV12Buffer(int first_row,
-                          int rows,
-                          int bytes_per_row,
-                          const scoped_refptr<VideoFrame>& source_frame,
-                          uint8* dest_y,
-                          int dest_stride_y,
-                          uint8* dest_uv,
-                          int dest_stride_uv,
-                          const base::Closure& done) {
-  TRACE_EVENT2("media", "CopyRowsToNV12Buffer", "bytes_per_row", bytes_per_row,
-               "rows", rows);
-  DCHECK_NE(dest_stride_y, 0);
-  DCHECK_NE(dest_stride_uv, 0);
-  DCHECK_LE(bytes_per_row, std::abs(dest_stride_y));
-  DCHECK_LE(bytes_per_row, std::abs(dest_stride_uv));
-  DCHECK_EQ(0, first_row % 2);
-  libyuv::I420ToNV12(
-      source_frame->data(VideoFrame::kYPlane) +
-          first_row * source_frame->stride(VideoFrame::kYPlane),
-      source_frame->stride(VideoFrame::kYPlane),
-      source_frame->data(VideoFrame::kUPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
-      source_frame->stride(VideoFrame::kUPlane),
-      source_frame->data(VideoFrame::kVPlane) +
-          first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
-      source_frame->stride(VideoFrame::kVPlane),
-      dest_y + first_row * dest_stride_y, dest_stride_y,
-      dest_uv + first_row / 2 * dest_stride_uv, dest_stride_uv,
-      bytes_per_row, rows);
-  done.Run();
-}
-
 void CopyRowsToUYVYBuffer(int first_row,
                           int rows,
                           int width,
                           const scoped_refptr<VideoFrame>& source_frame,
                           uint8* output,
                           int dest_stride,
                           const base::Closure& done) {
   TRACE_EVENT2("media", "CopyRowsToUYVYBuffer", "bytes_per_row", width * 2,
                "rows", rows);
   DCHECK_NE(dest_stride, 0);
@@ skipping 74 matching lines @@
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::OnCopiesDone(
     const scoped_refptr<VideoFrame>& video_frame,
     FrameResources* frame_resources,
     const FrameReadyCB& frame_ready_cb) {
-  for (const auto& plane_resource : frame_resources->plane_resources) {
-    if (plane_resource.gpu_memory_buffer)
-      plane_resource.gpu_memory_buffer->Unmap();
+  const size_t planes = VideoFrame::NumPlanes(output_format_);
+  for (size_t i = 0; i < planes; ++i) {
+    frame_resources->plane_resources[i].gpu_memory_buffer->Unmap();
   }
 
   media_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&PoolImpl::BindAndCreateMailboxesHardwareFrameResources, this,
                  video_frame, frame_resources, frame_ready_cb));
 }
 
 // Copies |video_frame| into |frame_resources| asynchronously, posting n tasks
 // that will be synchronized by a barrier.
 // After the barrier is passed OnCopiesDone will be called.
 void GpuMemoryBufferVideoFramePool::PoolImpl::CopyVideoFrameToGpuMemoryBuffers(
     const scoped_refptr<VideoFrame>& video_frame,
     FrameResources* frame_resources,
     const FrameReadyCB& frame_ready_cb) {
   // Compute the number of tasks to post and create the barrier.
-  const size_t num_planes = VideoFrame::NumPlanes(output_format_);
-  const size_t planes_per_copy = PlanesPerCopy(output_format_);
+  const size_t dest_planes = VideoFrame::NumPlanes(output_format_);
   gfx::Size size = video_frame->visible_rect().size();
   size_t copies = 0;
-  for (size_t i = 0; i < num_planes; i += planes_per_copy) {
-    const int rows = VideoFrame::Rows(i, output_format_, size.height());
-    const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
+  for (size_t i = 0; i < dest_planes; ++i) {
+    int rows = VideoFrame::Rows(i, output_format_, size.height());
+    int bytes_per_row = VideoFrame::RowBytes(i, output_format_, size.width());
+    // Copy a even number of lines, and at least one.
+    int rows_per_copy =
+        std::max<size_t>((kBytesPerCopyTarget / bytes_per_row) & ~1, 1);
     copies += rows / rows_per_copy;
     if (rows % rows_per_copy)
       ++copies;
   }
   base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
                  frame_ready_cb);
   base::Closure barrier = base::BarrierClosure(copies, copies_done);
+  // Post all the async tasks.
+  for (size_t i = 0; i < dest_planes; ++i) {
+    int rows = VideoFrame::Rows(i, output_format_, size.height());
+    int bytes_per_row = VideoFrame::RowBytes(i, output_format_, size.width());
+    int rows_per_copy =
+        std::max<size_t>((kBytesPerCopyTarget / bytes_per_row) & ~1, 1);
 
-  // Post all the async tasks.
-  for (size_t i = 0; i < num_planes; i += planes_per_copy) {
-    gfx::GpuMemoryBuffer* buffer =
-        frame_resources->plane_resources[i].gpu_memory_buffer.get();
-    DCHECK(buffer);
-    DCHECK_EQ(planes_per_copy,
-              gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
-    uint8* dest_buffers[VideoFrame::kMaxPlanes];
-    int dest_strides[VideoFrame::kMaxPlanes];
-    bool rv = buffer->Map(reinterpret_cast<void**>(dest_buffers));
+    void* data = nullptr;
+    DCHECK_EQ(1u, gfx::NumberOfPlanesForBufferFormat(
+                      GpuMemoryBufferFormat(output_format_, i)));
+    bool rv = frame_resources->plane_resources[i].gpu_memory_buffer->Map(&data);
     DCHECK(rv);
-    buffer->GetStride(dest_strides);
+    uint8* mapped_buffer = static_cast<uint8*>(data);
 
-    const int rows = VideoFrame::Rows(i, output_format_, size.height());
-    const int rows_per_copy = RowsPerCopy(i, output_format_, size.width());
+    int dest_stride = 0;
+    frame_resources->plane_resources[i].gpu_memory_buffer->GetStride(
+        &dest_stride);
 
     for (int row = 0; row < rows; row += rows_per_copy) {
-      const int rows_to_copy = std::min(rows_per_copy, rows - row);
       switch (output_format_) {
-        case PIXEL_FORMAT_I420: {
-          const int bytes_per_row =
-              VideoFrame::RowBytes(i, output_format_, size.width());
+        case PIXEL_FORMAT_I420:
           worker_task_runner_->PostTask(
               FROM_HERE,
-              base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
-                         bytes_per_row, video_frame->data(i),
-                         video_frame->stride(i), dest_buffers[0],
-                         dest_strides[0], barrier));
-          break;
-        }
-        case PIXEL_FORMAT_NV12:
-          worker_task_runner_->PostTask(
-              FROM_HERE,
-              base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy,
-                         size.width(), video_frame, dest_buffers[0],
-                         dest_strides[0], dest_buffers[1], dest_strides[1],
-                         barrier));
+              base::Bind(&CopyRowsToI420Buffer, row,
+                         std::min(rows_per_copy, rows - row), bytes_per_row,
+                         video_frame->data(i), video_frame->stride(i),
+                         mapped_buffer, dest_stride, barrier));
           break;
         case PIXEL_FORMAT_UYVY:
           worker_task_runner_->PostTask(
               FROM_HERE,
-              base::Bind(&CopyRowsToUYVYBuffer, row, rows_to_copy, size.width(),
-                         video_frame, dest_buffers[0], dest_strides[0],
-                         barrier));
+              base::Bind(&CopyRowsToUYVYBuffer, row,
+                         std::min(rows_per_copy, rows - row), size.width(),
+                         video_frame, mapped_buffer, dest_stride, barrier));
           break;
         default:
           NOTREACHED();
       }
     }
   }
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::
     BindAndCreateMailboxesHardwareFrameResources(
         const scoped_refptr<VideoFrame>& video_frame,
         FrameResources* frame_resources,
         const FrameReadyCB& frame_ready_cb) {
   gpu::gles2::GLES2Interface* gles2 = gpu_factories_->GetGLES2Interface();
   if (!gles2) {
     frame_ready_cb.Run(video_frame);
     return;
   }
 
-  const size_t num_planes = VideoFrame::NumPlanes(output_format_);
-  const size_t planes_per_copy = PlanesPerCopy(output_format_);
+  const size_t planes = VideoFrame::NumPlanes(output_format_);
   const gfx::Size size = video_frame->visible_rect().size();
   gpu::MailboxHolder mailbox_holders[VideoFrame::kMaxPlanes];
   // Set up the planes creating the mailboxes needed to refer to the textures.
-  for (size_t i = 0; i < num_planes; i += planes_per_copy) {
+  for (size_t i = 0; i < planes; ++i) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
-    DCHECK(plane_resource.gpu_memory_buffer);
     // Bind the texture and create or rebind the image.
     gles2->BindTexture(texture_target_, plane_resource.texture_id);
 
-    if (!plane_resource.image_id) {
+    if (plane_resource.gpu_memory_buffer && !plane_resource.image_id) {
       const size_t width = VideoFrame::Columns(i, output_format_, size.width());
       const size_t height = VideoFrame::Rows(i, output_format_, size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
           ImageInternalFormat(output_format_, i));
     } else {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target_,
                                        plane_resource.image_id);
     }
     gles2->BindTexImage2DCHROMIUM(texture_target_, plane_resource.image_id);
     mailbox_holders[i] =
         gpu::MailboxHolder(plane_resource.mailbox, texture_target_, 0);
   }
 
   // Insert a sync_point, this is needed to make sure that the textures the
   // mailboxes refer to will be used only after all the previous commands posted
   // in the command buffer have been processed.
   unsigned sync_point = gles2->InsertSyncPointCHROMIUM();
-  for (size_t i = 0; i < num_planes; i += planes_per_copy)
+  for (size_t i = 0; i < planes; ++i) {
     mailbox_holders[i].sync_point = sync_point;
+  }
 
   scoped_refptr<VideoFrame> frame;
   // Create the VideoFrame backed by native textures.
   switch (output_format_) {
     case PIXEL_FORMAT_I420:
       frame = VideoFrame::WrapYUV420NativeTextures(
           mailbox_holders[VideoFrame::kYPlane],
           mailbox_holders[VideoFrame::kUPlane],
           mailbox_holders[VideoFrame::kVPlane],
           base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources),
           size, video_frame->visible_rect(), video_frame->natural_size(),
           video_frame->timestamp());
       if (video_frame->metadata()->IsTrue(VideoFrameMetadata::ALLOW_OVERLAY))
         frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
       break;
-    case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_UYVY:
       frame = VideoFrame::WrapNativeTexture(
-          output_format_, mailbox_holders[VideoFrame::kYPlane],
+          PIXEL_FORMAT_UYVY, mailbox_holders[VideoFrame::kYPlane],
           base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources),
           size, video_frame->visible_rect(), video_frame->natural_size(),
           video_frame->timestamp());
       frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY, true);
       break;
     default:
       NOTREACHED();
   }
   frame_ready_cb.Run(frame);
 }
@@ skipping 32 matching lines @@
     } else {
       it++;
     }
   }
 
   // Create the resources.
   gpu::gles2::GLES2Interface* gles2 = gpu_factories_->GetGLES2Interface();
   if (!gles2)
     return nullptr;
   gles2->ActiveTexture(GL_TEXTURE0);
-  size_t num_planes = VideoFrame::NumPlanes(format);
+  size_t planes = VideoFrame::NumPlanes(format);
   FrameResources* frame_resources = new FrameResources(size);
   resources_pool_.push_back(frame_resources);
-  for (size_t i = 0; i < num_planes; i += PlanesPerCopy(format)) {
+  for (size_t i = 0; i < planes; ++i) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
     const size_t width = VideoFrame::Columns(i, format, size.width());
     const size_t height = VideoFrame::Rows(i, format, size.height());
     const gfx::Size plane_size(width, height);
 
-    const gfx::BufferFormat buffer_format = GpuMemoryBufferFormat(format, i);
     plane_resource.gpu_memory_buffer = gpu_factories_->AllocateGpuMemoryBuffer(
-        plane_size, buffer_format, gfx::BufferUsage::MAP);
+        plane_size, GpuMemoryBufferFormat(format, i), gfx::BufferUsage::MAP);
 
     gles2->GenTextures(1, &plane_resource.texture_id);
     gles2->BindTexture(texture_target_, plane_resource.texture_id);
     gles2->TexParameteri(texture_target_, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gles2->TexParameteri(texture_target_, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     gles2->TexParameteri(texture_target_, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gles2->TexParameteri(texture_target_, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     gles2->GenMailboxCHROMIUM(plane_resource.mailbox.name);
     gles2->ProduceTextureCHROMIUM(texture_target_, plane_resource.mailbox.name);
   }
@@ skipping 56 matching lines @@
 }
 
 void GpuMemoryBufferVideoFramePool::MaybeCreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(video_frame);
   pool_impl_->CreateHardwareFrame(video_frame, frame_ready_cb);
 }
 
 }  // namespace media