cc: UYVY video is not premultiplied rgba

cc/resources/video_resource_updater_unittest.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 "base/bind.h"
@@ skipping 154 matching lines @@
     scoped_refptr<media::VideoFrame> video_frame(media::VideoFrame::CreateFrame(
         media::PIXEL_FORMAT_YUV420P10, size, gfx::Rect(size), size,
         base::TimeDelta()));
     EXPECT_TRUE(video_frame);
     return video_frame;
   }
 
   static void ReleaseMailboxCB(const gpu::SyncToken& sync_token) {}
 
   scoped_refptr<media::VideoFrame> CreateTestHardwareVideoFrame(
-      unsigned target) {
+      unsigned target,
+      media::VideoPixelFormat format) {
     const int kDimension = 10;
     gfx::Size size(kDimension, kDimension);
 
     gpu::Mailbox mailbox;
     mailbox.name[0] = 51;
 
     const gpu::SyncToken sync_token(
         gpu::CommandBufferNamespace::GPU_IO, 0,
         gpu::CommandBufferId::FromUnsafeValue(0x123), 7);
     gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes] = {
         gpu::MailboxHolder(mailbox, sync_token, target)};
     scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::WrapNativeTextures(media::PIXEL_FORMAT_ARGB,
-                                              mailbox_holders,
+        media::VideoFrame::WrapNativeTextures(format, mailbox_holders,
                                               base::Bind(&ReleaseMailboxCB),
                                               size,             // coded_size
                                               gfx::Rect(size),  // visible_rect
                                               size,             // natural_size
                                               base::TimeDelta());  // timestamp
     EXPECT_TRUE(video_frame);
     return video_frame;
   }
 
   scoped_refptr<media::VideoFrame> CreateTestRGBAHardwareVideoFrame() {
-    return CreateTestHardwareVideoFrame(GL_TEXTURE_2D);
+    return CreateTestHardwareVideoFrame(GL_TEXTURE_2D,
+                                        media::PIXEL_FORMAT_ARGB);
   }
 
   scoped_refptr<media::VideoFrame> CreateTestStreamTextureHardwareVideoFrame(
       bool needs_copy) {
-    scoped_refptr<media::VideoFrame> video_frame =
-        CreateTestHardwareVideoFrame(GL_TEXTURE_EXTERNAL_OES);
+    scoped_refptr<media::VideoFrame> video_frame = CreateTestHardwareVideoFrame(
+        GL_TEXTURE_EXTERNAL_OES, media::PIXEL_FORMAT_ARGB);
     video_frame->metadata()->SetBoolean(
         media::VideoFrameMetadata::COPY_REQUIRED, needs_copy);
     return video_frame;
   }
 
+  scoped_refptr<media::VideoFrame> CreateTestUYVYTextureHardwareVideoFrame(
+      unsigned target) {
+    scoped_refptr<media::VideoFrame> video_frame =
+        CreateTestHardwareVideoFrame(target, media::PIXEL_FORMAT_UYVY);
+    video_frame->metadata()->SetBoolean(
+        media::VideoFrameMetadata::COPY_REQUIRED, false);
+    return video_frame;
+  }
+
   scoped_refptr<media::VideoFrame> CreateTestYuvHardwareVideoFrame() {
     const int kDimension = 10;
     gfx::Size size(kDimension, kDimension);
 
     const gpu::SyncToken sync_token(
         gpu::CommandBufferNamespace::GPU_IO, 0,
         gpu::CommandBufferId::FromUnsafeValue(0x123), 7);
     const unsigned target = GL_TEXTURE_RECTANGLE_ARB;
     const int kPlanesNum = 3;
     gpu::MailboxHolder mailbox_holders[media::VideoFrame::kMaxPlanes];
@@ skipping 285 matching lines @@
   EXPECT_EQ(1, context3d_->TextureCreationCount());
 
   // The texture copy path requires the use of CopyTextureCHROMIUM, which
   // enforces that the target texture not be immutable, as it may need
   // to alter the storage of the texture. Therefore, this test asserts
   // that an immutable texture wasn't created by glTexStorage2DEXT, when
   // that extension is supported.
   EXPECT_FALSE(context3d_->WasImmutableTextureCreated());
 }
 
+TEST_F(VideoResourceUpdaterTest, CreateForHardwarePlanes_UYVYTexture) {
+  VideoResourceUpdater updater(context_provider_.get(),
+                               resource_provider3d_.get());
+
+  scoped_refptr<media::VideoFrame> video_frame =
+      CreateTestUYVYTextureHardwareVideoFrame(GL_TEXTURE_2D);
+
+  VideoFrameExternalResources resources =
+      updater.CreateExternalResourcesFromVideoFrame(video_frame);
+  EXPECT_EQ(VideoFrameExternalResources::RGB_RESOURCE, resources.type);
+  EXPECT_EQ(1u, resources.mailboxes.size());
+  EXPECT_EQ(1u, resources.release_callbacks.size());
+  EXPECT_EQ(0u, resources.software_resources.size());
+
+  video_frame =
+      CreateTestUYVYTextureHardwareVideoFrame(GL_TEXTURE_EXTERNAL_OES);
+
+  resources = updater.CreateExternalResourcesFromVideoFrame(video_frame);
+  EXPECT_EQ(VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE,
+            resources.type);
+  EXPECT_EQ(1u, resources.mailboxes.size());
+  EXPECT_EQ(1u, resources.release_callbacks.size());
+  EXPECT_EQ(0u, resources.software_resources.size());
+}
+
 namespace {
 
 // Convert an IEEE 754 half-float to a double value
 // that we can do math on.
 double FromHalfFloat(uint16_t half_float) {
   if (!half_float)
     return 0.0;
   int sign = (half_float & 0x8000) ? -1 : 1;
   int exponent = (half_float >> 10) & 0x1F;
   int fraction = half_float & 0x3FF;
@@ skipping 39 matching lines @@
           FromHalfFloat(half_floats[i] + 1) - FromHalfFloat(half_floats[i]);
       EXPECT_NEAR(FromHalfFloat(half_floats[i]), expected_value,
                   expected_precision)
           << "i = " << i << " bits = " << bits;
     }
   }
 }
 
 }  // namespace
 }  // namespace cc