16 bit capture and GPU&CPU memory buffer support.

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 <stddef.h>
 #include <stdint.h>
@@ skipping 68 matching lines @@
   struct PlaneResource {
     gfx::Size size;
     std::unique_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer;
     unsigned texture_id = 0u;
     unsigned image_id = 0u;
     gpu::Mailbox mailbox;
   };
 
   // All the resources needed to compose a frame.
   struct FrameResources {
-    explicit FrameResources(const gfx::Size& size) : size(size) {}
+    explicit FrameResources(const gfx::Size& size, VideoPixelFormat format)
+        : size(size), format(format) {}
     void SetIsInUse(bool in_use) { in_use_ = in_use; }
     bool IsInUse() const { return in_use_; }
 
     const gfx::Size size;
+    VideoPixelFormat format;
     PlaneResource plane_resources[VideoFrame::kMaxPlanes];
 
    private:
     bool in_use_ = true;
   };
 
   // Copy |video_frame| data into |frame_resouces|
   // and calls |done| when done.
   void CopyVideoFrameToGpuMemoryBuffers(
       const scoped_refptr<VideoFrame>& video_frame,
@@ skipping 10 matching lines @@
   // This has to be run on |media_task_runner_| where |frame_ready_cb| will also
   // be run.
   void BindAndCreateMailboxesHardwareFrameResources(
       const scoped_refptr<VideoFrame>& video_frame,
       FrameResources* frame_resources,
       const FrameReadyCB& frame_ready_cb);
 
   // Return true if |resources| can be used to represent a frame for
   // specific |format| and |size|.
   static bool AreFrameResourcesCompatible(const FrameResources* resources,
-                                          const gfx::Size& size) {
-    return size == resources->size;
+                                          const gfx::Size& size,
+                                          VideoPixelFormat format) {
+    return size == resources->size && format == resources->format;
   }
 
   // Get the resources needed for a frame out of the pool, or create them if
   // necessary.
   // This also drops the LRU resources that can't be reuse for this frame.
   FrameResources* GetOrCreateFrameResources(const gfx::Size& size,
                                             VideoPixelFormat format);
 
   // Callback called when a VideoFrame generated with GetFrameResources is no
   // longer referenced.
@@ skipping 12 matching lines @@
   scoped_refptr<base::TaskRunner> worker_task_runner_;
 
   // Interface to GPU related operations.
   GpuVideoAcceleratorFactories* gpu_factories_;
 
   // Pool of resources.
   std::list<FrameResources*> resources_pool_;
 
   // TODO(dcastagna): change the following type from VideoPixelFormat to
   // BufferFormat.
+  // Pixel format of the hardware video frames for I420 and YV12 video.
   VideoPixelFormat output_format_;
 
+  // If texture_rg is supported, gpu memory buffers can be used for R8 and RG8.
+  bool texture_rg_available_ = false;
+  bool texture_rg_available_initialized_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(PoolImpl);
 };
 
 namespace {
 
 // VideoFrame copies to GpuMemoryBuffers will be split in copies where the
 // 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_RED_EXT;
     case PIXEL_FORMAT_NV12:
       DCHECK_LE(plane, 1u);
       return GL_RGB_YCBCR_420V_CHROMIUM;
     case PIXEL_FORMAT_UYVY:
       DCHECK_EQ(0u, plane);
       return GL_RGB_YCBCR_422_CHROMIUM;
+    case PIXEL_FORMAT_Y16:
+      DCHECK_EQ(0u, plane);
+      return GL_RG_EXT;
     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:
+    case PIXEL_FORMAT_Y16:
       return 1;
     case PIXEL_FORMAT_NV12:
       return 2;
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 // The number of output rows to be copied in each iteration.
@@ skipping 85 matching lines @@
             first_row / 2 * source_frame->stride(VideoFrame::kUPlane),
         source_frame->stride(VideoFrame::kUPlane),
         source_frame->visible_data(VideoFrame::kVPlane) +
             first_row / 2 * source_frame->stride(VideoFrame::kVPlane),
         source_frame->stride(VideoFrame::kVPlane),
         output + first_row * dest_stride, dest_stride, width, rows);
   }
   done.Run();
 }
 
