16 bit capture and GPU&CPU memory buffer support.

content/browser/renderer_host/media/video_capture_controller.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.
 
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
@@ skipping 200 matching lines @@
     const media::VideoCaptureParams& params) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "VideoCaptureController::AddClient() -- id=" << id
            << ", session_id=" << session_id
            << ", params.requested_format="
            << media::VideoCaptureFormat::ToString(params.requested_format);
 
   // Check that requested VideoCaptureParams are valid and supported.  If not,
   // report an error immediately and punt.
   if (!params.IsValid() ||
-      params.requested_format.pixel_format != media::PIXEL_FORMAT_I420 ||
+      !(params.requested_format.pixel_format == media::PIXEL_FORMAT_I420 ||
+        params.requested_format.pixel_format == media::PIXEL_FORMAT_Y16) ||
       (params.requested_format.pixel_storage != media::PIXEL_STORAGE_CPU &&
        params.requested_format.pixel_storage !=
            media::PIXEL_STORAGE_GPUMEMORYBUFFER)) {
     // Crash in debug builds since the renderer should not have asked for
     // invalid or unsupported parameters.
     LOG(DFATAL) << "Invalid or unsupported video capture parameters requested: "
                 << media::VideoCaptureFormat::ToString(params.requested_format);
     event_handler->OnError(id);
     return;
   }
@@ skipping 184 matching lines @@
   int count = 0;
   if (state_ == VIDEO_CAPTURE_STATE_STARTED) {
     if (!frame->metadata()->HasKey(VideoFrameMetadata::FRAME_RATE)) {
       frame->metadata()->SetDouble(VideoFrameMetadata::FRAME_RATE,
                                    video_capture_format_.frame_rate);
     }
     std::unique_ptr<base::DictionaryValue> metadata(
         new base::DictionaryValue());
     frame->metadata()->MergeInternalValuesInto(metadata.get());
 
-    // Only I420 pixel format is currently supported.
-    DCHECK_EQ(frame->format(), media::PIXEL_FORMAT_I420)
+    // Only I420 and Y16 pixel formats are currently supported.
+    DCHECK(frame->format() == media::PIXEL_FORMAT_I420 ||
+           frame->format() == media::PIXEL_FORMAT_Y16)
         << "Unsupported pixel format: "
         << media::VideoPixelFormatToString(frame->format());
 
     // Sanity-checks to confirm |frame| is actually being backed by |buffer|.
     DCHECK(frame->storage_type() == media::VideoFrame::STORAGE_SHMEM ||
            (frame->storage_type() ==
                 media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS));
     DCHECK(frame->data(media::VideoFrame::kYPlane) >= buffer->data(0) &&
            (frame->data(media::VideoFrame::kYPlane) <
             (reinterpret_cast<const uint8_t*>(buffer->data(0)) +
@@ skipping 80 matching lines @@
     case media::VideoFrame::STORAGE_GPU_MEMORY_BUFFERS: {
       std::vector<gfx::GpuMemoryBufferHandle> handles;
       const size_t num_planes = media::VideoFrame::NumPlanes(frame->format());
       for (size_t i = 0; i < num_planes; ++i) {
         gfx::GpuMemoryBufferHandle remote_handle;
         buffer_pool_->ShareToProcess2(
             buffer_id, i, client->render_process_handle, &remote_handle);
         handles.push_back(remote_handle);
       }
       client->event_handler->OnBufferCreated2(client->controller_id, handles,
-                                              buffer->dimensions(), buffer_id);
+                                              buffer->dimensions(),
+                                              frame->format(), buffer_id);
       break;
     }
     case media::VideoFrame::STORAGE_SHMEM: {
       base::SharedMemoryHandle remote_handle;
       buffer_pool_->ShareToProcess(buffer_id, client->render_process_handle,
                                    &remote_handle);
       client->event_handler->OnBufferCreated(
           client->controller_id, remote_handle, buffer->mapped_size(),
           buffer_id);
       break;
@@ skipping 19 matching lines @@
     int session_id,
     const ControllerClients& clients) {
   for (const auto& client : clients) {
     if (client->session_id == session_id)
       return client.get();
   }
   return nullptr;
 }
 
 }  // namespace content