Enable sampling from DXGI NV12 formats in GLRenderer.

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 328 matching lines @@
       DeleteResource(it++);
     else
       ++it;
   }
 
   const int max_resource_size = resource_provider_->max_texture_size();
   std::vector<ResourceList::iterator> plane_resources;
   for (size_t i = 0; i < output_plane_count; ++i) {
     gfx::Size output_plane_resource_size =
         SoftwarePlaneDimension(video_frame.get(), software_compositor, i);
+    ResourceFormat plane_resource_format = output_resource_format;
+    if ((input_frame_format == media::PIXEL_FORMAT_NV12) && (i == 1)) {

[danakj, 2016/04/13 00:24:18]

If all of this is for tests I'd prefer to just not support NV12 here at all. Is
that the case?

I was thinking of these tests:
https://code.google.com/p/chromium/codesearch#chromium/src/cc/output/gl_rende...

Are the pixel tests testing more production code than that would?

+      // A two-byte-per-pixel format would avoid wasting space, but this is
+      // only used in testing.
+      plane_resource_format = RGBA_8888;
+    }
     if (output_plane_resource_size.IsEmpty() ||
         output_plane_resource_size.width() > max_resource_size ||
         output_plane_resource_size.height() > max_resource_size) {
       break;
     }
 
     // Try recycle a previously-allocated resource.
     ResourceList::iterator resource_it = all_resources_.end();
     for (auto it = all_resources_.begin(); it != all_resources_.end(); ++it) {
       if (it->resource_size == output_plane_resource_size &&
-          it->resource_format == output_resource_format) {
+          it->resource_format == plane_resource_format) {
         if (PlaneResourceMatchesUniqueID(*it, video_frame.get(), i)) {
           // Bingo, we found a resource that already contains the data we are
           // planning to put in it. It's safe to reuse it even if
           // resource_provider_ holds some references to it, because those
           // references are read-only.
           resource_it = it;
           break;
         }
 
         // This extra check is needed because resources backed by SharedMemory
         // are not ref-counted, unlike mailboxes. Full discussion in
         // codereview.chromium.org/145273021.
         const bool in_use =
             software_compositor &&
             resource_provider_->InUseByConsumer(it->resource_id);
         if (it->ref_count == 0 && !in_use) {
           // We found a resource with the correct size that we can overwrite.
           resource_it = it;
         }
       }
     }
 
     // Check if we need to allocate a new resource.
     if (resource_it == all_resources_.end()) {
       const bool is_immutable = true;
       resource_it =
-          AllocateResource(output_plane_resource_size, output_resource_format,
+          AllocateResource(output_plane_resource_size, plane_resource_format,
                            !software_compositor, is_immutable);
     }
     if (resource_it == all_resources_.end())
       break;
 
     ++resource_it->ref_count;
     plane_resources.push_back(resource_it);
   }
 
   if (plane_resources.size() != output_plane_count) {
@@ skipping 36 matching lines @@
     external_resources.software_resources.push_back(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));
-
     if (!PlaneResourceMatchesUniqueID(plane_resource, video_frame.get(), 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;
+      bool needs_expansion = false;
 
       // 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;
+      } else if ((input_frame_format == media::PIXEL_FORMAT_NV12) && (i == 1)) {
+        DCHECK_EQ(RGBA_8888, plane_resource.resource_format);
+        needs_conversion = true;
+        // Expand each 2 byte pixel into 4 bytes.
+        needs_expansion = true;
       }
       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)
@@ skipping 13 matching lines @@
             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 (needs_expansion) {
+            uint32_t* dst = reinterpret_cast<uint32_t*>(
+                &upload_pixels_[upload_image_stride * row]);
+            const uint8_t* src =
+                video_frame->data(i) + (video_stride_bytes * row);
+            for (size_t i = 0; i < bytes_per_row / 4; i++) {
+              // The first channel (U) goes in the R component, and the second
+              // (V) goes in the G component. B and A are black.
+              dst[i] = ((src[i * 2] << 24) | (src[i * 2 + 1] << 16));
+            }
           } 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];
@@ skipping 236 matching lines @@
                plane_resource.plane_index == 0;
       });
   if (resource_it == updater->all_resources_.end())
     return;
 
   resource_it->destructed = true;
 }
 #endif
 
 }  // namespace cc