+void CopyRowsToGPUBuffer(int first_row,
+                         int rows,
+                         int width,
+                         const scoped_refptr<VideoFrame>& source_frame,
+                         uint8_t* output,
+                         int dest_stride,
+                         const base::Closure& done) {
+  int row_bytes = VideoFrame::RowBytes(0, source_frame->format(), width);
+  TRACE_EVENT2("media", "CopyRowsToGPUBuffer", "bytes_per_row", row_bytes,
+               "rows", rows);
+  if (output) {
+    DCHECK_NE(dest_stride, 0);
+    DCHECK_LE(row_bytes, std::abs(dest_stride));
+    const int source_stride = source_frame->stride(0);
+    const uint8_t* source =
+        source_frame->visible_data(0) + first_row * source_stride;
+    uint8_t* dest = output + first_row * dest_stride;
+    for (int i = 0; i < rows; ++i)
+      memcpy(dest + i * dest_stride, source + i * source_stride, row_bytes);
+  }
+  done.Run();
+}
+
 gfx::Size CodedSize(const scoped_refptr<VideoFrame>& video_frame,
                     VideoPixelFormat output_format) {
   DCHECK(gfx::Rect(video_frame->coded_size())
              .Contains(video_frame->visible_rect()));
   DCHECK((video_frame->visible_rect().x() & 1) == 0);
   gfx::Size output;
   switch (output_format) {
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_NV12:
       DCHECK((video_frame->visible_rect().y() & 1) == 0);
       output = gfx::Size((video_frame->visible_rect().width() + 1) & ~1,
                          (video_frame->visible_rect().height() + 1) & ~1);
       break;
     case PIXEL_FORMAT_UYVY:
       output = gfx::Size((video_frame->visible_rect().width() + 1) & ~1,
                          video_frame->visible_rect().height());
       break;
+    case PIXEL_FORMAT_Y16:
+      output = video_frame->visible_rect().size();
+      break;
     default:
       NOTREACHED();
   }
   DCHECK(gfx::Rect(video_frame->coded_size()).Contains(gfx::Rect(output)));
   return output;
 }
 }  // unnamed namespace
 
 // Creates a VideoFrame backed by native textures starting from a software
 // VideoFrame.
 // The data contained in |video_frame| is copied into the VideoFrame passed to
 // |frame_ready_cb|.
 // This has to be called on the thread where |media_task_runner_| is current.
 void GpuMemoryBufferVideoFramePool::PoolImpl::CreateHardwareFrame(
     const scoped_refptr<VideoFrame>& video_frame,
     const FrameReadyCB& frame_ready_cb) {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
-  // Lazily initialize output_format_ since VideoFrameOutputFormat() has to be
-  // called on the media_thread while this object might be instantiated on any.
-  if (output_format_ == PIXEL_FORMAT_UNKNOWN)
-    output_format_ = gpu_factories_->VideoFrameOutputFormat();
-
-  if (output_format_ == PIXEL_FORMAT_UNKNOWN) {
-    frame_ready_cb.Run(video_frame);
-    return;
-  }
+  media::VideoPixelFormat output_format = PIXEL_FORMAT_UNKNOWN;
   switch (video_frame->format()) {
     // Supported cases.
     case PIXEL_FORMAT_YV12:
-    case PIXEL_FORMAT_I420:
+    case PIXEL_FORMAT_I420: {
+      // Lazily initialize output_format_ since VideoFrameOutputFormat() has to
+      // be called on the media_thread while this object might be instantiated
+      // on any.
+      if (output_format_ == PIXEL_FORMAT_UNKNOWN) {
+        output_format_ =
+            gpu_factories_->VideoFrameOutputFormat(PIXEL_FORMAT_I420);
+      }
+      output_format = output_format_;
+      break;
+    }
+    case PIXEL_FORMAT_Y16:
+      // Lazily initialize texture_rg_available_.
+      if (!texture_rg_available_initialized_) {
+        texture_rg_available_initialized_ = true;
+        texture_rg_available_ = gpu_factories_->VideoFrameOutputFormat(
+                                    PIXEL_FORMAT_Y16) == PIXEL_FORMAT_Y16;
+      }
+      output_format =
+          texture_rg_available_ ? video_frame->format() : PIXEL_FORMAT_UNKNOWN;
       break;
     // Unsupported cases.
     case PIXEL_FORMAT_YV12A:
     case PIXEL_FORMAT_YV16:
     case PIXEL_FORMAT_YV24:
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_NV21:
     case PIXEL_FORMAT_UYVY:
     case PIXEL_FORMAT_YUY2:
     case PIXEL_FORMAT_ARGB:
     case PIXEL_FORMAT_XRGB:
     case PIXEL_FORMAT_RGB24:
     case PIXEL_FORMAT_RGB32:
     case PIXEL_FORMAT_MJPEG:
     case PIXEL_FORMAT_MT21:
     case PIXEL_FORMAT_YUV420P9:
     case PIXEL_FORMAT_YUV422P9:
     case PIXEL_FORMAT_YUV444P9:
     case PIXEL_FORMAT_YUV420P10:
     case PIXEL_FORMAT_YUV422P10:
     case PIXEL_FORMAT_YUV444P10:
     case PIXEL_FORMAT_YUV420P12:
     case PIXEL_FORMAT_YUV422P12:
     case PIXEL_FORMAT_YUV444P12:
     case PIXEL_FORMAT_Y8:
-    case PIXEL_FORMAT_Y16:
     case PIXEL_FORMAT_UNKNOWN:
-      frame_ready_cb.Run(video_frame);
-      return;
+      break;
+  }
+  if (output_format == PIXEL_FORMAT_UNKNOWN) {
+    frame_ready_cb.Run(video_frame);
+    return;
   }
 
-  const gfx::Size coded_size = CodedSize(video_frame, output_format_);
+  const gfx::Size coded_size = CodedSize(video_frame, output_format);
   // Acquire resources. Incompatible ones will be dropped from the pool.
   FrameResources* frame_resources =
-      GetOrCreateFrameResources(coded_size, output_format_);
+      GetOrCreateFrameResources(coded_size, output_format);
   if (!frame_resources) {
     frame_ready_cb.Run(video_frame);
     return;
   }
 
   worker_task_runner_->PostTask(
       FROM_HERE, base::Bind(&PoolImpl::CopyVideoFrameToGpuMemoryBuffers, this,
                             video_frame, frame_resources, frame_ready_cb));
 }
 
