OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/message_loop/message_loop.h" | 5 #include "base/bind.h" |
6 #include "base/run_loop.h" | 6 #include "base/test/test_simple_task_runner.h" |
7 #include "gpu/command_buffer/client/gles2_interface_stub.h" | 7 #include "gpu/command_buffer/client/gles2_interface_stub.h" |
8 #include "media/base/video_frame.h" | 8 #include "media/base/video_frame.h" |
9 #include "media/renderers/mock_gpu_video_accelerator_factories.h" | 9 #include "media/renderers/mock_gpu_video_accelerator_factories.h" |
10 #include "media/video/gpu_memory_buffer_video_frame_pool.h" | 10 #include "media/video/gpu_memory_buffer_video_frame_pool.h" |
11 #include "testing/gmock/include/gmock/gmock.h" | 11 #include "testing/gmock/include/gmock/gmock.h" |
12 | 12 |
13 namespace media { | 13 namespace media { |
14 | 14 |
15 namespace { | 15 namespace { |
16 class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub { | 16 class TestGLES2Interface : public gpu::gles2::GLES2InterfaceStub { |
(...skipping 13 matching lines...) Expand all Loading... |
30 private: | 30 private: |
31 unsigned sync_point = 0u; | 31 unsigned sync_point = 0u; |
32 unsigned mailbox = 0u; | 32 unsigned mailbox = 0u; |
33 }; | 33 }; |
34 | 34 |
35 } // unnamed namespace | 35 } // unnamed namespace |
36 | 36 |
37 class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test { | 37 class GpuMemoryBufferVideoFramePoolTest : public ::testing::Test { |
38 public: | 38 public: |
39 GpuMemoryBufferVideoFramePoolTest() {} | 39 GpuMemoryBufferVideoFramePoolTest() {} |
40 void SetUp() override { gles2_.reset(new TestGLES2Interface); } | 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 } |
41 | 45 |
42 void TearDown() override { base::RunLoop().RunUntilIdle(); } | 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 } |
43 | 53 |
44 static scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame( | 54 static scoped_refptr<media::VideoFrame> CreateTestYUVVideoFrame( |
45 int dimension) { | 55 int dimension) { |
46 const int kDimension = 10; | 56 const int kDimension = 10; |
47 static uint8 y_data[kDimension * kDimension] = {0}; | 57 static uint8 y_data[kDimension * kDimension] = {0}; |
48 static uint8 u_data[kDimension * kDimension / 2] = {0}; | 58 static uint8 u_data[kDimension * kDimension / 2] = {0}; |
49 static uint8 v_data[kDimension * kDimension / 2] = {0}; | 59 static uint8 v_data[kDimension * kDimension / 2] = {0}; |
50 | 60 |
51 DCHECK_LE(dimension, kDimension); | 61 DCHECK_LE(dimension, kDimension); |
52 gfx::Size size(dimension, dimension); | 62 gfx::Size size(dimension, dimension); |
53 | 63 |
54 return media::VideoFrame::WrapExternalYuvData( | 64 return media::VideoFrame::WrapExternalYuvData( |
55 media::PIXEL_FORMAT_YV12, // format | 65 media::PIXEL_FORMAT_YV12, // format |
56 size, // coded_size | 66 size, // coded_size |
57 gfx::Rect(size), // visible_rect | 67 gfx::Rect(size), // visible_rect |
58 size, // natural_size | 68 size, // natural_size |
59 size.width(), // y_stride | 69 size.width(), // y_stride |
60 size.width() / 2, // u_stride | 70 size.width() / 2, // u_stride |
61 size.width() / 2, // v_stride | 71 size.width() / 2, // v_stride |
62 y_data, // y_data | 72 y_data, // y_data |
63 u_data, // u_data | 73 u_data, // u_data |
64 v_data, // v_data | 74 v_data, // v_data |
65 base::TimeDelta()); // timestamp | 75 base::TimeDelta()); // timestamp |
66 } | 76 } |
67 | 77 |
68 protected: | 78 protected: |
69 base::MessageLoop media_message_loop_; | 79 scoped_refptr<base::TestSimpleTaskRunner> media_task_runner_; |
| 80 scoped_refptr<base::TestSimpleTaskRunner> copy_task_runner_; |
70 scoped_ptr<TestGLES2Interface> gles2_; | 81 scoped_ptr<TestGLES2Interface> gles2_; |
71 }; | 82 }; |
72 | 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 |
73 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoGpuFactoryNoHardwareVideoFrame) { | 90 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoGpuFactoryNoHardwareVideoFrame) { |
74 scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10); | 91 scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10); |
75 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = | 92 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = |
76 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( | 93 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( |
77 media_message_loop_.task_runner(), nullptr)); | 94 media_task_runner_, copy_task_runner_.get(), nullptr)); |
78 | 95 |
79 scoped_refptr<VideoFrame> frame2 = | 96 scoped_refptr<VideoFrame> frame2; |
80 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame); | 97 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 98 frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2)); |
| 99 RunUntilIdle(); |
81 EXPECT_EQ(frame.get(), frame2.get()); | 100 EXPECT_EQ(frame.get(), frame2.get()); |
82 } | 101 } |
83 | 102 |
84 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoTextureRGNoHardwareVideoFrame) { | 103 TEST_F(GpuMemoryBufferVideoFramePoolTest, NoTextureRGNoHardwareVideoFrame) { |
85 scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10); | 104 scoped_refptr<VideoFrame> frame = CreateTestYUVVideoFrame(10); |
86 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( | 105 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( |
87 new MockGpuVideoAcceleratorFactories); | 106 new MockGpuVideoAcceleratorFactories); |
88 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = | 107 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = |
89 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( | 108 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( |
90 media_message_loop_.task_runner(), mock_gpu_factories)); | 109 media_task_runner_, copy_task_runner_.get(), mock_gpu_factories)); |
91 | 110 |
92 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) | 111 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) |
93 .WillRepeatedly(testing::Return(false)); | 112 .WillRepeatedly(testing::Return(false)); |
94 scoped_refptr<VideoFrame> frame2 = | 113 scoped_refptr<VideoFrame> frame2; |
95 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(frame); | 114 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 115 frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2)); |
| 116 RunUntilIdle(); |
| 117 |
96 EXPECT_EQ(frame.get(), frame2.get()); | 118 EXPECT_EQ(frame.get(), frame2.get()); |
97 } | 119 } |
98 | 120 |
99 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareFrame) { | 121 TEST_F(GpuMemoryBufferVideoFramePoolTest, CreateOneHardwareFrame) { |
100 scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10); | 122 scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10); |
101 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( | 123 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( |
102 new MockGpuVideoAcceleratorFactories); | 124 new MockGpuVideoAcceleratorFactories); |
103 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = | 125 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = |
104 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( | 126 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( |
105 media_message_loop_.task_runner(), mock_gpu_factories)); | 127 media_task_runner_, copy_task_runner_.get(), mock_gpu_factories)); |
106 | 128 |
107 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) | 129 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) |
108 .WillRepeatedly(testing::Return(gles2_.get())); | 130 .WillRepeatedly(testing::Return(gles2_.get())); |
109 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) | 131 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) |
110 .WillRepeatedly(testing::Return(true)); | 132 .WillRepeatedly(testing::Return(true)); |
111 | 133 |
112 scoped_refptr<VideoFrame> frame = | 134 scoped_refptr<VideoFrame> frame; |
113 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame); | 135 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 136 software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame)); |
| 137 |
| 138 RunUntilIdle(); |
| 139 |
114 EXPECT_NE(software_frame.get(), frame.get()); | 140 EXPECT_NE(software_frame.get(), frame.get()); |
115 EXPECT_EQ(3u, gles2_->gen_textures); | 141 EXPECT_EQ(3u, gles2_->gen_textures); |
116 } | 142 } |
117 | 143 |
118 TEST_F(GpuMemoryBufferVideoFramePoolTest, ReuseFirstResource) { | 144 TEST_F(GpuMemoryBufferVideoFramePoolTest, ReuseFirstResource) { |
119 scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10); | 145 scoped_refptr<VideoFrame> software_frame = CreateTestYUVVideoFrame(10); |
120 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( | 146 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( |
121 new MockGpuVideoAcceleratorFactories); | 147 new MockGpuVideoAcceleratorFactories); |
122 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = | 148 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = |
123 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( | 149 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( |
124 media_message_loop_.task_runner(), mock_gpu_factories)); | 150 media_task_runner_, copy_task_runner_.get(), mock_gpu_factories)); |
125 | 151 |
126 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) | 152 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) |
127 .WillRepeatedly(testing::Return(gles2_.get())); | 153 .WillRepeatedly(testing::Return(gles2_.get())); |
128 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) | 154 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) |
129 .WillRepeatedly(testing::Return(true)); | 155 .WillRepeatedly(testing::Return(true)); |
130 | 156 |
131 scoped_refptr<VideoFrame> frame = | 157 scoped_refptr<VideoFrame> frame; |
132 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame); | 158 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 159 software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame)); |
| 160 RunUntilIdle(); |
| 161 |
133 EXPECT_NE(software_frame.get(), frame.get()); | 162 EXPECT_NE(software_frame.get(), frame.get()); |
134 gpu::Mailbox mailbox = frame->mailbox_holder(0).mailbox; | 163 gpu::Mailbox mailbox = frame->mailbox_holder(0).mailbox; |
135 unsigned sync_point = frame->mailbox_holder(0).sync_point; | 164 unsigned sync_point = frame->mailbox_holder(0).sync_point; |
136 EXPECT_EQ(3u, gles2_->gen_textures); | 165 EXPECT_EQ(3u, gles2_->gen_textures); |
137 | 166 |
138 scoped_refptr<VideoFrame> frame2 = | 167 scoped_refptr<VideoFrame> frame2; |
139 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame); | 168 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 169 software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame2)); |
| 170 RunUntilIdle(); |
| 171 |
140 EXPECT_NE(software_frame.get(), frame2.get()); | 172 EXPECT_NE(software_frame.get(), frame2.get()); |
141 EXPECT_NE(mailbox, frame2->mailbox_holder(0).mailbox); | 173 EXPECT_NE(mailbox, frame2->mailbox_holder(0).mailbox); |
142 EXPECT_EQ(6u, gles2_->gen_textures); | 174 EXPECT_EQ(6u, gles2_->gen_textures); |
143 | 175 |
144 frame = nullptr; | 176 frame = nullptr; |
145 frame2 = nullptr; | 177 frame2 = nullptr; |
146 base::RunLoop().RunUntilIdle(); // Run posted closures. | 178 RunUntilIdle(); |
147 frame = gpu_memory_buffer_pool_->MaybeCreateHardwareFrame(software_frame); | 179 |
| 180 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
| 181 software_frame, base::Bind(MaybeCreateHardwareFrameCallback, &frame)); |
| 182 RunUntilIdle(); |
| 183 |
148 EXPECT_NE(software_frame.get(), frame.get()); | 184 EXPECT_NE(software_frame.get(), frame.get()); |
149 EXPECT_EQ(6u, gles2_->gen_textures); | 185 EXPECT_EQ(6u, gles2_->gen_textures); |
150 EXPECT_EQ(frame->mailbox_holder(0).mailbox, mailbox); | 186 EXPECT_EQ(frame->mailbox_holder(0).mailbox, mailbox); |
151 EXPECT_NE(frame->mailbox_holder(0).sync_point, sync_point); | 187 EXPECT_NE(frame->mailbox_holder(0).sync_point, sync_point); |
152 } | 188 } |
153 | 189 |
154 TEST_F(GpuMemoryBufferVideoFramePoolTest, DropResourceWhenSizeIsDifferent) { | 190 TEST_F(GpuMemoryBufferVideoFramePoolTest, DropResourceWhenSizeIsDifferent) { |
155 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( | 191 scoped_refptr<MockGpuVideoAcceleratorFactories> mock_gpu_factories( |
156 new MockGpuVideoAcceleratorFactories); | 192 new MockGpuVideoAcceleratorFactories); |
157 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = | 193 scoped_ptr<GpuMemoryBufferVideoFramePool> gpu_memory_buffer_pool_ = |
158 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( | 194 make_scoped_ptr(new GpuMemoryBufferVideoFramePool( |
159 media_message_loop_.task_runner(), mock_gpu_factories)); | 195 media_task_runner_, copy_task_runner_.get(), mock_gpu_factories)); |
160 | 196 |
161 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) | 197 EXPECT_CALL(*mock_gpu_factories.get(), GetGLES2Interface()) |
162 .WillRepeatedly(testing::Return(gles2_.get())); | 198 .WillRepeatedly(testing::Return(gles2_.get())); |
163 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) | 199 EXPECT_CALL(*mock_gpu_factories.get(), IsTextureRGSupported()) |
164 .WillRepeatedly(testing::Return(true)); | 200 .WillRepeatedly(testing::Return(true)); |
165 | 201 |
166 scoped_refptr<VideoFrame> frame = | 202 scoped_refptr<VideoFrame> frame; |
167 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( | 203 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
168 CreateTestYUVVideoFrame(10)); | 204 CreateTestYUVVideoFrame(10), |
| 205 base::Bind(MaybeCreateHardwareFrameCallback, &frame)); |
| 206 RunUntilIdle(); |
| 207 |
169 EXPECT_EQ(3u, gles2_->gen_textures); | 208 EXPECT_EQ(3u, gles2_->gen_textures); |
170 | 209 |
171 frame = nullptr; | 210 frame = nullptr; |
172 base::RunLoop().RunUntilIdle(); // Run posted closures. | 211 RunUntilIdle(); |
173 frame = gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( | 212 gpu_memory_buffer_pool_->MaybeCreateHardwareFrame( |
174 CreateTestYUVVideoFrame(4)); | 213 CreateTestYUVVideoFrame(4), |
| 214 base::Bind(MaybeCreateHardwareFrameCallback, &frame)); |
| 215 RunUntilIdle(); |
175 EXPECT_EQ(6u, gles2_->gen_textures); | 216 EXPECT_EQ(6u, gles2_->gen_textures); |
176 } | 217 } |
177 | 218 |
178 } // namespace media | 219 } // namespace media |
OLD | NEW |