image/DecoderFactory.cpp

   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 #include "DecoderFactory.h"
   7
   8 #include "nsMimeTypes.h"
   9 #include "mozilla/RefPtr.h"
  10
  11 #include "AnimationSurfaceProvider.h"
  12 #include "Decoder.h"
  13 #include "DecodedSurfaceProvider.h"
  14 #include "IDecodingTask.h"
  15 #include "ImageOps.h"
  16 #include "nsPNGDecoder.h"
  17 #include "nsGIFDecoder2.h"
  18 #include "nsJPEGDecoder.h"
  19 #include "nsBMPDecoder.h"
  20 #include "nsICODecoder.h"
  21 #include "nsIconDecoder.h"
  22 #include "nsWebPDecoder.h"
  23 #ifdef MOZ_AV1
  24 #  include "nsAVIFDecoder.h"
  25 #endif
  26 #ifdef MOZ_JXL
  27 #  include "nsJXLDecoder.h"
  28 #endif
  29
  30 namespace mozilla {
  31
  32 using namespace gfx;
  33
  34 namespace image {
  35
  36 /* static */
  37 DecoderType DecoderFactory::GetDecoderType(const char* aMimeType) {
  38   // By default we don't know.
  39   DecoderType type = DecoderType::UNKNOWN;
  40
  41   // PNG
  42   if (!strcmp(aMimeType, IMAGE_PNG)) {
  43     type = DecoderType::PNG;
  44   } else if (!strcmp(aMimeType, IMAGE_X_PNG)) {
  45     type = DecoderType::PNG;
  46   } else if (!strcmp(aMimeType, IMAGE_APNG)) {
  47     type = DecoderType::PNG;
  48
  49     // GIF
  50   } else if (!strcmp(aMimeType, IMAGE_GIF)) {
  51     type = DecoderType::GIF;
  52
  53     // JPEG
  54   } else if (!strcmp(aMimeType, IMAGE_JPEG)) {
  55     type = DecoderType::JPEG;
  56   } else if (!strcmp(aMimeType, IMAGE_PJPEG)) {
  57     type = DecoderType::JPEG;
  58   } else if (!strcmp(aMimeType, IMAGE_JPG)) {
  59     type = DecoderType::JPEG;
  60
  61     // BMP
  62   } else if (!strcmp(aMimeType, IMAGE_BMP)) {
  63     type = DecoderType::BMP;
  64   } else if (!strcmp(aMimeType, IMAGE_BMP_MS)) {
  65     type = DecoderType::BMP;
  66
  67     // BMP_CLIPBOARD
  68   } else if (!strcmp(aMimeType, IMAGE_BMP_MS_CLIPBOARD)) {
  69     type = DecoderType::BMP_CLIPBOARD;
  70
  71     // ICO
  72   } else if (!strcmp(aMimeType, IMAGE_ICO)) {
  73     type = DecoderType::ICO;
  74   } else if (!strcmp(aMimeType, IMAGE_ICO_MS)) {
  75     type = DecoderType::ICO;
  76
  77     // Icon
  78   } else if (!strcmp(aMimeType, IMAGE_ICON_MS)) {
  79     type = DecoderType::ICON;
  80
  81     // WebP
  82   } else if (!strcmp(aMimeType, IMAGE_WEBP)) {
  83     type = DecoderType::WEBP;
  84
  85     // AVIF
  86   }
  87 #ifdef MOZ_AV1
  88   else if (!strcmp(aMimeType, IMAGE_AVIF) &&
  89            StaticPrefs::image_avif_enabled()) {
  90     type = DecoderType::AVIF;
  91   }
  92 #endif
  93 #ifdef MOZ_JXL
  94   else if (!strcmp(aMimeType, IMAGE_JXL) && StaticPrefs::image_jxl_enabled()) {
  95     type = DecoderType::JXL;
  96   }
  97 #endif
  98
  99   return type;
 100 }
 101
 102 /* static */
 103 DecoderFlags DecoderFactory::GetDefaultDecoderFlagsForType(DecoderType aType) {
 104   auto flags = DefaultDecoderFlags();
 105
 106 #ifdef MOZ_AV1
 107   if (aType == DecoderType::AVIF) {
 108     if (StaticPrefs::image_avif_sequence_enabled()) {
 109       flags |= DecoderFlags::AVIF_SEQUENCES_ENABLED;
 110     }
 111     if (StaticPrefs::image_avif_sequence_animate_avif_major_branded_images()) {
 112       flags |= DecoderFlags::AVIF_ANIMATE_AVIF_MAJOR;
 113     }
 114   }
 115 #endif
 116
 117   return flags;
 118 }
 119
 120 /* static */
 121 already_AddRefed<Decoder> DecoderFactory::GetDecoder(DecoderType aType,
 122                                                      RasterImage* aImage,
 123                                                      bool aIsRedecode) {
 124   RefPtr<Decoder> decoder;
 125
 126   switch (aType) {
 127     case DecoderType::PNG:
 128       decoder = new nsPNGDecoder(aImage);
 129       break;
 130     case DecoderType::GIF:
 131       decoder = new nsGIFDecoder2(aImage);
 132       break;
 133     case DecoderType::JPEG:
 134       // If we have all the data we don't want to waste cpu time doing
 135       // a progressive decode.
 136       decoder = new nsJPEGDecoder(
 137           aImage, aIsRedecode ? Decoder::SEQUENTIAL : Decoder::PROGRESSIVE);
 138       break;
 139     case DecoderType::BMP:
 140       decoder = new nsBMPDecoder(aImage);
 141       break;
 142     case DecoderType::BMP_CLIPBOARD:
 143       decoder = new nsBMPDecoder(aImage, /* aForClipboard */ true);
 144       break;
 145     case DecoderType::ICO:
 146       decoder = new nsICODecoder(aImage);
 147       break;
 148     case DecoderType::ICON:
 149       decoder = new nsIconDecoder(aImage);
 150       break;
 151     case DecoderType::WEBP:
 152       decoder = new nsWebPDecoder(aImage);
 153       break;
 154 #ifdef MOZ_AV1
 155     case DecoderType::AVIF:
 156       decoder = new nsAVIFDecoder(aImage);
 157       break;
 158 #endif
 159 #ifdef MOZ_JXL
 160     case DecoderType::JXL:
 161       decoder = new nsJXLDecoder(aImage);
 162       break;
 163 #endif
 164     default:
 165       MOZ_ASSERT_UNREACHABLE("Unknown decoder type");
 166   }
 167
 168   return decoder.forget();
 169 }
 170
 171 /* static */
 172 nsresult DecoderFactory::CreateDecoder(
 173     DecoderType aType, NotNull<RasterImage*> aImage,
 174     NotNull<SourceBuffer*> aSourceBuffer, const IntSize& aIntrinsicSize,
 175     const IntSize& aOutputSize, DecoderFlags aDecoderFlags,
 176     SurfaceFlags aSurfaceFlags, IDecodingTask** aOutTask) {
 177   if (aType == DecoderType::UNKNOWN) {
 178     return NS_ERROR_INVALID_ARG;
 179   }
 180
 181   // Create an anonymous decoder. Interaction with the SurfaceCache and the
 182   // owning RasterImage will be mediated by DecodedSurfaceProvider.
 183   RefPtr<Decoder> decoder = GetDecoder(
 184       aType, nullptr, bool(aDecoderFlags & DecoderFlags::IS_REDECODE));
 185   MOZ_ASSERT(decoder, "Should have a decoder now");
 186
 187   // Initialize the decoder.
 188   decoder->SetMetadataDecode(false);
 189   decoder->SetIterator(aSourceBuffer->Iterator());
 190   decoder->SetOutputSize(OrientedIntSize::FromUnknownSize(aOutputSize));
 191   decoder->SetDecoderFlags(aDecoderFlags | DecoderFlags::FIRST_FRAME_ONLY);
 192   decoder->SetSurfaceFlags(aSurfaceFlags);
 193
 194   nsresult rv = decoder->Init();
 195   if (NS_FAILED(rv)) {
 196     return NS_ERROR_FAILURE;
 197   }
 198
 199   // Create a DecodedSurfaceProvider which will manage the decoding process and
 200   // make this decoder's output available in the surface cache.
 201   SurfaceKey surfaceKey =
 202       RasterSurfaceKey(aOutputSize, aSurfaceFlags, PlaybackType::eStatic);
 203   auto provider = MakeNotNull<RefPtr<DecodedSurfaceProvider>>(
 204       aImage, surfaceKey, WrapNotNull(decoder));
 205   if (aDecoderFlags & DecoderFlags::CANNOT_SUBSTITUTE) {
 206     provider->Availability().SetCannotSubstitute();
 207   }
 208
 209   // Attempt to insert the surface provider into the surface cache right away so
 210   // we won't trigger any more decoders with the same parameters.
 211   switch (SurfaceCache::Insert(provider)) {
 212     case InsertOutcome::SUCCESS:
 213       break;
 214     case InsertOutcome::FAILURE_ALREADY_PRESENT:
 215       return NS_ERROR_ALREADY_INITIALIZED;
 216     default:
 217       return NS_ERROR_FAILURE;
 218   }
 219
 220   // Return the surface provider in its IDecodingTask guise.
 221   RefPtr<IDecodingTask> task = provider.get();
 222   task.forget(aOutTask);
 223   return NS_OK;
 224 }
 225
 226 /* static */
 227 nsresult DecoderFactory::CreateAnimationDecoder(
 228     DecoderType aType, NotNull<RasterImage*> aImage,
 229     NotNull<SourceBuffer*> aSourceBuffer, const IntSize& aIntrinsicSize,
 230     DecoderFlags aDecoderFlags, SurfaceFlags aSurfaceFlags,
 231     size_t aCurrentFrame, IDecodingTask** aOutTask) {
 232   if (aType == DecoderType::UNKNOWN) {
 233     return NS_ERROR_INVALID_ARG;
 234   }
 235
 236   MOZ_ASSERT(aType == DecoderType::GIF || aType == DecoderType::PNG ||
 237                  aType == DecoderType::WEBP || aType == DecoderType::AVIF,
 238              "Calling CreateAnimationDecoder for non-animating DecoderType");
 239
 240   // Create an anonymous decoder. Interaction with the SurfaceCache and the
 241   // owning RasterImage will be mediated by AnimationSurfaceProvider.
 242   RefPtr<Decoder> decoder =
 243       GetDecoder(aType, nullptr, /* aIsRedecode = */ true);
 244   MOZ_ASSERT(decoder, "Should have a decoder now");
 245
 246   // Initialize the decoder.
 247   decoder->SetMetadataDecode(false);
 248   decoder->SetIterator(aSourceBuffer->Iterator());
 249   decoder->SetDecoderFlags(aDecoderFlags | DecoderFlags::IS_REDECODE);
 250   decoder->SetSurfaceFlags(aSurfaceFlags);
 251
 252   nsresult rv = decoder->Init();
 253   if (NS_FAILED(rv)) {
 254     return NS_ERROR_FAILURE;
 255   }
 256
 257   // Create an AnimationSurfaceProvider which will manage the decoding process
 258   // and make this decoder's output available in the surface cache.
 259   SurfaceKey surfaceKey =
 260       RasterSurfaceKey(aIntrinsicSize, aSurfaceFlags, PlaybackType::eAnimated);
 261   auto provider = MakeNotNull<RefPtr<AnimationSurfaceProvider>>(
 262       aImage, surfaceKey, WrapNotNull(decoder), aCurrentFrame);
 263
 264   // Attempt to insert the surface provider into the surface cache right away so
 265   // we won't trigger any more decoders with the same parameters.
 266   switch (SurfaceCache::Insert(provider)) {
 267     case InsertOutcome::SUCCESS:
 268       break;
 269     case InsertOutcome::FAILURE_ALREADY_PRESENT:
 270       return NS_ERROR_ALREADY_INITIALIZED;
 271     default:
 272       return NS_ERROR_FAILURE;
 273   }
 274
 275   // Return the surface provider in its IDecodingTask guise.
 276   RefPtr<IDecodingTask> task = provider.get();
 277   task.forget(aOutTask);
 278   return NS_OK;
 279 }
 280
 281 /* static */
 282 already_AddRefed<Decoder> DecoderFactory::CloneAnimationDecoder(
 283     Decoder* aDecoder) {
 284   MOZ_ASSERT(aDecoder);
 285
 286   // In an ideal world, we would assert aDecoder->HasAnimation() but we cannot.
 287   // The decoder may not have detected it is animated yet (e.g. it did not even
 288   // get scheduled yet, or it has only decoded the first frame and has yet to
 289   // rediscover it is animated).
 290   DecoderType type = aDecoder->GetType();
 291   MOZ_ASSERT(type == DecoderType::GIF || type == DecoderType::PNG ||
 292                  type == DecoderType::WEBP || type == DecoderType::AVIF,
 293              "Calling CloneAnimationDecoder for non-animating DecoderType");
 294
 295   RefPtr<Decoder> decoder = GetDecoder(type, nullptr, /* aIsRedecode = */ true);
 296   MOZ_ASSERT(decoder, "Should have a decoder now");
 297
 298   // Initialize the decoder.
 299   decoder->SetMetadataDecode(false);
 300   decoder->SetIterator(aDecoder->GetSourceBuffer()->Iterator());
 301   decoder->SetDecoderFlags(aDecoder->GetDecoderFlags());
 302   decoder->SetSurfaceFlags(aDecoder->GetSurfaceFlags());
 303   decoder->SetFrameRecycler(aDecoder->GetFrameRecycler());
 304
 305   if (NS_FAILED(decoder->Init())) {
 306     return nullptr;
 307   }
 308
 309   return decoder.forget();
 310 }
 311
 312 /* static */
 313 already_AddRefed<IDecodingTask> DecoderFactory::CreateMetadataDecoder(
 314     DecoderType aType, NotNull<RasterImage*> aImage, DecoderFlags aFlags,
 315     NotNull<SourceBuffer*> aSourceBuffer) {
 316   if (aType == DecoderType::UNKNOWN) {
 317     return nullptr;
 318   }
 319
 320   RefPtr<Decoder> decoder =
 321       GetDecoder(aType, aImage, /* aIsRedecode = */ false);
 322   MOZ_ASSERT(decoder, "Should have a decoder now");
 323
 324   // Initialize the decoder.
 325   decoder->SetMetadataDecode(true);
 326   decoder->SetDecoderFlags(aFlags);
 327   decoder->SetIterator(aSourceBuffer->Iterator());
 328
 329   if (NS_FAILED(decoder->Init())) {
 330     return nullptr;
 331   }
 332
 333   RefPtr<IDecodingTask> task = new MetadataDecodingTask(WrapNotNull(decoder));
 334   return task.forget();
 335 }
 336
 337 /* static */
 338 already_AddRefed<Decoder> DecoderFactory::CreateDecoderForICOResource(
 339     DecoderType aType, SourceBufferIterator&& aIterator,
 340     NotNull<nsICODecoder*> aICODecoder, bool aIsMetadataDecode,
 341     const Maybe<OrientedIntSize>& aExpectedSize,
 342     const Maybe<uint32_t>& aDataOffset
 343     /* = Nothing() */) {
 344   // Create the decoder.
 345   RefPtr<Decoder> decoder;
 346   switch (aType) {
 347     case DecoderType::BMP:
 348       MOZ_ASSERT(aDataOffset);
 349       decoder =
 350           new nsBMPDecoder(aICODecoder->GetImageMaybeNull(), *aDataOffset);
 351       break;
 352
 353     case DecoderType::PNG:
 354       MOZ_ASSERT(!aDataOffset);
 355       decoder = new nsPNGDecoder(aICODecoder->GetImageMaybeNull());
 356       break;
 357
 358     default:
 359       MOZ_ASSERT_UNREACHABLE("Invalid ICO resource decoder type");
 360       return nullptr;
 361   }
 362
 363   MOZ_ASSERT(decoder);
 364
 365   // Initialize the decoder, copying settings from @aICODecoder.
 366   decoder->SetMetadataDecode(aIsMetadataDecode);
 367   decoder->SetIterator(std::forward<SourceBufferIterator>(aIterator));
 368   if (!aIsMetadataDecode) {
 369     decoder->SetOutputSize(aICODecoder->OutputSize());
 370   }
 371   if (aExpectedSize) {
 372     decoder->SetExpectedSize(*aExpectedSize);
 373   }
 374   decoder->SetDecoderFlags(aICODecoder->GetDecoderFlags());
 375   decoder->SetSurfaceFlags(aICODecoder->GetSurfaceFlags());
 376   decoder->SetFinalizeFrames(false);
 377
 378   if (NS_FAILED(decoder->Init())) {
 379     return nullptr;
 380   }
 381
 382   return decoder.forget();
 383 }
 384
 385 /* static */
 386 already_AddRefed<Decoder> DecoderFactory::CreateAnonymousDecoder(
 387     DecoderType aType, NotNull<SourceBuffer*> aSourceBuffer,
 388     const Maybe<IntSize>& aOutputSize, DecoderFlags aDecoderFlags,
 389     SurfaceFlags aSurfaceFlags) {
 390   if (aType == DecoderType::UNKNOWN) {
 391     return nullptr;
 392   }
 393
 394   RefPtr<Decoder> decoder =
 395       GetDecoder(aType, /* aImage = */ nullptr, /* aIsRedecode = */ false);
 396   MOZ_ASSERT(decoder, "Should have a decoder now");
 397
 398   // Initialize the decoder.
 399   decoder->SetMetadataDecode(false);
 400   decoder->SetIterator(aSourceBuffer->Iterator());
 401
 402   // Anonymous decoders are always transient; we don't want to optimize surfaces
 403   // or do any other expensive work that might be wasted.
 404   DecoderFlags decoderFlags = DecoderFlags::IMAGE_IS_TRANSIENT;
 405
 406   decoder->SetDecoderFlags(aDecoderFlags | decoderFlags);
 407   decoder->SetSurfaceFlags(aSurfaceFlags);
 408
 409   // Set an output size for downscale-during-decode if requested.
 410   if (aOutputSize) {
 411     decoder->SetOutputSize(OrientedIntSize::FromUnknownSize(*aOutputSize));
 412   }
 413
 414   if (NS_FAILED(decoder->Init())) {
 415     return nullptr;
 416   }
 417
 418   return decoder.forget();
 419 }
 420
 421 /* static */
 422 already_AddRefed<Decoder> DecoderFactory::CreateAnonymousMetadataDecoder(
 423     DecoderType aType, NotNull<SourceBuffer*> aSourceBuffer) {
 424   if (aType == DecoderType::UNKNOWN) {
 425     return nullptr;
 426   }
 427
 428   RefPtr<Decoder> decoder =
 429       GetDecoder(aType, /* aImage = */ nullptr, /* aIsRedecode = */ false);
 430   MOZ_ASSERT(decoder, "Should have a decoder now");
 431
 432   // Initialize the decoder.
 433   decoder->SetMetadataDecode(true);
 434   decoder->SetIterator(aSourceBuffer->Iterator());
 435   decoder->SetDecoderFlags(DecoderFlags::FIRST_FRAME_ONLY);
 436
 437   if (NS_FAILED(decoder->Init())) {
 438     return nullptr;
 439   }
 440
 441   return decoder.forget();
 442 }
 443
 444 }  // namespace image
 445 }  // namespace mozilla