Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(441)

Side by Side Diff: cc/output/renderer_pixeltest.cc

Issue 2463103002: Revert of Fix HTML5 video blurry (Closed)
Patch Set: Created 4 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/output/gl_renderer_draw_cache.h ('k') | cc/output/shader.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
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
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
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
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
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
OLDNEW
« no previous file with comments | « cc/output/gl_renderer_draw_cache.h ('k') | cc/output/shader.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698