media/video/gpu_memory_buffer_video_frame_pool_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/bind.h"
   6 #include "base/test/test_simple_task_runner.h"
   7 #include "gpu/command_buffer/client/gles2_interface_stub.h"
   8 #include "media/base/video_frame.h"
   9 #include "media/renderers/mock_gpu_video_accelerator_factories.h"
  10 #include "media/video/gpu_memory_buffer_video_frame_pool.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12
  13 namespace media {
  14
  15 namespace {
  16 class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub {
  17  public:
  18   unsigned gen_textures = 0u;
  19   void GenTextures(GLsizei n, GLuint* textures) override {
  20     DCHECK_EQ(1, n);
  21     *textures = ++gen_textures;
  22   }
  23
  24   GLuint InsertSyncPointCHROMIUM() override { return ++sync_point; }
  25
  26   void GenMailboxCHROMIUM(GLbyte* mailbox) override {
  27     *reinterpret_cast<unsigned*>(mailbox) = ++this->mailbox;
  28   }
  29
  30  private:
  31   unsigned sync_point = 0u;
  32   unsigned mailbox = 0u;
  33 };
  34
  35 }  // unnamed namespace
  36
  37 class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test {
  38  public:
  39   GpuMemoryBufferVideoFramePoolTest() {}
  40   void SetUp() override {
  41     gles2_.reset(new TestGLES2Interface);
  42     media_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
  43     copy_task_runner_ = make_scoped_refptr(new base::TestSimpleTaskRunner);
  44   }
  45
  46   void TearDown() override { RunUntilIdle(); }
  47
  48   void RunUntilIdle() {
  49     media_task_runner_->RunUntilIdle();
  50     copy_task_runner_->RunUntilIdle();
  51     media_task_runner_->RunUntilIdle();
  52   }
  53
  54   static scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame(
  55       int dimension) {
  56     const int kDimension = 10;
  57     static uint8 y_data[kDimension * kDimension] = {0};
  58     static uint8 u_data[kDimension * kDimension / 2] = {0};
  59     static uint8 v_data[kDimension * kDimension / 2] = {0};
  60
  61     DCHECK_LE(dimension, kDimension);
  62     gfx::Size size(dimension, dimension);
  63
  64     return media::VideoFrame::WrapExternalYuvData(
  65         media::PIXEL_FORMAT_YV12,  // format
  66         size,                      // coded_size
  67         gfx::Rect(size),           // visible_rect
  68         size,                      // natural_size
  69         size.width(),              // y_stride
  70         size.width() / 2,          // u_stride
  71         size.width() / 2,          // v_stride
  72         y_data,                    // y_data
  73         u_data,                    // u_data
  74         v_data,                    // v_data
  75         base::TimeDelta());        // timestamp
  76   }
  77
  78  protected:
  79   scoped_refptr<base::TestSimpleTaskRunner> media_task_runner_;
  80   scoped_refptr<base::TestSimpleTaskRunner> copy_task_runner_;
  81   scoped_ptr<TestGLES2Interface> gles2_;
  82 };
  83
  84 void MaybeCreateHardwareFrameCallback(
  85     scoped_refptr<VideoFrame>* video_frame_output,
  86     const scoped_refptr<VideoFrame>& video_frame) {
  87   *video_frame_output = video_frame;
  88 }
  89
  90 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoGpuFactoryNoHardwareVideoFrame) {
  91   scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10);
  92   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
  93       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
  94           media_task_runner_, copy_task_runner_.get(), nullptr));
  95
  96   scoped_refptr<VideoFrame> frame2;
  97   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
  98       frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2));
  99   RunUntilIdle();
 100   EXPECT_EQ(frame.get(), frame2.get());
 101 }
 102
 103 TEST_F(GpuMemoryBufferVideoFramePoolTest, VideoFrameOutputFormatUnknown) {
 104   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 105   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 106       new MockGpuVideoAcceleratorFactories);
 107   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 108       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 109           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 110
 111   mock_gpu_factories->SetVideoFrameOutputFormat(PIXEL_FORMAT_UNKNOWN);
 112   scoped_refptr<VideoFrame> frame;
 113   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 114       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 115   RunUntilIdle();
 116
 117   EXPECT_EQ(software_frame.get(), frame.get());
 118 }
 119
 120 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareFrame) {
 121   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 122   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 123       new MockGpuVideoAcceleratorFactories);
 124   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 125       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 126           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 127
 128   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 129       .WillRepeatedly(testing::Return(gles2_.get()));
 130
 131   scoped_refptr<VideoFrame> frame;
 132   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 133       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 134
 135   RunUntilIdle();
 136
 137   EXPECT_NE(software_frame.get(), frame.get());
 138   EXPECT_EQ(3u, gles2_->gen_textures);
 139 }
 140
 141 TEST_F(GpuMemoryBufferVideoFramePoolTest, ReuseFirstResource) {
 142   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 143   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 144       new MockGpuVideoAcceleratorFactories);
 145   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 146       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 147           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 148
 149   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 150       .WillRepeatedly(testing::Return(gles2_.get()));
 151
 152   scoped_refptr<VideoFrame> frame;
 153   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 154       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 155   RunUntilIdle();
 156
 157   EXPECT_NE(software_frame.get(), frame.get());
 158   gpu::Mailbox mailbox = frame->mailbox_holder(0).mailbox;
 159   unsigned sync_point = frame->mailbox_holder(0).sync_point;
 160   EXPECT_EQ(3u, gles2_->gen_textures);
 161
 162   scoped_refptr<VideoFrame> frame2;
 163   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 164       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2));
 165   RunUntilIdle();
 166
 167   EXPECT_NE(software_frame.get(), frame2.get());
 168   EXPECT_NE(mailbox, frame2->mailbox_holder(0).mailbox);
 169   EXPECT_EQ(6u, gles2_->gen_textures);
 170
 171   frame = nullptr;
 172   frame2 = nullptr;
 173   RunUntilIdle();
 174
 175   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 176       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 177   RunUntilIdle();
 178
 179   EXPECT_NE(software_frame.get(), frame.get());
 180   EXPECT_EQ(6u, gles2_->gen_textures);
 181   EXPECT_EQ(frame->mailbox_holder(0).mailbox, mailbox);
 182   EXPECT_NE(frame->mailbox_holder(0).sync_point, sync_point);
 183 }
 184
 185 TEST_F(GpuMemoryBufferVideoFramePoolTest, DropResourceWhenSizeIsDifferent) {
 186   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 187       new MockGpuVideoAcceleratorFactories);
 188   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 189       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 190           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 191
 192   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 193       .WillRepeatedly(testing::Return(gles2_.get()));
 194
 195   scoped_refptr<VideoFrame> frame;
 196   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 197       CreateTestYUVVideoFrame(10),
 198       base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 199   RunUntilIdle();
 200
 201   EXPECT_EQ(3u, gles2_->gen_textures);
 202
 203   frame = nullptr;
 204   RunUntilIdle();
 205   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 206       CreateTestYUVVideoFrame(4),
 207       base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 208   RunUntilIdle();
 209   EXPECT_EQ(6u, gles2_->gen_textures);
 210 }
 211
 212 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareUYUVFrame) {
 213   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 214   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 215       new MockGpuVideoAcceleratorFactories);
 216   mock_gpu_factories->SetVideoFrameOutputFormat(PIXEL_FORMAT_UYVY);
 217   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 218       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 219           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 220
 221   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 222       .WillRepeatedly(testing::Return(gles2_.get()));
 223
 224   scoped_refptr<VideoFrame> frame;
 225   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 226       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 227
 228   RunUntilIdle();
 229
 230   EXPECT_NE(software_frame.get(), frame.get());
 231   EXPECT_EQ(1u, gles2_->gen_textures);
 232 }
 233
 234 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareNV12Frame) {
 235   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 236   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 237       new MockGpuVideoAcceleratorFactories);
 238   mock_gpu_factories->SetVideoFrameOutputFormat(PIXEL_FORMAT_NV12);
 239   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 240       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 241           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 242
 243   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 244       .WillRepeatedly(testing::Return(gles2_.get()));
 245
 246   scoped_refptr<VideoFrame> frame;
 247   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 248       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 249
 250   RunUntilIdle();
 251
 252   EXPECT_NE(software_frame.get(), frame.get());
 253   EXPECT_EQ(1u, gles2_->gen_textures);
 254 }
 255
 256 // AllocateGpuMemoryBuffer can return null (e.g: when the GPU process is down).
 257 // This test checks that in that case we don't crash and still create the
 258 // textures.
 259 TEST_F(GpuMemoryBufferVideoFramePoolTest, AllocateGpuMemoryBufferBFail) {
 260   scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10);
 261   scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories(
 262       new MockGpuVideoAcceleratorFactories);
 263   mock_gpu_factories->SetFailToAllocateGpuMemoryBufferForTesting(true);
 264   scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ =
 265       make_scoped_ptr(new GpuMemoryBufferVideoFramePool(
 266           media_task_runner_, copy_task_runner_.get(), mock_gpu_factories));
 267
 268   EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface())
 269       .WillRepeatedly(testing::Return(gles2_.get()));
 270
 271   scoped_refptr<VideoFrame> frame;
 272   gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(
 273       software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame));
 274
 275   RunUntilIdle();
 276
 277   EXPECT_NE(software_frame.get(), frame.get());
 278   EXPECT_EQ(3u, gles2_->gen_textures);
 279 }
 280
 281 }  // namespace media