@@ skipping 52 matching lines @@
 }
 
 // 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 gfx::Size coded_size = CodedSize(video_frame, output_format_);
+  const size_t num_planes = VideoFrame::NumPlanes(frame_resources->format);
+  const size_t planes_per_copy = PlanesPerCopy(frame_resources->format);
+  const gfx::Size coded_size = CodedSize(video_frame, frame_resources->format);
   size_t copies = 0;
   for (size_t i = 0; i < num_planes; i += planes_per_copy) {
-    const int rows = VideoFrame::Rows(i, output_format_, coded_size.height());
+    const int rows =
+        VideoFrame::Rows(i, frame_resources->format, coded_size.height());
     const int rows_per_copy =
-        RowsPerCopy(i, output_format_, coded_size.width());
+        RowsPerCopy(i, frame_resources->format, coded_size.width());
     copies += rows / rows_per_copy;
     if (rows % rows_per_copy)
       ++copies;
   }
   const base::Closure copies_done =
       base::Bind(&PoolImpl::OnCopiesDone, this, video_frame, frame_resources,
                  frame_ready_cb);
   const base::Closure barrier = base::BarrierClosure(copies, copies_done);
 
   // 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();
 
     if (!buffer || !buffer->Map()) {
       DLOG(ERROR) << "Could not get or Map() buffer";
       return;
     }
     DCHECK_EQ(planes_per_copy,
               gfx::NumberOfPlanesForBufferFormat(buffer->GetFormat()));
 
-    const int rows = VideoFrame::Rows(i, output_format_, coded_size.height());
+    const int rows =
+        VideoFrame::Rows(i, frame_resources->format, coded_size.height());
     const int rows_per_copy =
