16 bpp video stream capture, render and createImageBitmap(video) using (CPU) shared memory buffers

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 752 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_Y16) {
+    LOG(DFATAL) << "Only PIXEL_FORMAT_I420 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);
   }
-  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);
+  switch (NumPlanes(format)) {
+    case 0:
+    case 2:
+    case 4:
+      NOTREACHED();

[xhwang, 2016/10/27 16:59:18]

In prod, we are still returning a non-null frame here. Shall we just return
nullptr here instead?

[aleksandar.stojiljkovic, 2016/10/27 19:12:22]

Done. Replaced by LOG(DFATAL) and return nullptr, according to the handling in
l.774 and l.785.

+      break;
+    case 3:
+      DCHECK_EQ(format, PIXEL_FORMAT_I420);
+      // 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_[kVPlane] = coded_size.width() / 2;
+      frame->data_[kVPlane] = data + (coded_size.GetArea() * 5 / 4);
+      frame->strides_[kUPlane] = coded_size.width() / 2;
+      frame->data_[kUPlane] = data + coded_size.GetArea();
+    // Fall through.
+    case 1:
+      frame->strides_[kYPlane] = RowBytes(kYPlane, format, coded_size.width());
+      frame->data_[kYPlane] = data;
+      return frame;
+  }
   return frame;
 }
 
 VideoFrame::VideoFrame(VideoPixelFormat format,
                        StorageType storage_type,
                        const gfx::Size& coded_size,
                        const gfx::Rect& visible_rect,
                        const gfx::Size& natural_size,
                        base::TimeDelta timestamp)
     : format_(format),
@@ skipping 150 matching lines @@
     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_YUV444P12:
+        case PIXEL_FORMAT_Y16:
           return gfx::Size(1, 1);
 
         case PIXEL_FORMAT_YV16:
         case PIXEL_FORMAT_YUV422P9:
         case PIXEL_FORMAT_YUV422P10:
         case PIXEL_FORMAT_YUV422P12:
           return gfx::Size(2, 1);
 
         case PIXEL_FORMAT_YV12:
         case PIXEL_FORMAT_I420:
         case PIXEL_FORMAT_YV12A:
         case PIXEL_FORMAT_NV12:
         case PIXEL_FORMAT_NV21:
         case PIXEL_FORMAT_MT21:
         case PIXEL_FORMAT_YUV420P9:
         case PIXEL_FORMAT_YUV420P10:
         case PIXEL_FORMAT_YUV420P12:
           return gfx::Size(2, 2);
 
         case PIXEL_FORMAT_UNKNOWN:
         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:
           break;
       }
   }
   NOTREACHED();
   return gfx::Size();
 }
 
 // static
 int VideoFrame::BytesPerElement(VideoPixelFormat format, size_t plane) {
   DCHECK(IsValidPlane(plane, format));
@@ skipping 81 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