fix highbit video

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 496 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;
-
-        // If the input data was 9 or 10 bit, and we output to half-floats,
-        // then we used the OR path below, which means that we need to
-        // adjust the resource offset and multiplier accordingly. If the
-        // input data uses more than 10 bits, it will already be normalized
-        // to 0.0..1.0, so there is no need to do anything.
-        if (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.
-          //
-          // https://en.wikipedia.org/wiki/Half-precision_floating-point_format
-          //
-          // PLEASE NOTE:
-          // All planes are assumed to use the same multiplier/offset.
-          external_resources.offset = 0.5f;
-          // Max value from input data.
-          int max_input_value = (1 << bits_per_channel) - 1;
-          // 2 << 11 = 2048 would be 1.0 with our exponent.
-          external_resources.multiplier = 2048.0 / max_input_value;
-        }
       } 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);
@@ skipping 39 matching lines @@
           }
         }
         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 the input data was 9 or 10 bit, and we output to half-floats,
+      // then we used the OR path below, which means that we need to

[danakj, 2016/10/05 23:20:01]

comment wrong now

[hubbe, 2016/10/06 00:16:30]

Done.

+      // adjust the resource offset and multiplier accordingly. If the
+      // input data uses more than 10 bits, it will already be normalized
+      // to 0.0..1.0, so there is no need to do anything.
+      if (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.
+        //
+        // https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+        //
+        // PLEASE NOTE:
+        // All planes are assumed to use the same multiplier/offset.
+        external_resources.offset = 0.5f;
+        // Max value from input data.
+        int max_input_value = (1 << bits_per_channel) - 1;
+        // 2 << 11 = 2048 would be 1.0 with our exponent.
+        external_resources.multiplier = 2048.0 / max_input_value;
+      }
+    }
 
     // VideoResourceUpdater shares a context with the compositor so a
     // sync token is not required.
     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()));
@@ skipping 147 matching lines @@
   if (lost_resource) {
     resource_it->clear_refs();
     updater->DeleteResource(resource_it);
     return;
   }
 
   resource_it->remove_ref();
 }
 
 }  // namespace cc