-        RowsPerCopy(i, output_format_, coded_size.width());
+        RowsPerCopy(i, frame_resources->format, coded_size.width());
 
     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_) {
+      switch (frame_resources->format) {
         case PIXEL_FORMAT_I420: {
-          const int bytes_per_row =
-              VideoFrame::RowBytes(i, output_format_, coded_size.width());
+          const int bytes_per_row = VideoFrame::RowBytes(
+              i, frame_resources->format, coded_size.width());
           worker_task_runner_->PostTask(
               FROM_HERE, base::Bind(&CopyRowsToI420Buffer, row, rows_to_copy,
                                     bytes_per_row, video_frame->visible_data(i),
                                     video_frame->stride(i),
                                     static_cast<uint8_t*>(buffer->memory(0)),
                                     buffer->stride(0), barrier));
           break;
         }
         case PIXEL_FORMAT_NV12:
           worker_task_runner_->PostTask(
               FROM_HERE, base::Bind(&CopyRowsToNV12Buffer, row, rows_to_copy,
                                     coded_size.width(), video_frame,
                                     static_cast<uint8_t*>(buffer->memory(0)),
                                     buffer->stride(0),
                                     static_cast<uint8_t*>(buffer->memory(1)),
                                     buffer->stride(1), barrier));
           break;
         case PIXEL_FORMAT_UYVY:
           worker_task_runner_->PostTask(
               FROM_HERE, base::Bind(&CopyRowsToUYVYBuffer, row, rows_to_copy,
                                     coded_size.width(), video_frame,
                                     static_cast<uint8_t*>(buffer->memory(0)),
                                     buffer->stride(0), barrier));
           break;
+        case PIXEL_FORMAT_Y16:
+          worker_task_runner_->PostTask(
+              FROM_HERE, base::Bind(&CopyRowsToGPUBuffer, row, rows_to_copy,
+                                    coded_size.width(), video_frame,
+                                    static_cast<uint8_t*>(buffer->memory(0)),
+                                    buffer->stride(0), barrier));
+          break;
         default:
           NOTREACHED();
       }
     }
   }
 }
 
 void GpuMemoryBufferVideoFramePool::PoolImpl::
     BindAndCreateMailboxesHardwareFrameResources(
         const scoped_refptr<VideoFrame>& video_frame,
         FrameResources* frame_resources,
         const FrameReadyCB& frame_ready_cb) {
   std::unique_ptr<GpuVideoAcceleratorFactories::ScopedGLContextLock> lock(
       gpu_factories_->GetGLContextLock());
   if (!lock) {
     frame_ready_cb.Run(video_frame);
     return;
   }
   gpu::gles2::GLES2Interface* gles2 = lock->ContextGL();
 
-  const size_t num_planes = VideoFrame::NumPlanes(output_format_);
-  const size_t planes_per_copy = PlanesPerCopy(output_format_);
-  const gfx::Size coded_size = CodedSize(video_frame, output_format_);
+  const size_t num_planes = VideoFrame::NumPlanes(frame_resources->format);
+  const size_t planes_per_copy = PlanesPerCopy(frame_resources->format);
+  const gfx::Size coded_size = CodedSize(video_frame, frame_resources->format);
   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) {
     PlaneResource& plane_resource = frame_resources->plane_resources[i];
     const gfx::BufferFormat buffer_format =
-        GpuMemoryBufferFormat(output_format_, i);
+        VideoFrame::BufferFormat(frame_resources->format);
     unsigned texture_target = gpu_factories_->ImageTextureTarget(buffer_format);
     // Bind the texture and create or rebind the image.
     gles2->BindTexture(texture_target, plane_resource.texture_id);
 
     if (plane_resource.gpu_memory_buffer && !plane_resource.image_id) {
       const size_t width =
-          VideoFrame::Columns(i, output_format_, coded_size.width());
+          VideoFrame::Columns(i, frame_resources->format, coded_size.width());
       const size_t height =
-          VideoFrame::Rows(i, output_format_, coded_size.height());
+          VideoFrame::Rows(i, frame_resources->format, coded_size.height());
       plane_resource.image_id = gles2->CreateImageCHROMIUM(
           plane_resource.gpu_memory_buffer->AsClientBuffer(), width, height,
-          ImageInternalFormat(output_format_, i));
+          ImageInternalFormat(frame_resources->format, i));
     } else if (plane_resource.image_id) {
       gles2->ReleaseTexImage2DCHROMIUM(texture_target, plane_resource.image_id);
     }
     if (plane_resource.image_id)
       gles2->BindTexImage2DCHROMIUM(texture_target, plane_resource.image_id);
     mailbox_holders[i] = gpu::MailboxHolder(plane_resource.mailbox,
                                             gpu::SyncToken(), texture_target);
   }
 
   // Insert a sync_token, 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.
   const GLuint64 fence_sync = gles2->InsertFenceSyncCHROMIUM();
   gles2->OrderingBarrierCHROMIUM();
 
   gpu::SyncToken sync_token;
   gles2->GenUnverifiedSyncTokenCHROMIUM(fence_sync, sync_token.GetData());
   for (size_t i = 0; i < num_planes; i += planes_per_copy)
     mailbox_holders[i].sync_token = sync_token;
 
 
   auto release_mailbox_callback = BindToCurrentLoop(
       base::Bind(&PoolImpl::MailboxHoldersReleased, this, frame_resources));
 
   // Consumers should sample from NV12 textures as if they're XRGB.
