16 bpp video stream capture, render and WebGL usage - Realsense R200 & SR300 support.

media/base/video_frame.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 "media/base/video_frame.h"
 
 #include <algorithm>
 #include <climits>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 107 matching lines @@
       natural_size.width() > limits::kMaxDimension ||
       natural_size.height() > limits::kMaxDimension)
     return false;
 
   // TODO(mcasas): Remove parameter |storage_type| when the opaque storage types
   // comply with the checks below. Right now we skip them.
   if (!IsStorageTypeMappable(storage_type))
     return true;
 
   // Make sure new formats are properly accounted for in the method.
-  static_assert(PIXEL_FORMAT_MAX == 21,
+  static_assert(PIXEL_FORMAT_MAX == 23,
                 "Added pixel format, please review IsValidConfig()");
 
   if (format == PIXEL_FORMAT_UNKNOWN) {
     return coded_size.IsEmpty() && visible_rect.IsEmpty() &&
            natural_size.IsEmpty();
   }
 
   // Check that software-allocated buffer formats are not empty.
   return !coded_size.IsEmpty() && !visible_rect.IsEmpty() &&
          !natural_size.IsEmpty();
@@ skipping 24 matching lines @@
 scoped_refptr<VideoFrame> VideoFrame::WrapNativeTextures(
     VideoPixelFormat format,
     const gpu::MailboxHolder (&mailbox_holders)[kMaxPlanes],
     const ReleaseMailboxCB& mailbox_holder_release_cb,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     base::TimeDelta timestamp) {
   if (format != PIXEL_FORMAT_ARGB && format != PIXEL_FORMAT_XRGB &&
       format != PIXEL_FORMAT_UYVY && format != PIXEL_FORMAT_NV12 &&
-      format != PIXEL_FORMAT_I420) {
+      format != PIXEL_FORMAT_I420 && format != PIXEL_FORMAT_Y8 &&
+      format != PIXEL_FORMAT_Y16) {
     LOG(DFATAL) << "Unsupported pixel format supported, got "
                 << VideoPixelFormatToString(format);
     return nullptr;
   }
   const StorageType storage = STORAGE_OPAQUE;
   if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
     LOG(DFATAL) << __func__ << " Invalid config."
                 << ConfigToString(format, storage, coded_size, visible_rect,
                                   natural_size);
     return nullptr;
@@ skipping 27 matching lines @@
     size_t data_size,
     base::SharedMemoryHandle handle,
     size_t data_offset,
     base::TimeDelta timestamp) {
   return WrapExternalStorage(format, STORAGE_SHMEM, coded_size, visible_rect,
                              natural_size, data, data_size, timestamp, handle,
                              data_offset);
 }
 
 // static
+scoped_refptr<VideoFrame> VideoFrame::WrapExternalGpuMemoryBuffer(
+    VideoPixelFormat format,
+    const gfx::Size& coded_size,
+    const gfx::Rect& visible_rect,
+    const gfx::Size& natural_size,
+    uint8_t* data,
+    const gfx::GpuMemoryBufferHandle& handle,
+    base::TimeDelta timestamp) {
+  const StorageType storage = STORAGE_GPU_MEMORY_BUFFERS;
+  if (!IsValidConfig(format, storage, coded_size, visible_rect, natural_size)) {
+    LOG(DFATAL) << __func__ << " Invalid config."
+                << ConfigToString(format, storage, coded_size, visible_rect,
+                                  natural_size);
+    return nullptr;
+  }
+
+  scoped_refptr<VideoFrame> frame(new VideoFrame(
+      format, storage, coded_size, visible_rect, natural_size, timestamp));
+  frame->strides_[0] = coded_size.width() * BytesPerElement(format, 0);
+  frame->data_[0] = data;
+  frame->gpu_memory_buffer_handles_.push_back(handle);
+  return frame;
+}
+
+// static
 scoped_refptr<VideoFrame> VideoFrame::WrapExternalYuvData(
     VideoPixelFormat format,
     const gfx::Size& coded_size,
     const gfx::Rect& visible_rect,
     const gfx::Size& natural_size,
     int32_t y_stride,
     int32_t u_stride,
     int32_t v_stride,
     uint8_t* y_data,
     uint8_t* u_data,
@@ skipping 297 matching lines @@
 // static
 size_t VideoFrame::NumPlanes(VideoPixelFormat format) {
   switch (format) {
     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_Y8:
+    case PIXEL_FORMAT_Y16:
       return 1;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_NV21:
     case PIXEL_FORMAT_MT21:
       return 2;
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_YV12:
     case PIXEL_FORMAT_YV16:
     case PIXEL_FORMAT_YV24:
     case PIXEL_FORMAT_YUV420P9:
@@ skipping 89 matching lines @@
     for (int row = 0; row < frame->rows(plane); ++row) {
       base::MD5Update(
           context,
           base::StringPiece(reinterpret_cast<char*>(frame->data(plane) +
                                                     frame->stride(plane) * row),
                             frame->row_bytes(plane)));
     }
   }
 }
 
+// static
+gfx::BufferFormat VideoFrame::BufferFormat(VideoPixelFormat format) {
+  switch (format) {
+    case PIXEL_FORMAT_I420:
+    case PIXEL_FORMAT_Y8:
+      return gfx::BufferFormat::R_8;
+    case PIXEL_FORMAT_NV12:
+      return gfx::BufferFormat::YUV_420_BIPLANAR;
+    case PIXEL_FORMAT_UYVY:
+      return gfx::BufferFormat::UYVY_422;
+    case PIXEL_FORMAT_Y16:
+      return gfx::BufferFormat::RG_88;
+    default:
+      NOTREACHED();
+      return gfx::BufferFormat::BGRA_8888;
+  }
+}
+
 bool VideoFrame::IsMappable() const {
   return IsStorageTypeMappable(storage_type_);
 }
 
 bool VideoFrame::HasTextures() const {
   return !mailbox_holders_[0].mailbox.IsZero();
 }
 
 gfx::ColorSpace VideoFrame::ColorSpace() const {
   if (color_space_ == gfx::ColorSpace()) {
@@ skipping 175 matching lines @@
     const gfx::Size& natural_size,
     uint8_t* data,
     size_t data_size,
     base::TimeDelta timestamp,
     base::SharedMemoryHandle handle,
     size_t data_offset) {
   DCHECK(IsStorageTypeMappable(storage_type));
 
   // TODO(miu): This function should support any pixel format.
   // http://crbug.com/555909
-  if (format != PIXEL_FORMAT_I420) {
-    LOG(DFATAL) << "Only PIXEL_FORMAT_I420 format supported: "
+  if (format != PIXEL_FORMAT_I420 && format != PIXEL_FORMAT_Y8 &&
+      format != PIXEL_FORMAT_Y16) {
+    LOG(DFATAL) << "Only PIXEL_FORMAT_I420, PIXEL_FORMAT_Y8 and "
+                   "PIXEL_FORMAT_Y16 formats are supported: "
                 << VideoPixelFormatToString(format);
     return nullptr;
   }
 
   if (!IsValidConfig(format, storage_type, coded_size, visible_rect,
                      natural_size)) {
     LOG(DFATAL) << __func__ << " Invalid config."
                 << ConfigToString(format, storage_type, coded_size,
                                   visible_rect, natural_size);
     return nullptr;
   }
 
   scoped_refptr<VideoFrame> frame;
   if (storage_type == STORAGE_SHMEM) {
     frame = new VideoFrame(format, storage_type, coded_size, visible_rect,
                            natural_size, timestamp, handle, data_offset);
   } else {
     frame = new VideoFrame(format, storage_type, coded_size, visible_rect,
                            natural_size, timestamp);
   }
+  if (format == PIXEL_FORMAT_Y8 || format == PIXEL_FORMAT_Y16) {
+    // TODO(astojilj) Make this code generic for all and move format specifics
+    // to static methods.
+    DCHECK_EQ(NumPlanes(format), 1U);
+    const size_t i = 0;
+    frame->strides_[i] = coded_size.width() * BytesPerElement(format, i);
+    frame->data_[i] = data;
+    return frame;
+  }
   frame->strides_[kYPlane] = coded_size.width();
   // TODO(miu): This always rounds widths down, whereas VideoFrame::RowBytes()
   // always rounds up.  This inconsistency must be resolved.  Perhaps a
   // CommonAlignment() check should be made in IsValidConfig()?
   // http://crbug.com/555909
   frame->strides_[kUPlane] = coded_size.width() / 2;
   frame->strides_[kVPlane] = coded_size.width() / 2;
   frame->data_[kYPlane] = data;
   frame->data_[kUPlane] = data + coded_size.GetArea();
   frame->data_[kVPlane] = data + (coded_size.GetArea() * 5 / 4);
@@ skipping 159 matching lines @@
     case kYPlane:
     case kAPlane:
       return gfx::Size(1, 1);
 
     case kUPlane:  // and kUVPlane:
     case kVPlane:
       switch (format) {
         case PIXEL_FORMAT_YV24:
         case PIXEL_FORMAT_YUV444P9:
         case PIXEL_FORMAT_YUV444P10:
+        case PIXEL_FORMAT_Y8:
+        case PIXEL_FORMAT_Y16:
           return gfx::Size(1, 1);
 
         case PIXEL_FORMAT_YV16:
         case PIXEL_FORMAT_YUV422P9:
         case PIXEL_FORMAT_YUV422P10:
           return gfx::Size(2, 1);
 
         case PIXEL_FORMAT_YV12:
         case PIXEL_FORMAT_I420:
         case PIXEL_FORMAT_YV12A:
@@ skipping 30 matching lines @@
     case PIXEL_FORMAT_RGB24:
       return 3;
     case PIXEL_FORMAT_UYVY:
     case PIXEL_FORMAT_YUY2:
     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_Y16:
       return 2;
     case PIXEL_FORMAT_NV12:
     case PIXEL_FORMAT_NV21:
     case PIXEL_FORMAT_MT21: {
       static const int bytes_per_element[] = {1, 2};
       DCHECK_LT(plane, arraysize(bytes_per_element));
       return bytes_per_element[plane];
     }
     case PIXEL_FORMAT_YV12:
     case PIXEL_FORMAT_I420:
     case PIXEL_FORMAT_YV16:
     case PIXEL_FORMAT_YV12A:
     case PIXEL_FORMAT_YV24:
+    case PIXEL_FORMAT_Y8:
       return 1;
     case PIXEL_FORMAT_MJPEG:
       return 0;
     case PIXEL_FORMAT_UNKNOWN:
       break;
   }
   NOTREACHED();
   return 0;
 }
 
@@ skipping 38 matching lines @@
   if (zero_initialize_memory)
     memset(data, 0, data_size);
 
   for (size_t plane = 0; plane < NumPlanes(format_); ++plane)
     data_[plane] = data + offset[plane];
 
   AddDestructionObserver(base::Bind(&base::AlignedFree, data));
 }
 
 }  // namespace media