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

cc/resources/video_resource_updater.cc

 // Copyright 2013 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 "cc/resources/video_resource_updater.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 49 matching lines @@
       switch (video_frame->mailbox_holder(0).texture_target) {
         case GL_TEXTURE_EXTERNAL_OES:
           return VideoFrameExternalResources::YUV_RESOURCE;
         case GL_TEXTURE_RECTANGLE_ARB:
           return VideoFrameExternalResources::RGB_RESOURCE;
         default:
           NOTREACHED();
           break;
       }
       break;
+    case media::PIXEL_FORMAT_Y8:
+    case media::PIXEL_FORMAT_Y16:
+      return VideoFrameExternalResources::Y_RESOURCE;
+      break;
     case media::PIXEL_FORMAT_YV12:
     case media::PIXEL_FORMAT_YV16:
     case media::PIXEL_FORMAT_YV24:
     case media::PIXEL_FORMAT_YV12A:
     case media::PIXEL_FORMAT_NV21:
     case media::PIXEL_FORMAT_YUY2:
     case media::PIXEL_FORMAT_RGB24:
     case media::PIXEL_FORMAT_RGB32:
     case media::PIXEL_FORMAT_MJPEG:
     case media::PIXEL_FORMAT_MT21:
     case media::PIXEL_FORMAT_YUV420P9:
     case media::PIXEL_FORMAT_YUV422P9:
     case media::PIXEL_FORMAT_YUV444P9:
     case media::PIXEL_FORMAT_YUV420P10:
     case media::PIXEL_FORMAT_YUV422P10:
     case media::PIXEL_FORMAT_YUV444P10:
     case media::PIXEL_FORMAT_UNKNOWN:
       break;
   }
   return VideoFrameExternalResources::NONE;
 }
 
