OLD | NEW |
| (Empty) |
1 diff a/cc/output/renderer_pixeltest.cc b/cc/output/renderer_pixeltest.cc
(rejected hunks) | |
2 @@ -902,243 +901,6 @@ TEST_F(GLRendererPixelTest, NonPremultipliedTextureWithBac
kground) { | |
3 FuzzyPixelOffByOneComparator(true))); | |
4 } | |
5 | |
6 -class VideoGLRendererPixelTest : public GLRendererPixelTest { | |
7 - protected: | |
8 - void CreateEdgeBleedPass(media::VideoFrame::Format format, | |
9 - RenderPassList* pass_list) { | |
10 - gfx::Rect rect(200, 200); | |
11 - | |
12 - RenderPassId id(1, 1); | |
13 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
14 - | |
15 - // Scale the video up so that bilinear filtering kicks in to sample more | |
16 - // than just nearest neighbor would. | |
17 - gfx::Transform scale_by_2; | |
18 - scale_by_2.Scale(2.f, 2.f); | |
19 - gfx::Rect half_rect(100, 100); | |
20 - SharedQuadState* shared_state = | |
21 - CreateTestSharedQuadState(scale_by_2, half_rect, pass.get()); | |
22 - | |
23 - gfx::Size background_size(200, 200); | |
24 - gfx::Rect green_rect(16, 20, 100, 100); | |
25 - gfx::RectF tex_coord_rect( | |
26 - static_cast<float>(green_rect.x()) / background_size.width(), | |
27 - static_cast<float>(green_rect.y()) / background_size.height(), | |
28 - static_cast<float>(green_rect.width()) / background_size.width(), | |
29 - static_cast<float>(green_rect.height()) / background_size.height()); | |
30 - | |
31 - // YUV of (149,43,21) should be green (0,255,0) in RGB. | |
32 - // Create a video frame that has a non-green background rect, with a | |
33 - // green sub-rectangle that should be the only thing displayed in | |
34 - // the final image. Bleeding will appear on all four sides of the video | |
35 - // if the tex coords are not clamped. | |
36 - CreateTestYUVVideoDrawQuad_TwoColor( | |
37 - shared_state, format, false, tex_coord_rect, background_size, 0, 0, 0, | |
38 - green_rect, 149, 43, 21, pass.get(), video_resource_updater_.get(), | |
39 - resource_provider_.get()); | |
40 - pass_list->push_back(pass.Pass()); | |
41 - } | |
42 - | |
43 - void SetUp() override { | |
44 - GLRendererPixelTest::SetUp(); | |
45 - video_resource_updater_.reset(new VideoResourceUpdater( | |
46 - output_surface_->context_provider(), resource_provider_.get())); | |
47 - } | |
48 - | |
49 - scoped_ptr<VideoResourceUpdater> video_resource_updater_; | |
50 -}; | |
51 - | |
52 -TEST_F(VideoGLRendererPixelTest, SimpleYUVRect) { | |
53 - gfx::Rect rect(this->device_viewport_size_); | |
54 - | |
55 - RenderPassId id(1, 1); | |
56 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
57 - | |
58 - SharedQuadState* shared_state = | |
59 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
60 - | |
61 - CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12, | |
62 - false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | |
63 - pass.get(), video_resource_updater_.get(), | |
64 - rect, resource_provider_.get()); | |
65 - | |
66 - RenderPassList pass_list; | |
67 - pass_list.push_back(pass.Pass()); | |
68 - | |
69 - EXPECT_TRUE( | |
70 - this->RunPixelTest(&pass_list, | |
71 - base::FilePath(FILE_PATH_LITERAL("yuv_stripes.png")), | |
72 - FuzzyPixelOffByOneComparator(true))); | |
73 -} | |
74 - | |
75 -TEST_F(VideoGLRendererPixelTest, OffsetYUVRect) { | |
76 - gfx::Rect rect(this->device_viewport_size_); | |
77 - | |
78 - RenderPassId id(1, 1); | |
79 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
80 - | |
81 - SharedQuadState* shared_state = | |
82 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
83 - | |
84 - // Intentionally sets frame format to I420 for testing coverage. | |
85 - CreateTestYUVVideoDrawQuad_Striped( | |
86 - shared_state, media::VideoFrame::I420, false, | |
87 - gfx::RectF(0.125f, 0.25f, 0.75f, 0.5f), pass.get(), | |
88 - video_resource_updater_.get(), rect, resource_provider_.get()); | |
89 - | |
90 - RenderPassList pass_list; | |
91 - pass_list.push_back(pass.Pass()); | |
92 - | |
93 - EXPECT_TRUE(this->RunPixelTest( | |
94 - &pass_list, | |
95 - base::FilePath(FILE_PATH_LITERAL("yuv_stripes_offset.png")), | |
96 - FuzzyPixelOffByOneComparator(true))); | |
97 -} | |
98 - | |
99 -TEST_F(VideoGLRendererPixelTest, SimpleYUVRectBlack) { | |
100 - gfx::Rect rect(this->device_viewport_size_); | |
101 - | |
102 - RenderPassId id(1, 1); | |
103 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
104 - | |
105 - SharedQuadState* shared_state = | |
106 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
107 - | |
108 - // In MPEG color range YUV values of (15,128,128) should produce black. | |
109 - CreateTestYUVVideoDrawQuad_Solid( | |
110 - shared_state, media::VideoFrame::YV12, false, | |
111 - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(), | |
112 - video_resource_updater_.get(), rect, resource_provider_.get()); | |
113 - | |
114 - RenderPassList pass_list; | |
115 - pass_list.push_back(pass.Pass()); | |
116 - | |
117 - // If we didn't get black out of the YUV values above, then we probably have
a | |
118 - // color range issue. | |
119 - EXPECT_TRUE(this->RunPixelTest(&pass_list, | |
120 - base::FilePath(FILE_PATH_LITERAL("black.png"))
, | |
121 - FuzzyPixelOffByOneComparator(true))); | |
122 -} | |
123 - | |
124 -TEST_F(VideoGLRendererPixelTest, SimpleYUVJRect) { | |
125 - gfx::Rect rect(this->device_viewport_size_); | |
126 - | |
127 - RenderPassId id(1, 1); | |
128 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
129 - | |
130 - SharedQuadState* shared_state = | |
131 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
132 - | |
133 - // YUV of (149,43,21) should be green (0,255,0) in RGB. | |
134 - CreateTestYUVVideoDrawQuad_Solid( | |
135 - shared_state, media::VideoFrame::YV12J, false, | |
136 - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 149, 43, 21, pass.get(), | |
137 - video_resource_updater_.get(), rect, resource_provider_.get()); | |
138 - | |
139 - RenderPassList pass_list; | |
140 - pass_list.push_back(pass.Pass()); | |
141 - | |
142 - EXPECT_TRUE(this->RunPixelTest(&pass_list, | |
143 - base::FilePath(FILE_PATH_LITERAL("green.png"))
, | |
144 - FuzzyPixelOffByOneComparator(true))); | |
145 -} | |
146 - | |
147 -// Test that a YUV video doesn't bleed outside of its tex coords when the | |
148 -// tex coord rect is only a partial subrectangle of the coded contents. | |
149 -TEST_F(VideoGLRendererPixelTest, YUVEdgeBleed) { | |
150 - RenderPassList pass_list; | |
151 - CreateEdgeBleedPass(media::VideoFrame::YV12J, &pass_list); | |
152 - EXPECT_TRUE(this->RunPixelTest(&pass_list, | |
153 - base::FilePath(FILE_PATH_LITERAL("green.png"))
, | |
154 - FuzzyPixelOffByOneComparator(true))); | |
155 -} | |
156 - | |
157 -TEST_F(VideoGLRendererPixelTest, YUVAEdgeBleed) { | |
158 - RenderPassList pass_list; | |
159 - CreateEdgeBleedPass(media::VideoFrame::YV12A, &pass_list); | |
160 - EXPECT_TRUE(this->RunPixelTest(&pass_list, | |
161 - base::FilePath(FILE_PATH_LITERAL("green.png"))
, | |
162 - FuzzyPixelOffByOneComparator(true))); | |
163 -} | |
164 - | |
165 -TEST_F(VideoGLRendererPixelTest, SimpleYUVJRectGrey) { | |
166 - gfx::Rect rect(this->device_viewport_size_); | |
167 - | |
168 - RenderPassId id(1, 1); | |
169 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
170 - | |
171 - SharedQuadState* shared_state = | |
172 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
173 - | |
174 - // Dark grey in JPEG color range (in MPEG, this is black). | |
175 - CreateTestYUVVideoDrawQuad_Solid( | |
176 - shared_state, media::VideoFrame::YV12J, false, | |
177 - gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), 15, 128, 128, pass.get(), | |
178 - video_resource_updater_.get(), rect, resource_provider_.get()); | |
179 - | |
180 - RenderPassList pass_list; | |
181 - pass_list.push_back(pass.Pass()); | |
182 - | |
183 - EXPECT_TRUE( | |
184 - this->RunPixelTest(&pass_list, | |
185 - base::FilePath(FILE_PATH_LITERAL("dark_grey.png")), | |
186 - FuzzyPixelOffByOneComparator(true))); | |
187 -} | |
188 - | |
189 -TEST_F(VideoGLRendererPixelTest, SimpleYUVARect) { | |
190 - gfx::Rect rect(this->device_viewport_size_); | |
191 - | |
192 - RenderPassId id(1, 1); | |
193 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
194 - | |
195 - SharedQuadState* shared_state = | |
196 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
197 - | |
198 - CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, | |
199 - false, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | |
200 - pass.get(), video_resource_updater_.get(), | |
201 - rect, resource_provider_.get()); | |
202 - | |
203 - SolidColorDrawQuad* color_quad = | |
204 - pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | |
205 - color_quad->SetNew(shared_state, rect, rect, SK_ColorWHITE, false); | |
206 - | |
207 - RenderPassList pass_list; | |
208 - pass_list.push_back(pass.Pass()); | |
209 - | |
210 - EXPECT_TRUE(this->RunPixelTest( | |
211 - &pass_list, | |
212 - base::FilePath(FILE_PATH_LITERAL("yuv_stripes_alpha.png")), | |
213 - FuzzyPixelOffByOneComparator(true))); | |
214 -} | |
215 - | |
216 -TEST_F(VideoGLRendererPixelTest, FullyTransparentYUVARect) { | |
217 - gfx::Rect rect(this->device_viewport_size_); | |
218 - | |
219 - RenderPassId id(1, 1); | |
220 - scoped_ptr<RenderPass> pass = CreateTestRootRenderPass(id, rect); | |
221 - | |
222 - SharedQuadState* shared_state = | |
223 - CreateTestSharedQuadState(gfx::Transform(), rect, pass.get()); | |
224 - | |
225 - CreateTestYUVVideoDrawQuad_Striped(shared_state, media::VideoFrame::YV12A, | |
226 - true, gfx::RectF(0.0f, 0.0f, 1.0f, 1.0f), | |
227 - pass.get(), video_resource_updater_.get(), | |
228 - rect, resource_provider_.get()); | |
229 - | |
230 - SolidColorDrawQuad* color_quad = | |
231 - pass->CreateAndAppendDrawQuad<SolidColorDrawQuad>(); | |
232 - color_quad->SetNew(shared_state, rect, rect, SK_ColorBLACK, false); | |
233 - | |
234 - RenderPassList pass_list; | |
235 - pass_list.push_back(pass.Pass()); | |
236 - | |
237 - EXPECT_TRUE(this->RunPixelTest( | |
238 - &pass_list, | |
239 - base::FilePath(FILE_PATH_LITERAL("black.png")), | |
240 - ExactPixelComparator(true))); | |
241 -} | |
242 - | |
243 TYPED_TEST(RendererPixelTest, FastPassColorFilterAlpha) { | |
244 gfx::Rect viewport_rect(this->device_viewport_size_); | |
245 | |
OLD | NEW |