12-bit vp9 video 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 66 matching lines @@
     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_YUV420P12:
+    case media::PIXEL_FORMAT_YUV422P12:
+    case media::PIXEL_FORMAT_YUV444P12:
     case media::PIXEL_FORMAT_UNKNOWN:
       break;
   }
   return VideoFrameExternalResources::NONE;
 }
 
 class SyncTokenClientImpl : public media::VideoFrame::SyncTokenClient {
  public:
   SyncTokenClientImpl(gpu::gles2::GLES2Interface* gl,
                       const gpu::SyncToken& sync_token)
@@ skipping 185 matching lines @@
   if (software_compositor)
     return coded_size;
 
   int plane_width = media::VideoFrame::Columns(
       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);
 }
 
+// Values are expected to be in [0.0..1.0]
+void VideoResourceUpdater::MakeHalfFloats(const uint16_t* src,

[danakj, 2016/09/26 22:10:39]

Maybe MultiplyHalfFloats would be a more accurate/descriptive name?

[hubbe, 2016/09/27 00:03:24]

I think I did a terrible job of explaining what this function does.
Trying again....

+                                          float mult,
+                                          size_t num,
+                                          uint16_t* dst) {
+  // TODO(hubbe): Make AVX and neon versions of this code.
+
+  // This magic constant is 2^-112. Multiplying by this
+  // is the same as subtracting 112 from the exponent, which
+  // is he difference in exponent bias between 32-bit and

[danakj, 2016/09/26 22:10:39]

is the

[hubbe, 2016/09/27 00:03:24]

Done.

+  // 16-bit floats. Once we've done this subtraction, we can
+  // simply extract the low bits of the exponent and the high
+  // bits of the mantissa from our float and we're done.
+  mult *= 1.9259299444e-34f;
+  for (size_t i = 0; i < num; i++) {
+    float value = src[i] * mult;
+    dst[i] = (*(uint32_t*)&value) >> 13;
+  }
+}
+
 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();
@@ skipping 18 matching lines @@
     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_YUV420P12:
+    case media::PIXEL_FORMAT_YUV422P12:
+    case media::PIXEL_FORMAT_YUV444P12:
+      bits_per_channel = 12;
+      break;
   }
 
   // Only YUV software video frames are supported.
   if (!media::IsYuvPlanar(input_frame_format)) {
     NOTREACHED() << media::VideoPixelFormatToString(input_frame_format);
     return VideoFrameExternalResources();
   }
 
   const bool software_compositor = context_provider_ == NULL;
 
@@ skipping 135 matching lines @@
       // Assuming that GL_UNPACK_ALIGNMENT has not changed from default.
       size_t upload_image_stride =
           MathUtil::CheckedRoundUp<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);
       } 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));
-            // 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;
+            if (bits_per_channel <= 10) {
+              // 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 {
+              MakeHalfFloats(src, 1.0f / ((1 << bits_per_channel) - 1),
+                             bytes_per_row / 2, dst);
+            }
           } 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 {
             // 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 &&
+        bits_per_channel <= 10) {
       // 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 168 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc