| 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 |