Common.h (22244B)
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ 2 /* This Source Code Form is subject to the terms of the Mozilla Public 3 * License, v. 2.0. If a copy of the MPL was not distributed with this 4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ 5 6 #ifndef mozilla_image_test_gtest_Common_h 7 #define mozilla_image_test_gtest_Common_h 8 9 #include <vector> 10 11 #include "gtest/gtest.h" 12 13 #include "mozilla/Attributes.h" 14 #include "mozilla/gtest/MozAssertions.h" 15 #include "mozilla/Maybe.h" 16 #include "mozilla/UniquePtr.h" 17 #include "mozilla/gfx/2D.h" 18 #include "Decoder.h" 19 #include "gfxColor.h" 20 #include "gfxPlatform.h" 21 #include "nsCOMPtr.h" 22 #include "SurfaceFlags.h" 23 #include "SurfacePipe.h" 24 #include "SurfacePipeFactory.h" 25 26 class nsIInputStream; 27 28 namespace mozilla { 29 namespace image { 30 31 /////////////////////////////////////////////////////////////////////////////// 32 // Types 33 /////////////////////////////////////////////////////////////////////////////// 34 35 struct BGRAColor { 36 BGRAColor() : BGRAColor(0, 0, 0, 0) {} 37 38 BGRAColor(uint8_t aBlue, uint8_t aGreen, uint8_t aRed, uint8_t aAlpha, 39 bool aPremultiplied = false, bool asRGB = true) 40 : mBlue(aBlue), 41 mGreen(aGreen), 42 mRed(aRed), 43 mAlpha(aAlpha), 44 mPremultiplied(aPremultiplied), 45 msRGB(asRGB) {} 46 47 static BGRAColor Green() { return BGRAColor(0x00, 0xFF, 0x00, 0xFF); } 48 static BGRAColor Red() { return BGRAColor(0x00, 0x00, 0xFF, 0xFF); } 49 static BGRAColor Blue() { return BGRAColor(0xFF, 0x00, 0x00, 0xFF); } 50 static BGRAColor Transparent() { return BGRAColor(0x00, 0x00, 0x00, 0x00); } 51 52 static BGRAColor FromPixel(uint32_t aPixel) { 53 uint8_t r, g, b, a; 54 r = (aPixel >> gfx::SurfaceFormatBit::OS_R) & 0xFF; 55 g = (aPixel >> gfx::SurfaceFormatBit::OS_G) & 0xFF; 56 b = (aPixel >> gfx::SurfaceFormatBit::OS_B) & 0xFF; 57 a = (aPixel >> gfx::SurfaceFormatBit::OS_A) & 0xFF; 58 return BGRAColor(b, g, r, a, true); 59 } 60 61 BGRAColor DeviceColor() const { 62 MOZ_RELEASE_ASSERT(!mPremultiplied); 63 if (msRGB) { 64 gfx::DeviceColor color = gfx::ToDeviceColor( 65 gfx::sRGBColor(float(mRed) / 255.0f, float(mGreen) / 255.0f, 66 float(mBlue) / 255.0f, 1.0)); 67 return BGRAColor(uint8_t(color.b * 255.0f), uint8_t(color.g * 255.0f), 68 uint8_t(color.r * 255.0f), mAlpha, mPremultiplied, 69 /* asRGB */ false); 70 } 71 return *this; 72 } 73 74 BGRAColor sRGBColor() const { 75 MOZ_RELEASE_ASSERT(msRGB); 76 MOZ_RELEASE_ASSERT(!mPremultiplied); 77 return *this; 78 } 79 80 BGRAColor Premultiply() const { 81 if (!mPremultiplied) { 82 return BGRAColor(gfxPreMultiply(mBlue, mAlpha), 83 gfxPreMultiply(mGreen, mAlpha), 84 gfxPreMultiply(mRed, mAlpha), mAlpha, true); 85 } 86 return *this; 87 } 88 89 uint32_t AsPixel() const { 90 if (!mPremultiplied) { 91 return gfxPackedPixel(mAlpha, mRed, mGreen, mBlue); 92 } 93 return gfxPackedPixelNoPreMultiply(mAlpha, mRed, mGreen, mBlue); 94 } 95 96 uint8_t mBlue; 97 uint8_t mGreen; 98 uint8_t mRed; 99 uint8_t mAlpha; 100 bool mPremultiplied; 101 bool msRGB; 102 }; 103 104 enum TestCaseFlags { 105 TEST_CASE_DEFAULT_FLAGS = 0, 106 TEST_CASE_IS_FUZZY = 1 << 0, 107 TEST_CASE_HAS_ERROR = 1 << 1, 108 TEST_CASE_IS_TRANSPARENT = 1 << 2, 109 TEST_CASE_IS_ANIMATED = 1 << 3, 110 TEST_CASE_IGNORE_OUTPUT = 1 << 4, 111 TEST_CASE_ASSUME_SRGB_OUTPUT = 1 << 5, 112 }; 113 114 struct ImageTestCase { 115 ImageTestCase(const char* aPath, const char* aMimeType, gfx::IntSize aSize, 116 uint32_t aFlags = TEST_CASE_DEFAULT_FLAGS, 117 uint32_t aFrameCount = 1) 118 : mPath(aPath), 119 mMimeType(aMimeType), 120 mSize(aSize), 121 mOutputSize(aSize), 122 mFrameCount(aFrameCount), 123 mFlags(aFlags), 124 mSurfaceFlags(DefaultSurfaceFlags()), 125 mColor(BGRAColor::Green()) {} 126 127 ImageTestCase(const char* aPath, const char* aMimeType, gfx::IntSize aSize, 128 gfx::IntSize aOutputSize, 129 uint32_t aFlags = TEST_CASE_DEFAULT_FLAGS) 130 : mPath(aPath), 131 mMimeType(aMimeType), 132 mSize(aSize), 133 mOutputSize(aOutputSize), 134 mFlags(aFlags), 135 mSurfaceFlags(DefaultSurfaceFlags()), 136 mColor(BGRAColor::Green()) {} 137 138 ImageTestCase WithSurfaceFlags(SurfaceFlags aSurfaceFlags) const { 139 ImageTestCase self = *this; 140 self.mSurfaceFlags = aSurfaceFlags; 141 return self; 142 } 143 144 ImageTestCase WithFlags(uint32_t aFlags) const { 145 ImageTestCase self = *this; 146 self.mFlags = aFlags; 147 return self; 148 } 149 150 BGRAColor ChooseColor(const BGRAColor& aColor) const { 151 // If we are forcing the output to be sRGB via the surface flag, or the 152 // test case is marked as assuming sRGB (used when the image itself is not 153 // explicitly tagged, and as a result, imagelib won't perform any color 154 // conversion), we should use the sRGB presentation of the color. 155 if ((mSurfaceFlags & SurfaceFlags::TO_SRGB_COLORSPACE) || 156 (mFlags & TEST_CASE_ASSUME_SRGB_OUTPUT)) { 157 return aColor.sRGBColor(); 158 } 159 return aColor.DeviceColor(); 160 } 161 162 BGRAColor Color() const { return ChooseColor(mColor); } 163 164 uint8_t Fuzz() const { 165 // If we are using device space, there can easily be off by 1 channel errors 166 // depending on the color profile and how the rounding went. 167 if (mFlags & TEST_CASE_IS_FUZZY || 168 !(mSurfaceFlags & SurfaceFlags::TO_SRGB_COLORSPACE)) { 169 return 1; 170 } 171 return 0; 172 } 173 174 const char* mPath; 175 const char* mMimeType; 176 gfx::IntSize mSize; 177 gfx::IntSize mOutputSize; 178 uint32_t mFrameCount = 0; 179 uint32_t mFlags; 180 SurfaceFlags mSurfaceFlags; 181 BGRAColor mColor; 182 }; 183 184 /////////////////////////////////////////////////////////////////////////////// 185 // General Helpers 186 /////////////////////////////////////////////////////////////////////////////// 187 188 /** 189 * A RAII class that ensure that ImageLib services are available. Any tests that 190 * require ImageLib to be initialized (for example, any test that uses the 191 * SurfaceCache; see image::EnsureModuleInitialized() for the full list) can 192 * use this class to ensure that ImageLib services are available. Failure to do 193 * so can result in strange, non-deterministic failures. 194 */ 195 class AutoInitializeImageLib { 196 public: 197 AutoInitializeImageLib(); 198 }; 199 200 /** 201 * A test fixture class used for benchmark tests. It preloads the image data 202 * from disk to avoid including that in the timing. 203 */ 204 class ImageBenchmarkBase : public ::testing::Test { 205 protected: 206 ImageBenchmarkBase(const ImageTestCase& aTestCase) : mTestCase(aTestCase) {} 207 208 void SetUp() override; 209 void TearDown() override; 210 211 AutoInitializeImageLib mInit; 212 ImageTestCase mTestCase; 213 RefPtr<SourceBuffer> mSourceBuffer; 214 }; 215 216 /// Spins on the main thread to process any pending events. 217 void SpinPendingEvents(); 218 219 /// Loads a file from the current directory. @return an nsIInputStream for it. 220 already_AddRefed<nsIInputStream> LoadFile(const char* aRelativePath); 221 222 /** 223 * @returns true if every pixel of @aSurface is @aColor. 224 * 225 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color 226 * component. This may be necessary for tests that involve JPEG images or 227 * downscaling. 228 */ 229 bool IsSolidColor(gfx::SourceSurface* aSurface, BGRAColor aColor, 230 uint8_t aFuzz = 0); 231 232 /** 233 * @returns true if every pixel in the range of rows specified by @aStartRow and 234 * @aRowCount of @aSurface is @aColor. 235 * 236 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color 237 * component. This may be necessary for tests that involve JPEG images or 238 * downscaling. 239 */ 240 bool RowsAreSolidColor(gfx::SourceSurface* aSurface, int32_t aStartRow, 241 int32_t aRowCount, BGRAColor aColor, uint8_t aFuzz = 0); 242 243 /** 244 * @returns true if every pixel in the rect specified by @aRect is @aColor. 245 * 246 * If @aFuzz is nonzero, a tolerance of @aFuzz is allowed in each color 247 * component. This may be necessary for tests that involve JPEG images or 248 * downscaling. 249 */ 250 bool RectIsSolidColor(gfx::SourceSurface* aSurface, const gfx::IntRect& aRect, 251 BGRAColor aColor, uint8_t aFuzz = 0); 252 253 /** 254 * @returns true if the pixels in @aRow of @aSurface match the pixels given in 255 * @aPixels. 256 */ 257 bool RowHasPixels(gfx::SourceSurface* aSurface, int32_t aRow, 258 const std::vector<BGRAColor>& aPixels); 259 260 // ExpectNoResume is an IResumable implementation for use by tests that expect 261 // Resume() to never get called. 262 class ExpectNoResume final : public IResumable { 263 public: 264 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ExpectNoResume, override) 265 266 void Resume() override { FAIL() << "Resume() should not get called"; } 267 268 private: 269 ~ExpectNoResume() override {} 270 }; 271 272 // CountResumes is an IResumable implementation for use by tests that expect 273 // Resume() to get called a certain number of times. 274 class CountResumes : public IResumable { 275 public: 276 NS_INLINE_DECL_THREADSAFE_REFCOUNTING(CountResumes, override) 277 278 CountResumes() : mCount(0) {} 279 280 void Resume() override { mCount++; } 281 uint32_t Count() const { return mCount; } 282 283 private: 284 ~CountResumes() override {} 285 286 uint32_t mCount; 287 }; 288 289 /////////////////////////////////////////////////////////////////////////////// 290 // SurfacePipe Helpers 291 /////////////////////////////////////////////////////////////////////////////// 292 293 /** 294 * Creates a decoder with no data associated with, suitable for testing code 295 * that requires a decoder to initialize or to allocate surfaces but doesn't 296 * actually need the decoder to do any decoding. 297 * 298 * XXX(seth): We only need this because SurfaceSink defer to the decoder for 299 * surface allocation. Once all decoders use SurfacePipe we won't need to do 300 * that anymore and we can remove this function. 301 */ 302 already_AddRefed<Decoder> CreateTrivialDecoder(); 303 304 /** 305 * Creates a pipeline of SurfaceFilters from a list of Config structs and passes 306 * it to the provided lambda @aFunc. Assertions that the pipeline is constructly 307 * correctly and cleanup of any allocated surfaces is handled automatically. 308 * 309 * @param aDecoder The decoder to use for allocating surfaces. 310 * @param aFunc The lambda function to pass the filter pipeline to. 311 * @param aConfigs The configuration for the pipeline. 312 */ 313 template <typename Func, typename... Configs> 314 void WithFilterPipeline(Decoder* aDecoder, Func aFunc, bool aFinish, 315 const Configs&... aConfigs) { 316 auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>(); 317 nsresult rv = pipe->Configure(aConfigs...); 318 ASSERT_NS_SUCCEEDED(rv); 319 320 aFunc(aDecoder, pipe.get()); 321 322 if (aFinish) { 323 RawAccessFrameRef currentFrame = aDecoder->GetCurrentFrameRef(); 324 if (currentFrame) { 325 currentFrame->Finish(); 326 } 327 } 328 } 329 330 template <typename Func, typename... Configs> 331 void WithFilterPipeline(Decoder* aDecoder, Func aFunc, 332 const Configs&... aConfigs) { 333 WithFilterPipeline(aDecoder, aFunc, true, aConfigs...); 334 } 335 336 /** 337 * Creates a pipeline of SurfaceFilters from a list of Config structs and 338 * asserts that configuring it fails. Cleanup of any allocated surfaces is 339 * handled automatically. 340 * 341 * @param aDecoder The decoder to use for allocating surfaces. 342 * @param aConfigs The configuration for the pipeline. 343 */ 344 template <typename... Configs> 345 void AssertConfiguringPipelineFails(Decoder* aDecoder, 346 const Configs&... aConfigs) { 347 auto pipe = MakeUnique<typename detail::FilterPipeline<Configs...>::Type>(); 348 nsresult rv = pipe->Configure(aConfigs...); 349 350 // Callers expect configuring the pipeline to fail. 351 ASSERT_NS_FAILED(rv); 352 353 RawAccessFrameRef currentFrame = aDecoder->GetCurrentFrameRef(); 354 if (currentFrame) { 355 currentFrame->Finish(); 356 } 357 } 358 359 /** 360 * Asserts that the provided filter pipeline is in the correct final state, 361 * which is to say, the entire surface has been written to (IsSurfaceFinished() 362 * returns true) and the invalid rects are as expected. 363 * 364 * @param aFilter The filter pipeline to check. 365 * @param aInputSpaceRect The expect invalid rect, in input space. 366 * @param aoutputSpaceRect The expect invalid rect, in output space. 367 */ 368 void AssertCorrectPipelineFinalState(SurfaceFilter* aFilter, 369 const gfx::IntRect& aInputSpaceRect, 370 const gfx::IntRect& aOutputSpaceRect); 371 372 /** 373 * Checks a generated image for correctness. Reports any unexpected deviation 374 * from the expected image as GTest failures. 375 * 376 * @param aDecoder The decoder which contains the image. The decoder's current 377 * frame will be checked. 378 * @param aRect The region in the space of the output surface that the filter 379 * pipeline will actually write to. It's expected that pixels in 380 * this region are green, while pixels outside this region are 381 * transparent. 382 * @param aFuzz The amount of fuzz to use in pixel comparisons. 383 */ 384 void CheckGeneratedImage(Decoder* aDecoder, const gfx::IntRect& aRect, 385 uint8_t aFuzz = 0); 386 387 /** 388 * Checks a generated surface for correctness. Reports any unexpected deviation 389 * from the expected image as GTest failures. 390 * 391 * @param aSurface The surface to check. 392 * @param aRect The region in the space of the output surface that the filter 393 * pipeline will actually write to. 394 * @param aInnerColor Check that pixels inside of aRect are this color. 395 * @param aOuterColor Check that pixels outside of aRect are this color. 396 * @param aFuzz The amount of fuzz to use in pixel comparisons. 397 */ 398 void CheckGeneratedSurface(gfx::SourceSurface* aSurface, 399 const gfx::IntRect& aRect, 400 const BGRAColor& aInnerColor, 401 const BGRAColor& aOuterColor, uint8_t aFuzz = 0); 402 403 /** 404 * Tests the result of calling WritePixels() using the provided SurfaceFilter 405 * pipeline. The pipeline must be a normal (i.e., non-paletted) pipeline. 406 * 407 * The arguments are specified in the an order intended to minimize the number 408 * of arguments that most test cases need to pass. 409 * 410 * @param aDecoder The decoder whose current frame will be written to. 411 * @param aFilter The SurfaceFilter pipeline to use. 412 * @param aOutputRect The region in the space of the output surface that will be 413 * invalidated by the filter pipeline. Defaults to 414 * (0, 0, 100, 100). 415 * @param aInputRect The region in the space of the input image that will be 416 * invalidated by the filter pipeline. Defaults to 417 * (0, 0, 100, 100). 418 * @param aInputWriteRect The region in the space of the input image that the 419 * filter pipeline will allow writes to. Note the 420 * difference from @aInputRect: @aInputRect is the actual 421 * region invalidated, while @aInputWriteRect is the 422 * region that is written to. These can differ in cases 423 * where the input is not clipped to the size of the 424 * image. Defaults to the entire input rect. 425 * @param aOutputWriteRect The region in the space of the output surface that 426 * the filter pipeline will actually write to. It's 427 * expected that pixels in this region are green, while 428 * pixels outside this region are transparent. Defaults 429 * to the entire output rect. 430 */ 431 void CheckWritePixels(Decoder* aDecoder, SurfaceFilter* aFilter, 432 const Maybe<gfx::IntRect>& aOutputRect = Nothing(), 433 const Maybe<gfx::IntRect>& aInputRect = Nothing(), 434 const Maybe<gfx::IntRect>& aInputWriteRect = Nothing(), 435 const Maybe<gfx::IntRect>& aOutputWriteRect = Nothing(), 436 uint8_t aFuzz = 0); 437 438 /** 439 * Tests the result of calling WritePixels() using the provided SurfaceFilter 440 * pipeline. Allows for control over the input color to write, and the expected 441 * output color. 442 * @see CheckWritePixels() for documentation of the arguments. 443 */ 444 void CheckTransformedWritePixels( 445 Decoder* aDecoder, SurfaceFilter* aFilter, const BGRAColor& aInputColor, 446 const BGRAColor& aOutputColor, 447 const Maybe<gfx::IntRect>& aOutputRect = Nothing(), 448 const Maybe<gfx::IntRect>& aInputRect = Nothing(), 449 const Maybe<gfx::IntRect>& aInputWriteRect = Nothing(), 450 const Maybe<gfx::IntRect>& aOutputWriteRect = Nothing(), uint8_t aFuzz = 0); 451 452 /////////////////////////////////////////////////////////////////////////////// 453 // Decoder Helpers 454 /////////////////////////////////////////////////////////////////////////////// 455 456 // Friend class of Decoder to access internals for tests. 457 class MOZ_STACK_CLASS DecoderTestHelper final { 458 public: 459 explicit DecoderTestHelper(Decoder* aDecoder) : mDecoder(aDecoder) {} 460 461 void PostIsAnimated(FrameTimeout aTimeout) { 462 mDecoder->PostIsAnimated(aTimeout); 463 } 464 465 void PostFrameStop(Opacity aOpacity) { mDecoder->PostFrameStop(aOpacity); } 466 467 private: 468 Decoder* mDecoder; 469 }; 470 471 /////////////////////////////////////////////////////////////////////////////// 472 // Test Data 473 /////////////////////////////////////////////////////////////////////////////// 474 475 ImageTestCase GreenPNGTestCase(); 476 ImageTestCase GreenGIFTestCase(); 477 ImageTestCase GreenJPGTestCase(); 478 ImageTestCase GreenBMPTestCase(); 479 ImageTestCase GreenICOTestCase(); 480 ImageTestCase GreenIconTestCase(); 481 ImageTestCase GreenWebPTestCase(); 482 ImageTestCase GreenAVIFTestCase(); 483 484 ImageTestCase NonzeroReservedAVIFTestCase(); 485 ImageTestCase MultipleColrAVIFTestCase(); 486 ImageTestCase Transparent10bit420AVIFTestCase(); 487 ImageTestCase Transparent10bit422AVIFTestCase(); 488 ImageTestCase Transparent10bit444AVIFTestCase(); 489 ImageTestCase Transparent12bit420AVIFTestCase(); 490 ImageTestCase Transparent12bit422AVIFTestCase(); 491 ImageTestCase Transparent12bit444AVIFTestCase(); 492 ImageTestCase Transparent8bit420AVIFTestCase(); 493 ImageTestCase Transparent8bit422AVIFTestCase(); 494 ImageTestCase Transparent8bit444AVIFTestCase(); 495 496 ImageTestCase Gray8bitLimitedRangeBT601AVIFTestCase(); 497 ImageTestCase Gray8bitLimitedRangeBT709AVIFTestCase(); 498 ImageTestCase Gray8bitLimitedRangeBT2020AVIFTestCase(); 499 ImageTestCase Gray8bitFullRangeBT601AVIFTestCase(); 500 ImageTestCase Gray8bitFullRangeBT709AVIFTestCase(); 501 ImageTestCase Gray8bitFullRangeBT2020AVIFTestCase(); 502 ImageTestCase Gray10bitLimitedRangeBT601AVIFTestCase(); 503 ImageTestCase Gray10bitLimitedRangeBT709AVIFTestCase(); 504 ImageTestCase Gray10bitLimitedRangeBT2020AVIFTestCase(); 505 ImageTestCase Gray10bitFullRangeBT601AVIFTestCase(); 506 ImageTestCase Gray10bitFullRangeBT709AVIFTestCase(); 507 ImageTestCase Gray10bitFullRangeBT2020AVIFTestCase(); 508 ImageTestCase Gray12bitLimitedRangeBT601AVIFTestCase(); 509 ImageTestCase Gray12bitLimitedRangeBT709AVIFTestCase(); 510 ImageTestCase Gray12bitLimitedRangeBT2020AVIFTestCase(); 511 ImageTestCase Gray12bitFullRangeBT601AVIFTestCase(); 512 ImageTestCase Gray12bitFullRangeBT709AVIFTestCase(); 513 ImageTestCase Gray12bitFullRangeBT2020AVIFTestCase(); 514 ImageTestCase Gray8bitLimitedRangeGrayscaleAVIFTestCase(); 515 ImageTestCase Gray8bitFullRangeGrayscaleAVIFTestCase(); 516 ImageTestCase Gray10bitLimitedRangeGrayscaleAVIFTestCase(); 517 ImageTestCase Gray10bitFullRangeGrayscaleAVIFTestCase(); 518 ImageTestCase Gray12bitLimitedRangeGrayscaleAVIFTestCase(); 519 ImageTestCase Gray12bitFullRangeGrayscaleAVIFTestCase(); 520 521 ImageTestCase StackCheckAVIFTestCase(); 522 523 ImageTestCase LargeWebPTestCase(); 524 ImageTestCase GreenWebPIccSrgbTestCase(); 525 526 ImageTestCase GreenFirstFrameAnimatedGIFTestCase(); 527 ImageTestCase GreenFirstFrameAnimatedPNGTestCase(); 528 ImageTestCase GreenFirstFrameAnimatedWebPTestCase(); 529 ImageTestCase GreenFirstFrameAnimatedAVIFTestCase(); 530 531 ImageTestCase BlendAnimatedGIFTestCase(); 532 ImageTestCase BlendAnimatedPNGTestCase(); 533 ImageTestCase BlendAnimatedWebPTestCase(); 534 ImageTestCase BlendAnimatedAVIFTestCase(); 535 536 ImageTestCase CorruptTestCase(); 537 ImageTestCase CorruptBMPWithTruncatedHeader(); 538 ImageTestCase CorruptICOWithBadBMPWidthTestCase(); 539 ImageTestCase CorruptICOWithBadBMPHeightTestCase(); 540 ImageTestCase CorruptICOWithBadBppTestCase(); 541 542 ImageTestCase TransparentPNGTestCase(); 543 ImageTestCase TransparentGIFTestCase(); 544 ImageTestCase TransparentWebPTestCase(); 545 ImageTestCase TransparentNoAlphaHeaderWebPTestCase(); 546 ImageTestCase FirstFramePaddingGIFTestCase(); 547 ImageTestCase TransparentIfWithinICOBMPTestCase(TestCaseFlags aFlags); 548 ImageTestCase NoFrameDelayGIFTestCase(); 549 ImageTestCase ExtraImageSubBlocksAnimatedGIFTestCase(); 550 551 ImageTestCase TransparentBMPWhenBMPAlphaEnabledTestCase(); 552 ImageTestCase RLE4BMPTestCase(); 553 ImageTestCase RLE8BMPTestCase(); 554 555 ImageTestCase DownscaledPNGTestCase(); 556 ImageTestCase DownscaledGIFTestCase(); 557 ImageTestCase DownscaledJPGTestCase(); 558 ImageTestCase DownscaledBMPTestCase(); 559 ImageTestCase DownscaledICOTestCase(); 560 ImageTestCase DownscaledIconTestCase(); 561 ImageTestCase DownscaledWebPTestCase(); 562 ImageTestCase DownscaledTransparentICOWithANDMaskTestCase(); 563 564 ImageTestCase TruncatedSmallGIFTestCase(); 565 566 ImageTestCase LargeICOWithBMPTestCase(); 567 ImageTestCase LargeICOWithPNGTestCase(); 568 ImageTestCase GreenMultipleSizesICOTestCase(); 569 570 ImageTestCase PerfGrayJPGTestCase(); 571 ImageTestCase PerfCmykJPGTestCase(); 572 ImageTestCase PerfYCbCrJPGTestCase(); 573 ImageTestCase PerfRgbPNGTestCase(); 574 ImageTestCase PerfRgbAlphaPNGTestCase(); 575 ImageTestCase PerfGrayPNGTestCase(); 576 ImageTestCase PerfGrayAlphaPNGTestCase(); 577 ImageTestCase PerfRgbLosslessWebPTestCase(); 578 ImageTestCase PerfRgbAlphaLosslessWebPTestCase(); 579 ImageTestCase PerfRgbLossyWebPTestCase(); 580 ImageTestCase PerfRgbAlphaLossyWebPTestCase(); 581 ImageTestCase PerfRgbGIFTestCase(); 582 583 ImageTestCase CorruptAVIFTestCase(); 584 ImageTestCase DownscaledAVIFTestCase(); 585 ImageTestCase LargeAVIFTestCase(); 586 ImageTestCase MultiLayerAVIFTestCase(); 587 ImageTestCase TransparentAVIFTestCase(); 588 589 #ifdef MOZ_JXL 590 ImageTestCase GreenJXLTestCase(); 591 ImageTestCase DownscaledJXLTestCase(); 592 ImageTestCase LargeJXLTestCase(); 593 ImageTestCase TransparentJXLTestCase(); 594 #endif 595 596 ImageTestCase ExifResolutionTestCase(); 597 598 RefPtr<Image> TestCaseToDecodedImage(const ImageTestCase&); 599 600 } // namespace image 601 } // namespace mozilla 602 603 #endif // mozilla_image_test_gtest_Common_h