Call libyuv for short->half-float conversion

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>
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/resource_util.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "media/base/video_frame.h"
 #include "media/renderers/skcanvas_video_renderer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/geometry/size_conversions.h"
 
 namespace cc {
 
 namespace {
 
 const ResourceFormat kRGBResourceFormat = RGBA_8888;
 
 VideoFrameExternalResources::ResourceType ResourceTypeForVideoFrame(
@@ skipping 256 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);
 }
 
 void VideoResourceUpdater::MakeHalfFloats(const uint16_t* src,
                                           int bits_per_channel,
                                           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 the difference in exponent bias between 32-bit and
-  // 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.
-  float mult = 1.9259299444e-34f / ((1 << bits_per_channel) - 1);
-  for (size_t i = 0; i < num; i++) {
-    float value = src[i] * mult;
-    dst[i] = (*(uint32_t*)&value) >> 13;
-  }
+  libyuv::HalfFloatPlane(src, 0, dst, 0, 1.0f / ((1 << bits_per_channel) - 1),

[danakj, 2016/10/03 22:48:15]

Can you use a temp var to give "1.0f / ((1 << bits_per_channel) - 1)" a name?
Same for the "1" at the end.. maybe for all the literals here.

[hubbe, 2016/10/03 23:30:49]

Better?

[danakj, 2016/10/03 23:47:43]

Much, thanks.

[hubbe, 2016/10/03 23:56:35]

Acknowledged.

+                         num, 1);
 }
 
 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) {
@@ skipping 163 matching lines @@
     }
     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));
 
     if (!plane_resource.Matches(video_frame->unique_id(), i)) {

[danakj, 2016/10/03 22:48:15]

I'm starting to wonder if everything inside this if statement belongs in media/
code, dep'ing libraries for this really makes me think.

[hubbe, 2016/10/03 23:30:49]

Agreed, although I'm not sure exactly what that would look like.
It might be best if we could just arrange it so that all texture
uploads happens before we get to this point. That is what happens
in most cases anyways. (Most video texture uploads is done in
src/media/video/gpu_memory_buffer_video_frame_pool.cc)  Unfortunately
gpu memory buffers can't easily support half-float textures, however, there is a
separate CL that uses RG_88 textures instead of half-floats, and it that
happens, we should be able to move high-bit uploads to
gpu_memory_buffer_video_frame_pool.cc as well, and then maybe we can just scrap
most of this code....

[danakj, 2016/10/03 23:47:44]

Yeh, I don't know that it belongs on VideoFrame. Doing it before making a
VideoFrame could work but this code depends on using the compositor context atm.

I was thinking just the code that makes a bitmap in the correct format for
upload, ie the code producing a pixels pointer, but not the upload call at the
end, would be a somewhat easy-to-do thing.

[hubbe, 2016/10/03 23:56:35]

All true, but probably better resolved in a separate CL.
Also, I would prefer to do a little wait-and-see on the RG88 stuff
before I start cleaning this stuff up, as that sort of determines
the right way to clean this up.

Is it ok if I just add a TODO for now?

[danakj, 2016/10/03 23:58:56]

A TODO is more than I was expecting for this CL, that'd be wonderful. Thanks!

       // 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);
 
@@ skipping 257 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc