16 bit capture and GPU&CPU memory buffer support.

content/renderer/media/video_capture_impl.cc

 // Copyright (c) 2012 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.
 //
 // Notes about usage of this object by VideoCaptureImplManager.
 //
 // VideoCaptureImplManager access this object by using a Unretained()
 // binding and tasks on the IO thread. It is then important that
 // VideoCaptureImpl never post task to itself. All operations must be
 // synchronous.
@@ skipping 35 matching lines @@
   const size_t buffer_size_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientBuffer);
 };
 
 // A holder of a GpuMemoryBuffer-backed buffer, Map()ed on ctor and Unmap()ed on
 // dtor. Creates and owns GpuMemoryBuffer instances.
 class VideoCaptureImpl::ClientBuffer2
     : public base::RefCountedThreadSafe<ClientBuffer2> {
  public:
-  ClientBuffer2(
-      const std::vector<gfx::GpuMemoryBufferHandle>& client_handles,
-      const gfx::Size& size)
-      : handles_(client_handles),
-        size_(size) {
-    const media::VideoPixelFormat format = media::PIXEL_FORMAT_I420;
+  ClientBuffer2(const std::vector<gfx::GpuMemoryBufferHandle>& client_handles,
+                const gfx::Size& size,
+                media::VideoPixelFormat format)
+      : handles_(client_handles) {
+    DCHECK(format == media::PIXEL_FORMAT_I420 ||
+           format == media::PIXEL_FORMAT_Y16);
     DCHECK_EQ(handles_.size(), media::VideoFrame::NumPlanes(format));
     for (size_t i = 0; i < handles_.size(); ++i) {
-      const size_t width = media::VideoFrame::Columns(i, format, size_.width());
-      const size_t height = media::VideoFrame::Rows(i, format, size_.height());
+      const size_t width = media::VideoFrame::Columns(i, format, size.width());
+      const size_t height = media::VideoFrame::Rows(i, format, size.height());
       buffers_.push_back(gpu::GpuMemoryBufferImpl::CreateFromHandle(
-          handles_[i], gfx::Size(width, height), gfx::BufferFormat::R_8,
+          handles_[i], gfx::Size(width, height),
+          media::VideoFrame::BufferFormat(format),
           gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
           base::Bind(&ClientBuffer2::DestroyGpuMemoryBuffer,
                      base::Unretained(this))));
       bool rv = buffers_[i]->Map();
       DCHECK(rv);
       data_[i] = reinterpret_cast<uint8_t*>(buffers_[i]->memory(0u));
       strides_[i] = width;
     }
   }
 
   uint8_t* data(int plane) const { return data_[plane]; }
   int32_t stride(int plane) const { return strides_[plane]; }
   std::vector<gfx::GpuMemoryBufferHandle> gpu_memory_buffer_handles() {
     return handles_;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ClientBuffer2>;
 
   virtual ~ClientBuffer2() {
     for (auto* buffer : buffers_)
       buffer->Unmap();
   }
 
   void DestroyGpuMemoryBuffer(const gpu::SyncToken& sync_token) {}
 
   const std::vector<gfx::GpuMemoryBufferHandle> handles_;
-  const gfx::Size size_;
   ScopedVector<gfx::GpuMemoryBuffer> buffers_;
   uint8_t* data_[media::VideoFrame::kMaxPlanes];
   int32_t strides_[media::VideoFrame::kMaxPlanes];
 
   DISALLOW_COPY_AND_ASSIGN(ClientBuffer2);
 };
 
 VideoCaptureImpl::ClientInfo::ClientInfo() {}
 VideoCaptureImpl::ClientInfo::ClientInfo(const ClientInfo& other) = default;
 VideoCaptureImpl::ClientInfo::~ClientInfo() {}
@@ skipping 146 matching lines @@
       client_buffers_.insert(std::make_pair(
                                  buffer_id,
                                  new ClientBuffer(std::move(shm), length)))
           .second;
   DCHECK(inserted);
 }
 
 void VideoCaptureImpl::OnBufferCreated2(
     const std::vector<gfx::GpuMemoryBufferHandle>& handles,
     const gfx::Size& size,
+    media::VideoPixelFormat format,
     int buffer_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   // In case client calls StopCapture before the arrival of created buffer,
   // just close this buffer and return.
   if (state_ != VIDEO_CAPTURE_STATE_STARTED)
     return;
 
   const bool inserted =
-      client_buffer2s_.insert(std::make_pair(buffer_id,
-                                             new ClientBuffer2(handles, size)))
+      client_buffer2s_
+          .insert(std::make_pair(buffer_id,
+                                 new ClientBuffer2(handles, size, format)))
           .second;
   DCHECK(inserted);
 }
 
 void VideoCaptureImpl::OnBufferDestroyed(int buffer_id) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
 
   const auto& cb_iter = client_buffers_.find(buffer_id);
   if (cb_iter != client_buffers_.end()) {
     DCHECK(!cb_iter->second.get() || cb_iter->second->HasOneRef())
@@ skipping 12 matching lines @@
 void VideoCaptureImpl::OnBufferReceived(
     int buffer_id,
     base::TimeDelta timestamp,
     const base::DictionaryValue& metadata,
     media::VideoPixelFormat pixel_format,
     media::VideoFrame::StorageType storage_type,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect) {
   DCHECK(io_task_runner_->BelongsToCurrentThread());
   if (state_ != VIDEO_CAPTURE_STATE_STARTED || suspended_ ||
-      pixel_format != media::PIXEL_FORMAT_I420 ||
+      (pixel_format != media::PIXEL_FORMAT_I420 &&
+       pixel_format != media::PIXEL_FORMAT_Y16) ||
       (storage_type != media::VideoFrame::STORAGE_SHMEM &&
        storage_type != media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS)) {
     // Crash in debug builds since the host should not have provided a buffer
     // with an unsupported pixel format or storage type.
-    DCHECK_EQ(media::PIXEL_FORMAT_I420, pixel_format);
+    DCHECK(media::PIXEL_FORMAT_I420 == pixel_format ||
+           media::PIXEL_FORMAT_Y16 == pixel_format);
     DCHECK(storage_type == media::VideoFrame::STORAGE_SHMEM ||
            storage_type == media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS);
     Send(new VideoCaptureHostMsg_BufferReady(device_id_, buffer_id,
                                              gpu::SyncToken(), -1.0));
     return;
   }
 
   base::TimeTicks reference_time;
   media::VideoFrameMetadata frame_metadata;
   frame_metadata.MergeInternalValuesFrom(metadata);
@@ skipping 21 matching lines @@
 
   scoped_refptr<media::VideoFrame> frame;
   BufferFinishedCallback buffer_finished_callback;
   std::unique_ptr<gpu::SyncToken> release_sync_token(new gpu::SyncToken);
   switch (storage_type) {
     case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {
       const auto& iter = client_buffer2s_.find(buffer_id);
       DCHECK(iter != client_buffer2s_.end());
       scoped_refptr<ClientBuffer2> buffer = iter->second;
       const auto& handles = buffer->gpu_memory_buffer_handles();
-      frame = media::VideoFrame::WrapExternalYuvGpuMemoryBuffers(
-          media::PIXEL_FORMAT_I420, coded_size, gfx::Rect(coded_size),
-          coded_size, buffer->stride(media::VideoFrame::kYPlane),
-          buffer->stride(media::VideoFrame::kUPlane),
-          buffer->stride(media::VideoFrame::kVPlane),
-          buffer->data(media::VideoFrame::kYPlane),
-          buffer->data(media::VideoFrame::kUPlane),
-          buffer->data(media::VideoFrame::kVPlane),
-          handles[media::VideoFrame::kYPlane],
-          handles[media::VideoFrame::kUPlane],
-          handles[media::VideoFrame::kVPlane], timestamp);
+      frame =
+          (pixel_format == media::PIXEL_FORMAT_I420)
+              ? media::VideoFrame::WrapExternalYuvGpuMemoryBuffers(
+                    media::PIXEL_FORMAT_I420, coded_size, gfx::Rect(coded_size),
+                    coded_size, buffer->stride(media::VideoFrame::kYPlane),
+                    buffer->stride(media::VideoFrame::kUPlane),
+                    buffer->stride(media::VideoFrame::kVPlane),
+                    buffer->data(media::VideoFrame::kYPlane),
+                    buffer->data(media::VideoFrame::kUPlane),
+                    buffer->data(media::VideoFrame::kVPlane),
+                    handles[media::VideoFrame::kYPlane],
+                    handles[media::VideoFrame::kUPlane],
+                    handles[media::VideoFrame::kVPlane], timestamp)
+              : media::VideoFrame::WrapExternalGpuMemoryBuffer(
+                    pixel_format, coded_size, gfx::Rect(coded_size), coded_size,
+                    buffer->data(0), handles[0], timestamp);
       buffer_finished_callback = media::BindToCurrentLoop(
           base::Bind(&VideoCaptureImpl::OnClientBufferFinished2,
                      weak_factory_.GetWeakPtr(), buffer_id, buffer));
       break;
     }
     case media::VideoFrame::STORAGE_SHMEM: {
       const auto& iter = client_buffers_.find(buffer_id);
       DCHECK(iter != client_buffers_.end());
       const scoped_refptr<ClientBuffer> buffer = iter->second;
       frame = media::VideoFrame::WrapExternalSharedMemory(
@@ skipping 189 matching lines @@
   double consumer_resource_utilization = -1.0;
   if (!metadata->GetDouble(media::VideoFrameMetadata::RESOURCE_UTILIZATION,
                            &consumer_resource_utilization)) {
     consumer_resource_utilization = -1.0;
   }
 
   callback_to_io_thread.Run(*release_sync_token, consumer_resource_utilization);
 }
 
 }  // namespace content