-  VideoPixelFormat frame_format =
-      output_format_ == PIXEL_FORMAT_NV12 ? PIXEL_FORMAT_XRGB : output_format_;
+  VideoPixelFormat frame_format = (frame_resources->format == PIXEL_FORMAT_NV12)
+                                      ? PIXEL_FORMAT_XRGB
+                                      : frame_resources->format;
   DCHECK_EQ(VideoFrame::NumPlanes(frame_format) * planes_per_copy, num_planes);
 
   // Create the VideoFrame backed by native textures.
   gfx::Size visible_size = video_frame->visible_rect().size();
   scoped_refptr<VideoFrame> frame = VideoFrame::WrapNativeTextures(
       frame_format, mailbox_holders, release_mailbox_callback, coded_size,
       gfx::Rect(visible_size), video_frame->natural_size(),
       video_frame->timestamp());
 
   if (!frame) {
     release_mailbox_callback.Run(gpu::SyncToken());
     frame_ready_cb.Run(video_frame);
     return;
   }
 
   frame->set_color_space(video_frame->ColorSpace());
 
   bool allow_overlay = false;
-  switch (output_format_) {
+  switch (frame_resources->format) {
     case PIXEL_FORMAT_I420:
       allow_overlay =
           video_frame->metadata()->IsTrue(VideoFrameMetadata::ALLOW_OVERLAY);
       break;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_UYVY:
+    case PIXEL_FORMAT_Y16:
       allow_overlay = true;
       break;
     default:
       break;
   }
   frame->metadata()->SetBoolean(VideoFrameMetadata::ALLOW_OVERLAY,
                                 allow_overlay);
 
   base::TimeTicks render_time;
   if (video_frame->metadata()->GetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
@@ skipping 24 matching lines @@
 // Tries to find the resources in the pool or create them.
 // Incompatible resources will be dropped.
 GpuMemoryBufferVideoFramePool::PoolImpl::FrameResources*
 GpuMemoryBufferVideoFramePool::PoolImpl::GetOrCreateFrameResources(
     const gfx::Size& size,
     VideoPixelFormat format) {
   auto it = resources_pool_.begin();
   while (it != resources_pool_.end()) {
     FrameResources* frame_resources = *it;
     if (!frame_resources->IsInUse()) {
-      if (AreFrameResourcesCompatible(frame_resources, size)) {
+      if (AreFrameResourcesCompatible(frame_resources, size, format)) {
         frame_resources->SetIsInUse(true);
         return frame_resources;
       } else {
         resources_pool_.erase(it++);
         DeleteFrameResources(gpu_factories_, frame_resources);
         delete frame_resources;
       }
     } else {
       it++;
     }
   }
 
   // Create the resources.
   std::unique_ptr<GpuVideoAcceleratorFactories::ScopedGLContextLock> lock(
       gpu_factories_->GetGLContextLock());
   if (!lock)
     return nullptr;
 
   gpu::gles2::GLES2Interface* gles2 = lock->ContextGL();
   gles2->ActiveTexture(GL_TEXTURE0);
   size_t num_planes = VideoFrame::NumPlanes(format);
-  FrameResources* frame_resources = new FrameResources(size);
+  FrameResources* frame_resources = new FrameResources(size, format);
   resources_pool_.push_back(frame_resources);
   for (size_t i = 0; i < num_planes; i += PlanesPerCopy(format)) {
     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());
     plane_resource.size = gfx::Size(width, height);
 
-    const gfx::BufferFormat buffer_format = GpuMemoryBufferFormat(format, i);
+    const gfx::BufferFormat buffer_format = VideoFrame::BufferFormat(format);
     plane_resource.gpu_memory_buffer = gpu_factories_->AllocateGpuMemoryBuffer(
         plane_resource.size, buffer_format,
         gfx::BufferUsage::GPU_READ_CPU_READ_WRITE);
 
     unsigned texture_target = gpu_factories_->ImageTextureTarget(buffer_format);
     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);
+    if (format == PIXEL_FORMAT_Y16) {
+      gles2->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      gles2->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+    } else {
+      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);
   }
   return frame_resources;
 }
 
 // static
 void GpuMemoryBufferVideoFramePool::PoolImpl::DeleteFrameResources(
@@ skipping 51 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