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;
-  }
+  // Source and dest stride can be zero since we're only copying
+  // one row at a time.
+  int stride = 0;
+  // Maximum value used in |src|.
+  int max_value = (1 << bits_per_channel) - 1;
+  // Copy one row.

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

this comment's redundant i think, the var says the same. the others are nice as
they explain why the value is what it is.

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

Done.

+  int rows = 1;
+  libyuv::HalfFloatPlane(src, stride, dst, stride, 1.0f / max_value, num, rows);
 }
 
 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 441 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc