16 bpp video stream capture, render and WebGL usage - Realsense R200 & SR300 support.

media/video/gpu_memory_buffer_video_frame_pool_unittest.cc

 // Copyright 2015 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 <stdint.h>
 #include <memory>
 
 #include "base/bind.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 104 matching lines @@
             size.width() / 2,          // u_stride
             size.width() / 2,          // v_stride
             y_data,                    // y_data
             u_data,                    // u_data
             v_data,                    // v_data
             base::TimeDelta());        // timestamp
     EXPECT_TRUE(video_frame);
     return video_frame;
   }
 
+  static scoped_refptr<media::VideoFrame> CreateTestY16VideoFrame(
+      int dimension) {
+    const int kDimension = 10;
+    static uint8_t data[kDimension * kDimension * 2] = {0};
+
+    DCHECK_LE(dimension, kDimension);
+    gfx::Size size(dimension, dimension);
+
+    scoped_refptr<VideoFrame> video_frame =
+        media::VideoFrame::WrapExternalData(media::PIXEL_FORMAT_Y16,  // format
+                                            size,                // coded_size
+                                            gfx::Rect(size),     // visible_rect
+                                            size,                // natural_size
+                                            data,                // data
+                                            sizeof(data),        // byte size
+                                            base::TimeDelta());  // timestamp
+    EXPECT_TRUE(video_frame);
+    return video_frame;
+  }
+
  protected:
   std::unique_ptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories_;
   std::unique_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_;
   scoped_refptr<base::TestSimpleTaskRunner> media_task_runner_;
   scoped_refptr<base::TestSimpleTaskRunner> copy_task_runner_;
   // GpuMemoryBufferVideoFramePool uses BindToCurrentLoop(), which requires
   // ThreadTaskRunnerHandle initialization.
   std::unique_ptr<base::ThreadTaskRunnerHandle> media_task_runner_handle_;
   std::unique_ptr<TestGLES2Interface> gles2_;
 };
@@ skipping 56 matching lines @@
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
   RunUntilIdle();
 
   EXPECT_NE(software_frame.get(), frame.get());
   EXPECT_EQ(6u, gles2_->gen_textures);
   EXPECT_EQ(frame->mailbox_holder(0).mailbox, mailbox);
   EXPECT_NE(frame->mailbox_holder(0).sync_token, sync_token);
 }
 
-TEST_F(GpuMemoryBufferVideoFramePoolTest, DropResourceWhenSizeIsDifferent) {
+TEST_F(GpuMemoryBufferVideoFramePoolTest,
+       DropResourceWhenSizeOrFormatAreDifferent) {
   scoped_refptr<VideoFrame> frame;
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       CreateTestYUVVideoFrame(10),
       base::Bind(MaybeCreateHardwareFrameCallback, &frame));
   RunUntilIdle();
 
   EXPECT_EQ(3u, gles2_->gen_textures);
 
   frame = nullptr;
   RunUntilIdle();
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       CreateTestYUVVideoFrame(4),
       base::Bind(MaybeCreateHardwareFrameCallback, &frame));
   RunUntilIdle();
   EXPECT_EQ(6u, gles2_->gen_textures);
+
+  frame = nullptr;
+  RunUntilIdle();
+  mock_gpu_factories_->SetVideoFrameOutputFormat(
+      media::GpuVideoAcceleratorFactories::OutputFormat::Y16);
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      CreateTestY16VideoFrame(4),
+      base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+  RunUntilIdle();
+  EXPECT_EQ(7u, gles2_->gen_textures);
 }
 
 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareUYUVFrame) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
   scoped_refptr<VideoFrame> frame;
   mock_gpu_factories_->SetVideoFrameOutputFormat(
       media::GpuVideoAcceleratorFactories::OutputFormat::UYVY);
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 
@@ skipping 30 matching lines @@
       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 
   RunUntilIdle();
 
   EXPECT_NE(software_frame.get(), frame.get());
   EXPECT_EQ(2u, gles2_->gen_textures);
   EXPECT_TRUE(frame->metadata()->IsTrue(
       media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
 }
 
+TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareY16Frame) {
+  scoped_refptr<VideoFrame> software_frame = CreateTestY16VideoFrame(10);
+  scoped_refptr<VideoFrame> frame;
+  mock_gpu_factories_->SetVideoFrameOutputFormat(
+      media::GpuVideoAcceleratorFactories::OutputFormat::Y16);
+  gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
+      software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
+
+  RunUntilIdle();
+
+  EXPECT_NE(software_frame.get(), frame.get());
+  EXPECT_EQ(1u, gles2_->gen_textures);
+  EXPECT_TRUE(frame->metadata()->IsTrue(
+      media::VideoFrameMetadata::READ_LOCK_FENCES_ENABLED));
+}
+
 // AllocateGpuMemoryBuffer can return null (e.g: when the GPU process is down).
 // This test checks that in that case we don't crash and still create the
 // textures.
 TEST_F(GpuMemoryBufferVideoFramePoolTest, AllocateGpuMemoryBufferFail) {
   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
   scoped_refptr<VideoFrame> frame;
   mock_gpu_factories_->SetFailToAllocateGpuMemoryBufferForTesting(true);
   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 
   RunUntilIdle();
 
   EXPECT_NE(software_frame.get(), frame.get());
   EXPECT_EQ(3u, gles2_->gen_textures);
 }
 
 }  // namespace media