OLD | NEW |
1 // Copyright 2012 The Chromium Authors. All rights reserved. | 1 // Copyright 2012 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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "base/message_loop/message_loop.h" | 9 #include "base/message_loop/message_loop.h" |
10 #include "base/strings/string_split.h" | |
11 #include "cc/base/math_util.h" | 10 #include "cc/base/math_util.h" |
12 #include "cc/output/gl_renderer.h" | 11 #include "cc/output/gl_renderer.h" |
13 #include "cc/quads/draw_quad.h" | 12 #include "cc/quads/draw_quad.h" |
14 #include "cc/quads/picture_draw_quad.h" | 13 #include "cc/quads/picture_draw_quad.h" |
15 #include "cc/quads/texture_draw_quad.h" | 14 #include "cc/quads/texture_draw_quad.h" |
16 #include "cc/resources/video_resource_updater.h" | 15 #include "cc/resources/video_resource_updater.h" |
17 #include "cc/test/fake_raster_source.h" | 16 #include "cc/test/fake_raster_source.h" |
18 #include "cc/test/fake_recording_source.h" | 17 #include "cc/test/fake_recording_source.h" |
19 #include "cc/test/pixel_test.h" | 18 #include "cc/test/pixel_test.h" |
20 #include "cc/test/test_in_process_context_provider.h" | |
21 #include "gpu/command_buffer/client/gles2_interface.h" | 19 #include "gpu/command_buffer/client/gles2_interface.h" |
22 #include "media/base/video_frame.h" | 20 #include "media/base/video_frame.h" |
23 #include "third_party/skia/include/core/SkColorPriv.h" | 21 #include "third_party/skia/include/core/SkColorPriv.h" |
24 #include "third_party/skia/include/core/SkImageFilter.h" | 22 #include "third_party/skia/include/core/SkImageFilter.h" |
25 #include "third_party/skia/include/core/SkMatrix.h" | 23 #include "third_party/skia/include/core/SkMatrix.h" |
26 #include "third_party/skia/include/core/SkRefCnt.h" | 24 #include "third_party/skia/include/core/SkRefCnt.h" |
27 #include "third_party/skia/include/core/SkSurface.h" | 25 #include "third_party/skia/include/core/SkSurface.h" |
28 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" | 26 #include "third_party/skia/include/effects/SkColorFilterImageFilter.h" |
29 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" | 27 #include "third_party/skia/include/effects/SkColorMatrixFilter.h" |
30 #include "ui/gfx/geometry/rect_conversions.h" | 28 #include "ui/gfx/geometry/rect_conversions.h" |
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
212 gfx::ColorSpace video_color_space = video_frame->ColorSpace(); | 210 gfx::ColorSpace video_color_space = video_frame->ColorSpace(); |
213 | 211 |
214 const gfx::Rect opaque_rect(0, 0, 0, 0); | 212 const gfx::Rect opaque_rect(0, 0, 0, 0); |
215 | 213 |
216 if (with_alpha) { | 214 if (with_alpha) { |
217 memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value, | 215 memset(video_frame->data(media::VideoFrame::kAPlane), alpha_value, |
218 video_frame->stride(media::VideoFrame::kAPlane) * | 216 video_frame->stride(media::VideoFrame::kAPlane) * |
219 video_frame->rows(media::VideoFrame::kAPlane)); | 217 video_frame->rows(media::VideoFrame::kAPlane)); |
220 } | 218 } |
221 | 219 |
222 VideoFrameExternalResources external_resources = | 220 VideoFrameExternalResources resources = |
223 video_resource_updater->CreateExternalResourcesFromVideoFrame( | 221 video_resource_updater->CreateExternalResourcesFromVideoFrame( |
224 video_frame); | 222 video_frame); |
225 | 223 |
226 ResourceProvider::ResourceIdArray resource_ids; | 224 EXPECT_EQ(VideoFrameExternalResources::YUV_RESOURCE, resources.type); |
227 resource_ids.reserve(external_resources.mailboxes.size()); | 225 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), |
228 for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) { | 226 resources.mailboxes.size()); |
229 ResourceId resource_id = | 227 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), |
230 resource_provider->CreateResourceFromTextureMailbox( | 228 resources.release_callbacks.size()); |
231 external_resources.mailboxes[i], | 229 |
232 SingleReleaseCallbackImpl::Create( | 230 ResourceId y_resource = resource_provider->CreateResourceFromTextureMailbox( |
233 external_resources.release_callbacks[i]), | 231 resources.mailboxes[media::VideoFrame::kYPlane], |
234 external_resources.read_lock_fences_enabled); | 232 SingleReleaseCallbackImpl::Create( |
235 resource_ids.push_back(resource_id); | 233 resources.release_callbacks[media::VideoFrame::kYPlane])); |
| 234 ResourceId u_resource = resource_provider->CreateResourceFromTextureMailbox( |
| 235 resources.mailboxes[media::VideoFrame::kUPlane], |
| 236 SingleReleaseCallbackImpl::Create( |
| 237 resources.release_callbacks[media::VideoFrame::kUPlane])); |
| 238 ResourceId v_resource = resource_provider->CreateResourceFromTextureMailbox( |
| 239 resources.mailboxes[media::VideoFrame::kVPlane], |
| 240 SingleReleaseCallbackImpl::Create( |
| 241 resources.release_callbacks[media::VideoFrame::kVPlane])); |
| 242 ResourceId a_resource = 0; |
| 243 if (with_alpha) { |
| 244 a_resource = resource_provider->CreateResourceFromTextureMailbox( |
| 245 resources.mailboxes[media::VideoFrame::kAPlane], |
| 246 SingleReleaseCallbackImpl::Create( |
| 247 resources.release_callbacks[media::VideoFrame::kAPlane])); |
236 } | 248 } |
237 | 249 |
238 switch (external_resources.type) { | 250 const gfx::Size ya_tex_size = video_frame->coded_size(); |
239 case VideoFrameExternalResources::YUV_RESOURCE: { | 251 const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize( |
240 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), | 252 video_frame->format(), media::VideoFrame::kUPlane, |
241 external_resources.mailboxes.size()); | 253 video_frame->coded_size()); |
242 EXPECT_EQ(media::VideoFrame::NumPlanes(video_frame->format()), | 254 DCHECK(uv_tex_size == media::VideoFrame::PlaneSize( |
243 external_resources.release_callbacks.size()); | 255 video_frame->format(), media::VideoFrame::kVPlane, |
244 const gfx::Size ya_tex_size = video_frame->coded_size(); | 256 video_frame->coded_size())); |
245 const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize( | 257 if (with_alpha) { |
246 video_frame->format(), media::VideoFrame::kUPlane, | 258 DCHECK(ya_tex_size == media::VideoFrame::PlaneSize( |
247 video_frame->coded_size()); | 259 video_frame->format(), media::VideoFrame::kAPlane, |
248 DCHECK(uv_tex_size == | 260 video_frame->coded_size())); |
249 media::VideoFrame::PlaneSize(video_frame->format(), | 261 } |
250 media::VideoFrame::kVPlane, | |
251 video_frame->coded_size())); | |
252 if (with_alpha) { | |
253 DCHECK(ya_tex_size == | |
254 media::VideoFrame::PlaneSize(video_frame->format(), | |
255 media::VideoFrame::kAPlane, | |
256 video_frame->coded_size())); | |
257 } | |
258 gfx::RectF ya_tex_coord_rect( | |
259 tex_coord_rect.x() * ya_tex_size.width(), | |
260 tex_coord_rect.y() * ya_tex_size.height(), | |
261 tex_coord_rect.width() * ya_tex_size.width(), | |
262 tex_coord_rect.height() * ya_tex_size.height()); | |
263 gfx::RectF uv_tex_coord_rect( | |
264 tex_coord_rect.x() * uv_tex_size.width(), | |
265 tex_coord_rect.y() * uv_tex_size.height(), | |
266 tex_coord_rect.width() * uv_tex_size.width(), | |
267 tex_coord_rect.height() * uv_tex_size.height()); | |
268 | 262 |
269 YUVVideoDrawQuad* yuv_quad = | 263 gfx::RectF ya_tex_coord_rect(tex_coord_rect.x() * ya_tex_size.width(), |
270 render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); | 264 tex_coord_rect.y() * ya_tex_size.height(), |
271 yuv_quad->SetNew( | 265 tex_coord_rect.width() * ya_tex_size.width(), |
272 shared_state, rect, opaque_rect, visible_rect, ya_tex_coord_rect, | 266 tex_coord_rect.height() * ya_tex_size.height()); |
273 uv_tex_coord_rect, ya_tex_size, uv_tex_size, resource_ids[0], | 267 gfx::RectF uv_tex_coord_rect(tex_coord_rect.x() * uv_tex_size.width(), |
274 resource_ids[1], | 268 tex_coord_rect.y() * uv_tex_size.height(), |
275 resource_ids.size() > 2 ? resource_ids[2] : resource_ids[1], | 269 tex_coord_rect.width() * uv_tex_size.width(), |
276 resource_ids.size() > 3 ? resource_ids[3] : 0, color_space, | 270 tex_coord_rect.height() * uv_tex_size.height()); |
277 video_color_space, external_resources.offset, | 271 |
278 external_resources.multiplier, external_resources.bits_per_channel); | 272 YUVVideoDrawQuad* yuv_quad = |
279 break; | 273 render_pass->CreateAndAppendDrawQuad<YUVVideoDrawQuad>(); |
280 } | 274 uint32_t bits_per_channel = 8; |
281 case VideoFrameExternalResources::RGBA_RESOURCE: { | 275 if (video_frame->format() == media::PIXEL_FORMAT_YUV420P10 || |
282 EXPECT_EQ(1u, external_resources.mailboxes.size()); | 276 video_frame->format() == media::PIXEL_FORMAT_YUV422P10 || |
283 EXPECT_EQ(1u, external_resources.release_callbacks.size()); | 277 video_frame->format() == media::PIXEL_FORMAT_YUV444P10) { |
284 float opacity[] = {1.0f, 1.0f, 1.0f, 1.0f}; | 278 bits_per_channel = 10; |
285 TextureDrawQuad* texture_quad = | |
286 render_pass->CreateAndAppendDrawQuad<TextureDrawQuad>(); | |
287 texture_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, | |
288 resource_ids[0], false, tex_coord_rect.origin(), | |
289 tex_coord_rect.bottom_right(), SK_ColorTRANSPARENT, | |
290 opacity, false, false, false); | |
291 break; | |
292 } | |
293 case VideoFrameExternalResources::NONE: | |
294 case VideoFrameExternalResources::RGB_RESOURCE: | |
295 case VideoFrameExternalResources::RGBA_PREMULTIPLIED_RESOURCE: | |
296 case VideoFrameExternalResources::STREAM_TEXTURE_RESOURCE: | |
297 case VideoFrameExternalResources::SOFTWARE_RESOURCE: | |
298 NOTREACHED(); | |
299 break; | |
300 } | 279 } |
| 280 |
| 281 yuv_quad->SetNew(shared_state, rect, opaque_rect, visible_rect, |
| 282 ya_tex_coord_rect, uv_tex_coord_rect, ya_tex_size, |
| 283 uv_tex_size, y_resource, u_resource, v_resource, a_resource, |
| 284 color_space, video_color_space, 0.0f, 1.0f, |
| 285 bits_per_channel); |
301 } | 286 } |
302 | 287 |
303 // Upshift video frame to 10 bit. | 288 // Upshift video frame to 10 bit. |
304 scoped_refptr<media::VideoFrame> CreateHighbitVideoFrame( | 289 scoped_refptr<media::VideoFrame> CreateHighbitVideoFrame( |
305 media::VideoFrame* video_frame) { | 290 media::VideoFrame* video_frame) { |
306 media::VideoPixelFormat format; | 291 media::VideoPixelFormat format; |
307 switch (video_frame->format()) { | 292 switch (video_frame->format()) { |
308 case media::PIXEL_FORMAT_I420: | 293 case media::PIXEL_FORMAT_I420: |
309 case media::PIXEL_FORMAT_YV12: | 294 case media::PIXEL_FORMAT_YV12: |
310 format = media::PIXEL_FORMAT_YUV420P10; | 295 format = media::PIXEL_FORMAT_YUV420P10; |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
351 bool is_transparent, | 336 bool is_transparent, |
352 bool highbit, | 337 bool highbit, |
353 const gfx::RectF& tex_coord_rect, | 338 const gfx::RectF& tex_coord_rect, |
354 RenderPass* render_pass, | 339 RenderPass* render_pass, |
355 VideoResourceUpdater* video_resource_updater, | 340 VideoResourceUpdater* video_resource_updater, |
356 const gfx::Rect& rect, | 341 const gfx::Rect& rect, |
357 const gfx::Rect& visible_rect, | 342 const gfx::Rect& visible_rect, |
358 ResourceProvider* resource_provider) { | 343 ResourceProvider* resource_provider) { |
359 scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame( | 344 scoped_refptr<media::VideoFrame> video_frame = media::VideoFrame::CreateFrame( |
360 format, rect.size(), rect, rect.size(), base::TimeDelta()); | 345 format, rect.size(), rect, rect.size(), base::TimeDelta()); |
361 video_frame->metadata()->SetInteger(media::VideoFrameMetadata::COLOR_SPACE, | |
362 media::COLOR_SPACE_JPEG); | |
363 | 346 |
364 // YUV values representing a striped pattern, for validating texture | 347 // YUV values representing a striped pattern, for validating texture |
365 // coordinates for sampling. | 348 // coordinates for sampling. |
366 uint8_t y_value = 0; | 349 uint8_t y_value = 0; |
367 uint8_t u_value = 0; | 350 uint8_t u_value = 0; |
368 uint8_t v_value = 0; | 351 uint8_t v_value = 0; |
369 for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { | 352 for (int i = 0; i < video_frame->rows(media::VideoFrame::kYPlane); ++i) { |
370 uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + | 353 uint8_t* y_row = video_frame->data(media::VideoFrame::kYPlane) + |
371 video_frame->stride(media::VideoFrame::kYPlane) * i; | 354 video_frame->stride(media::VideoFrame::kYPlane) * i; |
372 for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); | 355 for (int j = 0; j < video_frame->row_bytes(media::VideoFrame::kYPlane); |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
496 | 479 |
497 uint8_t alpha_value = is_transparent ? 0 : 128; | 480 uint8_t alpha_value = is_transparent ? 0 : 128; |
498 CreateTestYUVVideoDrawQuad_FromVideoFrame( | 481 CreateTestYUVVideoDrawQuad_FromVideoFrame( |
499 shared_state, video_frame, alpha_value, tex_coord_rect, render_pass, | 482 shared_state, video_frame, alpha_value, tex_coord_rect, render_pass, |
500 video_resource_updater, rect, visible_rect, resource_provider); | 483 video_resource_updater, rect, visible_rect, resource_provider); |
501 } | 484 } |
502 | 485 |
503 void CreateTestYUVVideoDrawQuad_NV12(const SharedQuadState* shared_state, | 486 void CreateTestYUVVideoDrawQuad_NV12(const SharedQuadState* shared_state, |
504 media::ColorSpace video_frame_color_space, | 487 media::ColorSpace video_frame_color_space, |
505 const gfx::ColorSpace& video_color_space, | 488 const gfx::ColorSpace& video_color_space, |
506 ResourceFormat y_format, | |
507 const gfx::RectF& tex_coord_rect, | 489 const gfx::RectF& tex_coord_rect, |
508 uint8_t y, | 490 uint8_t y, |
509 uint8_t u, | 491 uint8_t u, |
510 uint8_t v, | 492 uint8_t v, |
511 RenderPass* render_pass, | 493 RenderPass* render_pass, |
512 const gfx::Rect& rect, | 494 const gfx::Rect& rect, |
513 const gfx::Rect& visible_rect, | 495 const gfx::Rect& visible_rect, |
514 ResourceProvider* resource_provider) { | 496 ResourceProvider* resource_provider) { |
515 YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601; | 497 YUVVideoDrawQuad::ColorSpace color_space = YUVVideoDrawQuad::REC_601; |
516 if (video_frame_color_space == media::COLOR_SPACE_JPEG) { | 498 if (video_frame_color_space == media::COLOR_SPACE_JPEG) { |
517 color_space = YUVVideoDrawQuad::JPEG; | 499 color_space = YUVVideoDrawQuad::JPEG; |
518 } | 500 } |
519 | 501 |
520 const gfx::Rect opaque_rect(0, 0, 0, 0); | 502 const gfx::Rect opaque_rect(0, 0, 0, 0); |
521 const gfx::Size ya_tex_size = rect.size(); | 503 const gfx::Size ya_tex_size = rect.size(); |
522 const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize( | 504 const gfx::Size uv_tex_size = media::VideoFrame::PlaneSize( |
523 media::PIXEL_FORMAT_NV12, media::VideoFrame::kUVPlane, rect.size()); | 505 media::PIXEL_FORMAT_NV12, media::VideoFrame::kUVPlane, rect.size()); |
524 | 506 |
525 ResourceId y_resource = resource_provider->CreateResource( | 507 ResourceId y_resource = resource_provider->CreateResource( |
526 rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT, y_format, | 508 rect.size(), ResourceProvider::TEXTURE_HINT_DEFAULT, |
527 gfx::ColorSpace()); | 509 resource_provider->YuvResourceFormat(8), gfx::ColorSpace()); |
528 ResourceId u_resource = resource_provider->CreateResource( | 510 ResourceId u_resource = resource_provider->CreateResource( |
529 uv_tex_size, ResourceProvider::TEXTURE_HINT_DEFAULT, RGBA_8888, | 511 uv_tex_size, ResourceProvider::TEXTURE_HINT_DEFAULT, RGBA_8888, |
530 gfx::ColorSpace()); | 512 gfx::ColorSpace()); |
531 ResourceId v_resource = u_resource; | 513 ResourceId v_resource = u_resource; |
532 ResourceId a_resource = 0; | 514 ResourceId a_resource = 0; |
533 | 515 |
534 std::vector<uint8_t> y_pixels(ya_tex_size.GetArea(), y); | 516 std::vector<uint8_t> y_pixels(ya_tex_size.GetArea(), y); |
535 resource_provider->CopyToResource(y_resource, y_pixels.data(), ya_tex_size); | 517 resource_provider->CopyToResource(y_resource, y_pixels.data(), ya_tex_size); |
536 | 518 |
537 // U goes in the R component and V goes in the G component. | 519 // U goes in the R component and V goes in the G component. |
(...skipping 567 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1105 resource_provider_.get()); | 1087 resource_provider_.get()); |
1106 pass_list->push_back(std::move(pass)); | 1088 pass_list->push_back(std::move(pass)); |
1107 } | 1089 } |
1108 | 1090 |
1109 void SetUp() override { | 1091 void SetUp() override { |
1110 GLRendererPixelTest::SetUp(); | 1092 GLRendererPixelTest::SetUp(); |
1111 video_resource_updater_.reset(new VideoResourceUpdater( | 1093 video_resource_updater_.reset(new VideoResourceUpdater( |
1112 output_surface_->context_provider(), resource_provider_.get())); | 1094 output_surface_->context_provider(), resource_provider_.get())); |
1113 } | 1095 } |
1114 | 1096 |
1115 void DisableOneComponentTextures() { | |
1116 TestInProcessContextProvider* context_provider = | |
1117 GetTestInProcessContextProvider(); | |
1118 context_provider->SetDisableOneComponentTextures(true); | |
1119 } | |
1120 | |
1121 std::unique_ptr<VideoResourceUpdater> video_resource_updater_; | 1097 std::unique_ptr<VideoResourceUpdater> video_resource_updater_; |
1122 | |
1123 protected: | |
1124 TestInProcessContextProvider* GetTestInProcessContextProvider() { | |
1125 return static_cast<TestInProcessContextProvider*>( | |
1126 output_surface_->context_provider()); | |
1127 } | |
1128 }; | |
1129 | |
1130 enum class HighbitTexture { | |
1131 Y8, | |
1132 RGBA_8888, | |
1133 LUMINANCE_F16, // need --use-gpu-in-tests | |
1134 }; | 1098 }; |
1135 | 1099 |
1136 class VideoGLRendererPixelHiLoTest | 1100 class VideoGLRendererPixelHiLoTest |
1137 : public VideoGLRendererPixelTest, | 1101 : public VideoGLRendererPixelTest, |
1138 public ::testing::WithParamInterface< | 1102 public ::testing::WithParamInterface<bool> {}; |
1139 ::testing::tuple<bool, HighbitTexture>> { | |
1140 public: | |
1141 void SetSupportHighbitTexture(HighbitTexture texture) { | |
1142 TestInProcessContextProvider* context_provider = | |
1143 GetTestInProcessContextProvider(); | |
1144 switch (texture) { | |
1145 case HighbitTexture::Y8: | |
1146 context_provider->SetDisableOneComponentTextures(false); | |
1147 context_provider->SetSupportTextureHalfFloatLinear(false); | |
1148 break; | |
1149 case HighbitTexture::RGBA_8888: | |
1150 context_provider->SetDisableOneComponentTextures(true); | |
1151 context_provider->SetSupportTextureHalfFloatLinear(false); | |
1152 break; | |
1153 case HighbitTexture::LUMINANCE_F16: | |
1154 context_provider->SetDisableOneComponentTextures(false); | |
1155 context_provider->SetSupportTextureHalfFloatLinear(true); | |
1156 break; | |
1157 } | |
1158 } | |
1159 | |
1160 bool IsHalfFloatLinearSupported() { | |
1161 if (extensions_.empty()) | |
1162 InitializeExtensions(); | |
1163 | |
1164 return extensions_.find("GL_OES_texture_half_float_linear") != | |
1165 extensions_.end(); | |
1166 } | |
1167 | |
1168 private: | |
1169 void InitializeExtensions() { | |
1170 std::string extensions = GetTestInProcessContextProvider() | |
1171 ->ContextGL() | |
1172 ->GetRequestableExtensionsCHROMIUM(); | |
1173 std::vector<std::string> tokens = base::SplitString( | |
1174 extensions, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY); | |
1175 extensions_.insert(tokens.begin(), tokens.end()); | |
1176 } | |
1177 | |
1178 std::set<std::string> extensions_; | |
1179 }; | |
1180 | 1103 |
1181 TEST_P(VideoGLRendererPixelHiLoTest, SimpleYUVRect) { | 1104 TEST_P(VideoGLRendererPixelHiLoTest, SimpleYUVRect) { |
1182 gfx::Rect rect(this->device_viewport_size_); | 1105 gfx::Rect rect(this->device_viewport_size_); |
1183 | 1106 |
1184 RenderPassId id(1, 1); | 1107 RenderPassId id(1, 1); |
1185 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1108 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1186 | 1109 |
1187 SharedQuadState* shared_state = | 1110 SharedQuadState* shared_state = |
1188 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1111 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1189 | 1112 |
1190 const bool highbit = testing::get<0>(GetParam()); | 1113 bool highbit = GetParam(); |
1191 const HighbitTexture format = testing::get<1>(GetParam()); | |
1192 if (format == HighbitTexture::LUMINANCE_F16 && !IsHalfFloatLinearSupported()) | |
1193 return; | |
1194 | |
1195 SetSupportHighbitTexture(format); | |
1196 CreateTestYUVVideoDrawQuad_Striped( | 1114 CreateTestYUVVideoDrawQuad_Striped( |
1197 shared_state, media::PIXEL_FORMAT_YV12, false, highbit, | 1115 shared_state, media::PIXEL_FORMAT_YV12, false, highbit, |
1198 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(), | 1116 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(), |
1199 video_resource_updater_.get(), rect, rect, resource_provider_.get()); | 1117 video_resource_updater_.get(), rect, rect, resource_provider_.get()); |
1200 | 1118 |
1201 RenderPassList pass_list; | 1119 RenderPassList pass_list; |
1202 pass_list.push_back(std::move(pass)); | 1120 pass_list.push_back(std::move(pass)); |
1203 | 1121 |
1204 base::FilePath file_path = | 1122 EXPECT_TRUE( |
1205 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")); | 1123 this->RunPixelTest(&pass_list, |
1206 // TODO(dshwang): investigate why results per configuraion are so different. | 1124 base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), |
1207 // crbug.com/622133 | 1125 FuzzyPixelOffByOneComparator(true))); |
1208 if (format == HighbitTexture::RGBA_8888) { | |
1209 // Color space is so different, because this path doesn't respect video | |
1210 // color profile. | |
1211 file_path = base::FilePath(FILE_PATH_LITERAL("yuv_stripes_rgba.png")); | |
1212 } | |
1213 EXPECT_TRUE(this->RunPixelTest( | |
1214 &pass_list, file_path, | |
1215 // All pixels can be off by two, but any more than that is an error. | |
1216 FuzzyPixelComparator(true, 100.f, 0.f, 2.f, 2, 0))); | |
1217 } | 1126 } |
1218 | 1127 |
1219 TEST_P(VideoGLRendererPixelHiLoTest, ClippedYUVRect) { | 1128 TEST_P(VideoGLRendererPixelHiLoTest, ClippedYUVRect) { |
1220 gfx::Rect viewport(this->device_viewport_size_); | 1129 gfx::Rect viewport(this->device_viewport_size_); |
1221 gfx::Rect draw_rect(this->device_viewport_size_.width() * 1.5, | 1130 gfx::Rect draw_rect(this->device_viewport_size_.width() * 1.5, |
1222 this->device_viewport_size_.height() * 1.5); | 1131 this->device_viewport_size_.height() * 1.5); |
1223 | 1132 |
1224 RenderPassId id(1, 1); | 1133 RenderPassId id(1, 1); |
1225 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, viewport); | 1134 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, viewport); |
1226 | 1135 |
1227 SharedQuadState* shared_state = | 1136 SharedQuadState* shared_state = |
1228 CreateTestSharedQuadState(gfx::Transform(), viewport, pass.get()); | 1137 CreateTestSharedQuadState(gfx::Transform(), viewport, pass.get()); |
1229 | 1138 |
1230 const bool highbit = testing::get<0>(GetParam()); | 1139 bool highbit = GetParam(); |
1231 const HighbitTexture format = testing::get<1>(GetParam()); | |
1232 if (format == HighbitTexture::LUMINANCE_F16 && !IsHalfFloatLinearSupported()) | |
1233 return; | |
1234 | |
1235 SetSupportHighbitTexture(format); | |
1236 CreateTestYUVVideoDrawQuad_Striped( | 1140 CreateTestYUVVideoDrawQuad_Striped( |
1237 shared_state, media::PIXEL_FORMAT_YV12, false, highbit, | 1141 shared_state, media::PIXEL_FORMAT_YV12, false, highbit, |
1238 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(), | 1142 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), pass.get(), |
1239 video_resource_updater_.get(), draw_rect, viewport, | 1143 video_resource_updater_.get(), draw_rect, viewport, |
1240 resource_provider_.get()); | 1144 resource_provider_.get()); |
1241 RenderPassList pass_list; | 1145 RenderPassList pass_list; |
1242 pass_list.push_back(std::move(pass)); | 1146 pass_list.push_back(std::move(pass)); |
1243 | 1147 |
1244 base::FilePath file_path = | |
1245 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png")); | |
1246 if (format == HighbitTexture::RGBA_8888) { | |
1247 file_path = | |
1248 base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped_rgba.png")); | |
1249 } | |
1250 EXPECT_TRUE(this->RunPixelTest( | 1148 EXPECT_TRUE(this->RunPixelTest( |
1251 &pass_list, file_path, | 1149 &pass_list, base::FilePath(FILE_PATH_LITERAL("yuv_stripes_clipped.png")), |
1252 // All pixels can be off by two, but any more than that is an error. | 1150 FuzzyPixelOffByOneComparator(true))); |
1253 FuzzyPixelComparator(true, 100.f, 0.f, 2.f, 2, 0))); | |
1254 } | 1151 } |
1255 | 1152 |
1256 TEST_F(VideoGLRendererPixelHiLoTest, OffsetYUVRect) { | 1153 TEST_F(VideoGLRendererPixelHiLoTest, OffsetYUVRect) { |
1257 gfx::Rect rect(this->device_viewport_size_); | 1154 gfx::Rect rect(this->device_viewport_size_); |
1258 | 1155 |
1259 RenderPassId id(1, 1); | 1156 RenderPassId id(1, 1); |
1260 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1157 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1261 | 1158 |
1262 SharedQuadState* shared_state = | 1159 SharedQuadState* shared_state = |
1263 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1160 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1295 pass_list.push_back(std::move(pass)); | 1192 pass_list.push_back(std::move(pass)); |
1296 | 1193 |
1297 // If we didn't get black out of the YUV values above, then we probably have a | 1194 // If we didn't get black out of the YUV values above, then we probably have a |
1298 // color range issue. | 1195 // color range issue. |
1299 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 1196 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
1300 base::FilePath(FILE_PATH_LITERAL("black.png")), | 1197 base::FilePath(FILE_PATH_LITERAL("black.png")), |
1301 FuzzyPixelOffByOneComparator(true))); | 1198 FuzzyPixelOffByOneComparator(true))); |
1302 } | 1199 } |
1303 | 1200 |
1304 // First argument (test case prefix) is intentionally left empty. | 1201 // First argument (test case prefix) is intentionally left empty. |
1305 INSTANTIATE_TEST_CASE_P( | 1202 INSTANTIATE_TEST_CASE_P(, VideoGLRendererPixelHiLoTest, ::testing::Bool()); |
1306 , | |
1307 VideoGLRendererPixelHiLoTest, | |
1308 ::testing::Combine(::testing::Bool(), | |
1309 ::testing::Values(HighbitTexture::Y8, | |
1310 HighbitTexture::LUMINANCE_F16, | |
1311 HighbitTexture::RGBA_8888))); | |
1312 | 1203 |
1313 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { | 1204 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { |
1314 gfx::Rect rect(this->device_viewport_size_); | 1205 gfx::Rect rect(this->device_viewport_size_); |
1315 | 1206 |
1316 RenderPassId id(1, 1); | 1207 RenderPassId id(1, 1); |
1317 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1208 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1318 | 1209 |
1319 SharedQuadState* shared_state = | 1210 SharedQuadState* shared_state = |
1320 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1211 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1321 | 1212 |
(...skipping 13 matching lines...) Expand all Loading... |
1335 | 1226 |
1336 TEST_F(VideoGLRendererPixelTest, SimpleNV12JRect) { | 1227 TEST_F(VideoGLRendererPixelTest, SimpleNV12JRect) { |
1337 gfx::Rect rect(this->device_viewport_size_); | 1228 gfx::Rect rect(this->device_viewport_size_); |
1338 | 1229 |
1339 RenderPassId id(1, 1); | 1230 RenderPassId id(1, 1); |
1340 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1231 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1341 | 1232 |
1342 SharedQuadState* shared_state = | 1233 SharedQuadState* shared_state = |
1343 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | 1234 CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); |
1344 | 1235 |
1345 ResourceFormat y_format = video_resource_updater_->YuvResourceFormat(8); | |
1346 | |
1347 // YUV of (149,43,21) should be green (0,255,0) in RGB. | 1236 // YUV of (149,43,21) should be green (0,255,0) in RGB. |
1348 CreateTestYUVVideoDrawQuad_NV12( | 1237 CreateTestYUVVideoDrawQuad_NV12( |
1349 shared_state, media::COLOR_SPACE_JPEG, gfx::ColorSpace::CreateJpeg(), | 1238 shared_state, media::COLOR_SPACE_JPEG, gfx::ColorSpace::CreateJpeg(), |
1350 y_format, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), | 1239 gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), rect, rect, |
1351 rect, rect, resource_provider_.get()); | 1240 resource_provider_.get()); |
1352 | 1241 |
1353 RenderPassList pass_list; | 1242 RenderPassList pass_list; |
1354 pass_list.push_back(std::move(pass)); | 1243 pass_list.push_back(std::move(pass)); |
1355 | 1244 |
1356 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 1245 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
1357 base::FilePath(FILE_PATH_LITERAL("green.png")), | 1246 base::FilePath(FILE_PATH_LITERAL("green.png")), |
1358 FuzzyPixelOffByOneComparator(true))); | 1247 FuzzyPixelOffByOneComparator(true))); |
1359 } | 1248 } |
1360 | 1249 |
1361 // Test that a YUV video doesn't bleed outside of its tex coords when the | 1250 // Test that a YUV video doesn't bleed outside of its tex coords when the |
1362 // tex coord rect is only a partial subrectangle of the coded contents. | 1251 // tex coord rect is only a partial subrectangle of the coded contents. |
1363 TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) { | 1252 TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) { |
1364 RenderPassList pass_list; | 1253 RenderPassList pass_list; |
1365 CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG, | 1254 CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG, |
1366 &pass_list); | 1255 &pass_list); |
1367 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 1256 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
1368 base::FilePath(FILE_PATH_LITERAL("green.png")), | 1257 base::FilePath(FILE_PATH_LITERAL("green.png")), |
1369 FuzzyPixelOffByOneComparator(true))); | 1258 FuzzyPixelOffByOneComparator(true))); |
1370 } | 1259 } |
1371 | 1260 |
1372 TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) { | 1261 TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) { |
1373 RenderPassList pass_list; | 1262 RenderPassList pass_list; |
1374 CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12A, media::COLOR_SPACE_UNSPECIFIED, | 1263 CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12A, media::COLOR_SPACE_UNSPECIFIED, |
1375 &pass_list); | 1264 &pass_list); |
1376 EXPECT_TRUE(this->RunPixelTest(&pass_list, | 1265 EXPECT_TRUE(this->RunPixelTest(&pass_list, |
1377 base::FilePath(FILE_PATH_LITERAL("green.png")), | 1266 base::FilePath(FILE_PATH_LITERAL("green.png")), |
1378 FuzzyPixelOffByOneComparator(true))); | |
1379 } | |
1380 | |
1381 TEST_F(VideoGLRendererPixelTest, TextureQuadEdgeBleed) { | |
1382 // VideoResourceUpdater::CreateForSoftwarePlanes() converts YUV frame to RGBA | |
1383 // texture. | |
1384 DisableOneComponentTextures(); | |
1385 RenderPassList pass_list; | |
1386 CreateEdgeBleedPass(media::PIXEL_FORMAT_YV12, media::COLOR_SPACE_JPEG, | |
1387 &pass_list); | |
1388 EXPECT_TRUE(this->RunPixelTest(&pass_list, | |
1389 base::FilePath(FILE_PATH_LITERAL("green.png")), | |
1390 FuzzyPixelOffByOneComparator(true))); | 1267 FuzzyPixelOffByOneComparator(true))); |
1391 } | 1268 } |
1392 | 1269 |
1393 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { | 1270 TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { |
1394 gfx::Rect rect(this->device_viewport_size_); | 1271 gfx::Rect rect(this->device_viewport_size_); |
1395 | 1272 |
1396 RenderPassId id(1, 1); | 1273 RenderPassId id(1, 1); |
1397 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | 1274 std::unique_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); |
1398 | 1275 |
1399 SharedQuadState* shared_state = | 1276 SharedQuadState* shared_state = |
(...skipping 1870 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3270 | 3147 |
3271 EXPECT_TRUE(this->RunPixelTest( | 3148 EXPECT_TRUE(this->RunPixelTest( |
3272 &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")), | 3149 &pass_list, base::FilePath(FILE_PATH_LITERAL("spiral.png")), |
3273 FuzzyPixelOffByOneComparator(true))); | 3150 FuzzyPixelOffByOneComparator(true))); |
3274 } | 3151 } |
3275 | 3152 |
3276 #endif // !defined(OS_ANDROID) | 3153 #endif // !defined(OS_ANDROID) |
3277 | 3154 |
3278 } // namespace | 3155 } // namespace |
3279 } // namespace cc | 3156 } // namespace cc |
OLD | NEW |