+static const uint8_t exp_lookup_table_lower[256] = {
+#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
+    0,     0,     0,     0,     1,     1,     1,     1,     2,     2,     2,
+    2,     2,     2,     2,     2,     LT(3), LT(4), LT(4), LT(5), LT(5), LT(5),
+    LT(5), LT(6), LT(6), LT(6), LT(6), LT(6), LT(6), LT(6), LT(6)};
+
+static const uint8_t exp_lookup_table_upper[256] = {
+#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
+    7,      7,      8,      8,      9,      9,      9,      9,
+    10,     10,     10,     10,     10,     10,     10,     10,
+    LT(11), LT(12), LT(12), LT(13), LT(13), LT(13), LT(13), LT(14),
+    LT(14), LT(14), LT(14), LT(14), LT(14), LT(14), LT(14)};
+
+uint16_t ushort_to_half_float(uint16_t value) {
+  unsigned short upper = value >> 8;
+  unsigned short exponent =
+      upper ? exp_lookup_table_upper[upper] : exp_lookup_table_lower[value];
+  return (exponent << 10) | (((value << (15 - exponent)) >> 6) & 0x3FF);
+}
+
 class SyncTokenClientImpl : public media::VideoFrame::SyncTokenClient {
  public:
   SyncTokenClientImpl(gpu::gles2::GLES2Interface* gl,
                       const gpu::SyncToken& sync_token)
       : gl_(gl), sync_token_(sync_token) {}
   ~SyncTokenClientImpl() override {}
   void GenerateSyncToken(gpu::SyncToken* sync_token) override {
     if (sync_token_.HasData()) {
       *sync_token = sync_token_;
     } else {
@@ skipping 141 matching lines @@
       plane_index, input_frame->format(), coded_size.width());
   int plane_height = media::VideoFrame::Rows(plane_index, input_frame->format(),
                                              coded_size.height());
   return gfx::Size(plane_width, plane_height);
 }
 
 VideoFrameExternalResources VideoResourceUpdater::CreateForSoftwarePlanes(
     scoped_refptr<media::VideoFrame> video_frame) {
   TRACE_EVENT0("cc", "VideoResourceUpdater::CreateForSoftwarePlanes");
   const media::VideoPixelFormat input_frame_format = video_frame->format();
-
   // TODO(hubbe): Make this a video frame method.
   int bits_per_channel = 0;
   switch (input_frame_format) {
     case media::PIXEL_FORMAT_UNKNOWN:
       NOTREACHED();
     // Fall through!
     case media::PIXEL_FORMAT_I420:
     case media::PIXEL_FORMAT_YV12:
     case media::PIXEL_FORMAT_YV16:
     case media::PIXEL_FORMAT_YV12A:
     case media::PIXEL_FORMAT_YV24:
     case media::PIXEL_FORMAT_NV12:
     case media::PIXEL_FORMAT_NV21:
     case media::PIXEL_FORMAT_UYVY:
     case media::PIXEL_FORMAT_YUY2:
     case media::PIXEL_FORMAT_ARGB:
     case media::PIXEL_FORMAT_XRGB:
     case media::PIXEL_FORMAT_RGB24:
     case media::PIXEL_FORMAT_RGB32:
     case media::PIXEL_FORMAT_MJPEG:
     case media::PIXEL_FORMAT_MT21:
+    case media::PIXEL_FORMAT_Y8:
       bits_per_channel = 8;
       break;
     case media::PIXEL_FORMAT_YUV420P9:
     case media::PIXEL_FORMAT_YUV422P9:
     case media::PIXEL_FORMAT_YUV444P9:
       bits_per_channel = 9;
       break;
     case media::PIXEL_FORMAT_YUV420P10:
     case media::PIXEL_FORMAT_YUV422P10:
     case media::PIXEL_FORMAT_YUV444P10:
       bits_per_channel = 10;
       break;
+    case media::PIXEL_FORMAT_Y16:
+      bits_per_channel = 16;
+      break;
   }
 
-  // Only YUV software video frames are supported.
-  if (!media::IsYuvPlanar(input_frame_format)) {
+  // Only YUV, Y8 and Y16 software video frames are supported.
+  const bool isYuvPlanar = media::IsYuvPlanar(input_frame_format);
+  if (!(isYuvPlanar || input_frame_format == media::PIXEL_FORMAT_Y16 ||
+        input_frame_format == media::PIXEL_FORMAT_Y8)) {
     NOTREACHED() << media::VideoPixelFormatToString(input_frame_format);
     return VideoFrameExternalResources();
   }
 
   const bool software_compositor = context_provider_ == NULL;
 
+  if ((input_frame_format == media::PIXEL_FORMAT_Y8 ||
+       input_frame_format == media::PIXEL_FORMAT_Y16) &&
+      software_compositor) {
+    // TODO(astojilj) Y8 and Y16 software compositor support.
+    NOTREACHED() << "Software compositor doesn't support PIXEL_FORMAT_Y8/Y16";
+    return VideoFrameExternalResources();
+  }
+
   ResourceFormat output_resource_format =
-      resource_provider_->YuvResourceFormat(bits_per_channel);
+      (input_frame_format == media::PIXEL_FORMAT_Y16)
+          ? resource_provider_->Y16ResourceFormat()
+          : resource_provider_->YuvResourceFormat(bits_per_channel);
 
   size_t output_plane_count = media::VideoFrame::NumPlanes(input_frame_format);
 
   // TODO(skaslev): If we're in software compositing mode, we do the YUV -> RGB
   // conversion here. That involves an extra copy of each frame to a bitmap.
   // Obviously, this is suboptimal and should be addressed once ubercompositor
   // starts shaping up.
   if (software_compositor) {
     output_resource_format = kRGBResourceFormat;
     output_plane_count = 1;
@@ skipping 94 matching lines @@
         plane_resource.resource_id());
     external_resources.software_release_callback =
         base::Bind(&RecycleResource, AsWeakPtr(), plane_resource.resource_id());
     external_resources.type = VideoFrameExternalResources::SOFTWARE_RESOURCE;
     return external_resources;
   }
 
   for (size_t i = 0; i < plane_resources.size(); ++i) {
     PlaneResource& plane_resource = *plane_resources[i];
     // Update each plane's resource id with its content.
-    DCHECK_EQ(plane_resource.resource_format(),
-              resource_provider_->YuvResourceFormat(bits_per_channel));
+    DCHECK_EQ(plane_resource.resource_format(), output_resource_format);
 
     if (!plane_resource.Matches(video_frame->unique_id(), i)) {
       // We need to transfer data from |video_frame| to the plane resource.
       // TODO(reveman): Can use GpuMemoryBuffers here to improve performance.
 
       // The |resource_size_pixels| is the size of the resource we want to
       // upload to.
       gfx::Size resource_size_pixels = plane_resource.resource_size();
       // The |video_stride_bytes| is the width of the video frame we are
       // uploading (including non-frame data to fill in the stride).
       int video_stride_bytes = video_frame->stride(i);
 
       size_t bytes_per_row = ResourceUtil::UncheckedWidthInBytes<size_t>(
           resource_size_pixels.width(), plane_resource.resource_format());
       // Use 4-byte row alignment (OpenGL default) for upload performance.
       // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
       size_t upload_image_stride =
           MathUtil::UncheckedRoundUp<size_t>(bytes_per_row, 4u);
 
       bool needs_conversion = false;
       int shift = 0;
 
       // LUMINANCE_F16 uses half-floats, so we always need a conversion step.
       if (plane_resource.resource_format() == LUMINANCE_F16) {
         needs_conversion = true;
         // Note that the current method of converting integers to half-floats
         // stops working if you have more than 10 bits of data.
-        DCHECK_LE(bits_per_channel, 10);
+        DCHECK(bits_per_channel <= 10 || !isYuvPlanar);
+      } else if (input_frame_format == media::PIXEL_FORMAT_Y16) {
+        if (plane_resource.resource_format() == RGBA_8888)
+          needs_conversion = true;
       } else if (bits_per_channel > 8) {
         // If bits_per_channel > 8 and we can't use LUMINANCE_F16, we need to
         // shift the data down and create an 8-bit texture.
         needs_conversion = true;
         shift = bits_per_channel - 8;
       }
       const uint8_t* pixels;
       if (static_cast<int>(upload_image_stride) == video_stride_bytes &&
           !needs_conversion) {
         pixels = video_frame->data(i);
       } else {
         // Avoid malloc for each frame/plane if possible.
         size_t needed_size =
             upload_image_stride * resource_size_pixels.height();
         if (upload_pixels_.size() < needed_size)
           upload_pixels_.resize(needed_size);
 
         for (int row = 0; row < resource_size_pixels.height(); ++row) {
           if (plane_resource.resource_format() == LUMINANCE_F16) {
             uint16_t* dst = reinterpret_cast<uint16_t*>(
                 &upload_pixels_[upload_image_stride * row]);
             const uint16_t* src = reinterpret_cast<uint16_t*>(
                 video_frame->data(i) + (video_stride_bytes * row));
+
+            if (input_frame_format == media::PIXEL_FORMAT_Y16) {
+              for (size_t i = 0; i < bytes_per_row / 2; i++)
+                dst[i] = ushort_to_half_float(src[i]);
+              continue;
+            }
             // Micro-benchmarking indicates that the compiler does
             // a good enough job of optimizing this loop that trying
             // to manually operate on one uint64 at a time is not
             // actually helpful.
             // Note to future optimizers: Benchmark your optimizations!
             for (size_t i = 0; i < bytes_per_row / 2; i++)
               dst[i] = src[i] | 0x3800;
           } else if (shift != 0) {
             // We have more-than-8-bit input which we need to shift
             // down to fit it into an 8-bit texture.
             uint8_t* dst = &upload_pixels_[upload_image_stride * row];
             const uint16_t* src = reinterpret_cast<uint16_t*>(
                 video_frame->data(i) + (video_stride_bytes * row));
             for (size_t i = 0; i < bytes_per_row; i++)
               dst[i] = src[i] >> shift;
+          } else if (input_frame_format == media::PIXEL_FORMAT_Y16 &&
+                     plane_resource.resource_format() == RGBA_8888) {
+            uint32_t* dst = reinterpret_cast<uint32_t*>(
+                &upload_pixels_[upload_image_stride * row]);
+            const uint16_t* src = reinterpret_cast<uint16_t*>(
+                video_frame->data(i) + (video_stride_bytes * row));
+            for (size_t i = 0; i < bytes_per_row / 4; ++i)
+              *dst++ = *src++;
           } else {
             // Input and output are the same size and format, but
             // differ in stride, copy one row at a time.
             uint8_t* dst = &upload_pixels_[upload_image_stride * row];
             const uint8_t* src =
                 video_frame->data(i) + (video_stride_bytes * row);
             memcpy(dst, src, bytes_per_row);
           }
         }
         pixels = &upload_pixels_[0];
       }
 
       resource_provider_->CopyToResource(plane_resource.resource_id(), pixels,
                                          resource_size_pixels);
       plane_resource.SetUniqueId(video_frame->unique_id(), i);
     }
 
-    if (plane_resource.resource_format() == LUMINANCE_F16) {
+    if (plane_resource.resource_format() == LUMINANCE_F16 && isYuvPlanar) {
       // By OR-ing with 0x3800, 10-bit numbers become half-floats in the
       // range [0.5..1) and 9-bit numbers get the range [0.5..0.75).
       //
       // Half-floats are evaluated as:
       // float value = pow(2.0, exponent - 25) * (0x400 + fraction);
       //
       // In our case the exponent is 14 (since we or with 0x3800) and
       // pow(2.0, 14-25) * 0x400 evaluates to 0.5 (our offset) and
       // pow(2.0, 14-25) * fraction is [0..0.49951171875] for 10-bit and
       // [0..0.24951171875] for 9-bit.
@@ skipping 11 matching lines @@
 
     TextureMailbox mailbox(plane_resource.mailbox(), gpu::SyncToken(),
                            resource_provider_->GetResourceTextureTarget(
                                plane_resource.resource_id()));
     mailbox.set_color_space(video_frame->ColorSpace());
     external_resources.mailboxes.push_back(mailbox);
     external_resources.release_callbacks.push_back(base::Bind(
         &RecycleResource, AsWeakPtr(), plane_resource.resource_id()));
   }
 
-  external_resources.type = VideoFrameExternalResources::YUV_RESOURCE;
+  external_resources.type =
+      (input_frame_format == media::PIXEL_FORMAT_Y16)
+          ? VideoFrameExternalResources::Y_RESOURCE
+          : (isYuvPlanar ? VideoFrameExternalResources::YUV_RESOURCE
+                         : VideoFrameExternalResources::RGB_RESOURCE);
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
     base::WeakPtr<VideoResourceUpdater> updater,
     const scoped_refptr<media::VideoFrame>& video_frame,
     const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
@@ skipping 116 matching lines @@
                              video_frame->coded_size(),
                              video_frame->metadata()->IsTrue(
                                  media::VideoFrameMetadata::ALLOW_OVERLAY),
                              false);
       mailbox.set_color_space(video_frame->ColorSpace());
       external_resources.mailboxes.push_back(mailbox);
       external_resources.release_callbacks.push_back(
           base::Bind(&ReturnTexture, AsWeakPtr(), video_frame));
     }
   }
+
+  external_resources.bits_per_channel =
+      (video_frame->format() == media::PIXEL_FORMAT_Y16) ? 16 : 8;
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     ResourceId resource_id,
     const gpu::SyncToken& sync_token,
     bool lost_resource,
     BlockingTaskRunner* main_thread_task_runner) {
@@ skipping 19 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc