[ tor-browser ].git.dasho

nsWebPDecoder.cpp (20020B)
      1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
      2 *
      3 * This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #include "ImageLogging.h"  // Must appear first
      8 #include "gfxPlatform.h"
      9 #include "mozilla/TelemetryHistogramEnums.h"
     10 #include "nsWebPDecoder.h"
     11 
     12 #include "RasterImage.h"
     13 #include "SurfacePipeFactory.h"
     14 
     15 using namespace mozilla::gfx;
     16 
     17 namespace mozilla {
     18 namespace image {
     19 
     20 static LazyLogModule sWebPLog("WebPDecoder");
     21 
     22 nsWebPDecoder::nsWebPDecoder(RasterImage* aImage)
     23    : Decoder(aImage),
     24      mDecoder(nullptr),
     25      mBlend(BlendMethod::OVER),
     26      mDisposal(DisposalMethod::KEEP),
     27      mTimeout(FrameTimeout::Forever()),
     28      mFormat(SurfaceFormat::OS_RGBX),
     29      mLastRow(0),
     30      mCurrentFrame(0),
     31      mData(nullptr),
     32      mLength(0),
     33      mIteratorComplete(false),
     34      mNeedDemuxer(true),
     35      mGotColorProfile(false) {
     36  MOZ_LOG(sWebPLog, LogLevel::Debug,
     37          ("[this=%p] nsWebPDecoder::nsWebPDecoder", this));
     38 }
     39 
     40 nsWebPDecoder::~nsWebPDecoder() {
     41  MOZ_LOG(sWebPLog, LogLevel::Debug,
     42          ("[this=%p] nsWebPDecoder::~nsWebPDecoder", this));
     43  if (mDecoder) {
     44    WebPIDelete(mDecoder);
     45    WebPFreeDecBuffer(&mBuffer);
     46  }
     47 }
     48 
     49 LexerResult nsWebPDecoder::ReadData() {
     50  MOZ_ASSERT(mData);
     51  MOZ_ASSERT(mLength > 0);
     52 
     53  WebPDemuxer* demuxer = nullptr;
     54  bool complete = mIteratorComplete;
     55 
     56  if (mNeedDemuxer) {
     57    WebPDemuxState state;
     58    WebPData fragment;
     59    fragment.bytes = mData;
     60    fragment.size = mLength;
     61 
     62    demuxer = WebPDemuxPartial(&fragment, &state);
     63    if (state == WEBP_DEMUX_PARSE_ERROR) {
     64      MOZ_LOG(
     65          sWebPLog, LogLevel::Error,
     66          ("[this=%p] nsWebPDecoder::ReadData -- demux parse error\n", this));
     67      WebPDemuxDelete(demuxer);
     68      return LexerResult(TerminalState::FAILURE);
     69    }
     70 
     71    if (state == WEBP_DEMUX_PARSING_HEADER) {
     72      WebPDemuxDelete(demuxer);
     73      return LexerResult(Yield::NEED_MORE_DATA);
     74    }
     75 
     76    if (!demuxer) {
     77      MOZ_LOG(sWebPLog, LogLevel::Error,
     78              ("[this=%p] nsWebPDecoder::ReadData -- no demuxer\n", this));
     79      return LexerResult(TerminalState::FAILURE);
     80    }
     81 
     82    complete = complete || state == WEBP_DEMUX_DONE;
     83  }
     84 
     85  LexerResult rv(TerminalState::FAILURE);
     86  if (!HasSize()) {
     87    rv = ReadHeader(demuxer, complete);
     88  } else {
     89    rv = ReadPayload(demuxer, complete);
     90  }
     91 
     92  WebPDemuxDelete(demuxer);
     93  return rv;
     94 }
     95 
     96 LexerResult nsWebPDecoder::DoDecode(SourceBufferIterator& aIterator,
     97                                    IResumable* aOnResume) {
     98  while (true) {
     99    SourceBufferIterator::State state = SourceBufferIterator::COMPLETE;
    100    if (!mIteratorComplete) {
    101      state = aIterator.AdvanceOrScheduleResume(SIZE_MAX, aOnResume);
    102 
    103      // We need to remember since we can't advance a complete iterator.
    104      mIteratorComplete = state == SourceBufferIterator::COMPLETE;
    105    }
    106 
    107    if (state == SourceBufferIterator::WAITING) {
    108      return LexerResult(Yield::NEED_MORE_DATA);
    109    }
    110 
    111    LexerResult rv = UpdateBuffer(aIterator, state);
    112    if (rv.is<Yield>() && rv.as<Yield>() == Yield::NEED_MORE_DATA) {
    113      // We need to check the iterator to see if more is available before
    114      // giving up unless we are already complete.
    115      if (mIteratorComplete) {
    116        MOZ_LOG(sWebPLog, LogLevel::Error,
    117                ("[this=%p] nsWebPDecoder::DoDecode -- read all data, "
    118                 "but needs more\n",
    119                 this));
    120        return LexerResult(TerminalState::FAILURE);
    121      }
    122      continue;
    123    }
    124 
    125    return rv;
    126  }
    127 }
    128 
    129 LexerResult nsWebPDecoder::UpdateBuffer(SourceBufferIterator& aIterator,
    130                                        SourceBufferIterator::State aState) {
    131  MOZ_ASSERT(!HasError(), "Shouldn't call DoDecode after error!");
    132 
    133  switch (aState) {
    134    case SourceBufferIterator::READY:
    135      if (!aIterator.IsContiguous()) {
    136        // We need to buffer. This should be rare, but expensive.
    137        break;
    138      }
    139      if (!mData) {
    140        // For as long as we hold onto an iterator, we know the data pointers
    141        // to the chunks cannot change underneath us, so save the pointer to
    142        // the first block.
    143        MOZ_ASSERT(mLength == 0);
    144        mData = reinterpret_cast<const uint8_t*>(aIterator.Data());
    145      }
    146      mLength += aIterator.Length();
    147      return ReadData();
    148    case SourceBufferIterator::COMPLETE:
    149      if (!mData) {
    150        // We must have hit an error, such as an OOM, when buffering the
    151        // first set of encoded data.
    152        MOZ_LOG(
    153            sWebPLog, LogLevel::Error,
    154            ("[this=%p] nsWebPDecoder::DoDecode -- complete no data\n", this));
    155        return LexerResult(TerminalState::FAILURE);
    156      }
    157      return ReadData();
    158    default:
    159      MOZ_LOG(sWebPLog, LogLevel::Error,
    160              ("[this=%p] nsWebPDecoder::DoDecode -- bad state\n", this));
    161      return LexerResult(TerminalState::FAILURE);
    162  }
    163 
    164  // We need to buffer. If we have no data buffered, we need to get everything
    165  // from the first chunk of the source buffer before appending the new data.
    166  if (mBufferedData.empty()) {
    167    MOZ_ASSERT(mData);
    168    MOZ_ASSERT(mLength > 0);
    169 
    170    if (!mBufferedData.append(mData, mLength)) {
    171      MOZ_LOG(sWebPLog, LogLevel::Error,
    172              ("[this=%p] nsWebPDecoder::DoDecode -- oom, initialize %zu\n",
    173               this, mLength));
    174      return LexerResult(TerminalState::FAILURE);
    175    }
    176 
    177    MOZ_LOG(sWebPLog, LogLevel::Debug,
    178            ("[this=%p] nsWebPDecoder::DoDecode -- buffered %zu bytes\n", this,
    179             mLength));
    180  }
    181 
    182  // Append the incremental data from the iterator.
    183  if (!mBufferedData.append(aIterator.Data(), aIterator.Length())) {
    184    MOZ_LOG(sWebPLog, LogLevel::Error,
    185            ("[this=%p] nsWebPDecoder::DoDecode -- oom, append %zu on %zu\n",
    186             this, aIterator.Length(), mBufferedData.length()));
    187    return LexerResult(TerminalState::FAILURE);
    188  }
    189 
    190  MOZ_LOG(sWebPLog, LogLevel::Debug,
    191          ("[this=%p] nsWebPDecoder::DoDecode -- buffered %zu -> %zu bytes\n",
    192           this, aIterator.Length(), mBufferedData.length()));
    193  mData = mBufferedData.begin();
    194  mLength = mBufferedData.length();
    195  return ReadData();
    196 }
    197 
    198 nsresult nsWebPDecoder::CreateFrame(const OrientedIntRect& aFrameRect) {
    199  MOZ_ASSERT(HasSize());
    200  MOZ_ASSERT(!mDecoder);
    201 
    202  MOZ_LOG(
    203      sWebPLog, LogLevel::Debug,
    204      ("[this=%p] nsWebPDecoder::CreateFrame -- frame %u, (%d, %d) %d x %d\n",
    205       this, mCurrentFrame, aFrameRect.x, aFrameRect.y, aFrameRect.width,
    206       aFrameRect.height));
    207 
    208  if (aFrameRect.width <= 0 || aFrameRect.height <= 0) {
    209    MOZ_LOG(sWebPLog, LogLevel::Error,
    210            ("[this=%p] nsWebPDecoder::CreateFrame -- bad frame rect\n", this));
    211    return NS_ERROR_FAILURE;
    212  }
    213 
    214  // If this is our first frame in an animation and it doesn't cover the
    215  // full frame, then we are transparent even if there is no alpha
    216  if (mCurrentFrame == 0 && !aFrameRect.IsEqualEdges(FullFrame())) {
    217    MOZ_ASSERT(HasAnimation());
    218    mFormat = SurfaceFormat::OS_RGBA;
    219    PostHasTransparency();
    220  }
    221 
    222  if (!WebPInitDecBuffer(&mBuffer)) {
    223    MOZ_LOG(
    224        sWebPLog, LogLevel::Error,
    225        ("[this=%p] nsWebPDecoder::CreateFrame -- WebPInitDecBuffer failed\n",
    226         this));
    227    return NS_ERROR_FAILURE;
    228  }
    229 
    230  switch (SurfaceFormat::OS_RGBA) {
    231    case SurfaceFormat::B8G8R8A8:
    232      mBuffer.colorspace = MODE_BGRA;
    233      break;
    234    case SurfaceFormat::A8R8G8B8:
    235      mBuffer.colorspace = MODE_ARGB;
    236      break;
    237    case SurfaceFormat::R8G8B8A8:
    238      mBuffer.colorspace = MODE_RGBA;
    239      break;
    240    default:
    241      MOZ_ASSERT_UNREACHABLE("Unknown OS_RGBA");
    242      return NS_ERROR_FAILURE;
    243  }
    244 
    245  mDecoder = WebPINewDecoder(&mBuffer);
    246  if (!mDecoder) {
    247    MOZ_LOG(sWebPLog, LogLevel::Error,
    248            ("[this=%p] nsWebPDecoder::CreateFrame -- create decoder error\n",
    249             this));
    250    return NS_ERROR_FAILURE;
    251  }
    252 
    253  // WebP doesn't guarantee that the alpha generated matches the hint in the
    254  // header, so we always need to claim the input is BGRA. If the output is
    255  // BGRX, swizzling will mask off the alpha channel.
    256  SurfaceFormat inFormat = SurfaceFormat::OS_RGBA;
    257 
    258  SurfacePipeFlags pipeFlags = SurfacePipeFlags();
    259  if (mFormat == SurfaceFormat::OS_RGBA &&
    260      !(GetSurfaceFlags() & SurfaceFlags::NO_PREMULTIPLY_ALPHA)) {
    261    pipeFlags |= SurfacePipeFlags::PREMULTIPLY_ALPHA;
    262  }
    263 
    264  Maybe<AnimationParams> animParams;
    265  if (!IsFirstFrameDecode()) {
    266    animParams.emplace(aFrameRect.ToUnknownRect(), mTimeout, mCurrentFrame,
    267                       mBlend, mDisposal);
    268  }
    269 
    270  Maybe<SurfacePipe> pipe = SurfacePipeFactory::CreateSurfacePipe(
    271      this, Size(), OutputSize(), aFrameRect, inFormat, mFormat, animParams,
    272      mTransform, pipeFlags);
    273  if (!pipe) {
    274    MOZ_LOG(sWebPLog, LogLevel::Error,
    275            ("[this=%p] nsWebPDecoder::CreateFrame -- no pipe\n", this));
    276    return NS_ERROR_FAILURE;
    277  }
    278 
    279  mFrameRect = aFrameRect;
    280  mPipe = std::move(*pipe);
    281  return NS_OK;
    282 }
    283 
    284 void nsWebPDecoder::EndFrame() {
    285  MOZ_ASSERT(HasSize());
    286  MOZ_ASSERT(mDecoder);
    287 
    288  auto opacity = mFormat == SurfaceFormat::OS_RGBA ? Opacity::SOME_TRANSPARENCY
    289                                                   : Opacity::FULLY_OPAQUE;
    290 
    291  MOZ_LOG(sWebPLog, LogLevel::Debug,
    292          ("[this=%p] nsWebPDecoder::EndFrame -- frame %u, opacity %d, "
    293           "disposal %d, timeout %d, blend %d\n",
    294           this, mCurrentFrame, (int)opacity, (int)mDisposal,
    295           mTimeout.AsEncodedValueDeprecated(), (int)mBlend));
    296 
    297  PostFrameStop(opacity);
    298  WebPIDelete(mDecoder);
    299  WebPFreeDecBuffer(&mBuffer);
    300  mDecoder = nullptr;
    301  mLastRow = 0;
    302  ++mCurrentFrame;
    303 }
    304 
    305 void nsWebPDecoder::ApplyColorProfile(const char* aProfile, size_t aLength) {
    306  MOZ_ASSERT(!mGotColorProfile);
    307  mGotColorProfile = true;
    308 
    309  if (mCMSMode == CMSMode::Off || !GetCMSOutputProfile() ||
    310      (mCMSMode == CMSMode::TaggedOnly && !aProfile)) {
    311    return;
    312  }
    313 
    314  if (!aProfile) {
    315    MOZ_LOG(sWebPLog, LogLevel::Debug,
    316            ("[this=%p] nsWebPDecoder::ApplyColorProfile -- not tagged, use "
    317             "sRGB transform\n",
    318             this));
    319    mTransform = GetCMSsRGBTransform(SurfaceFormat::OS_RGBA);
    320    return;
    321  }
    322 
    323  mInProfile = qcms_profile_from_memory(aProfile, aLength);
    324  if (!mInProfile) {
    325    MOZ_LOG(
    326        sWebPLog, LogLevel::Error,
    327        ("[this=%p] nsWebPDecoder::ApplyColorProfile -- bad color profile\n",
    328         this));
    329    return;
    330  }
    331 
    332  uint32_t profileSpace = qcms_profile_get_color_space(mInProfile);
    333  if (profileSpace != icSigRgbData) {
    334    // WebP doesn't produce grayscale data, this must be corrupt.
    335    MOZ_LOG(sWebPLog, LogLevel::Error,
    336            ("[this=%p] nsWebPDecoder::ApplyColorProfile -- ignoring non-rgb "
    337             "color profile\n",
    338             this));
    339    return;
    340  }
    341 
    342  // Calculate rendering intent.
    343  int intent = gfxPlatform::GetRenderingIntent();
    344  if (intent == -1) {
    345    intent = qcms_profile_get_rendering_intent(mInProfile);
    346  }
    347 
    348  // Create the color management transform.
    349  qcms_data_type type = gfxPlatform::GetCMSOSRGBAType();
    350  mTransform = qcms_transform_create(mInProfile, type, GetCMSOutputProfile(),
    351                                     type, (qcms_intent)intent);
    352  MOZ_LOG(sWebPLog, LogLevel::Debug,
    353          ("[this=%p] nsWebPDecoder::ApplyColorProfile -- use tagged "
    354           "transform\n",
    355           this));
    356 }
    357 
    358 LexerResult nsWebPDecoder::ReadHeader(WebPDemuxer* aDemuxer, bool aIsComplete) {
    359  MOZ_ASSERT(aDemuxer);
    360 
    361  MOZ_LOG(
    362      sWebPLog, LogLevel::Debug,
    363      ("[this=%p] nsWebPDecoder::ReadHeader -- %zu bytes\n", this, mLength));
    364 
    365  uint32_t flags = WebPDemuxGetI(aDemuxer, WEBP_FF_FORMAT_FLAGS);
    366 
    367  if (!IsMetadataDecode() && !mGotColorProfile) {
    368    if (flags & WebPFeatureFlags::ICCP_FLAG) {
    369      WebPChunkIterator iter;
    370      if (WebPDemuxGetChunk(aDemuxer, "ICCP", 1, &iter)) {
    371        ApplyColorProfile(reinterpret_cast<const char*>(iter.chunk.bytes),
    372                          iter.chunk.size);
    373        WebPDemuxReleaseChunkIterator(&iter);
    374 
    375      } else {
    376        if (!aIsComplete) {
    377          return LexerResult(Yield::NEED_MORE_DATA);
    378        }
    379 
    380        MOZ_LOG(sWebPLog, LogLevel::Warning,
    381                ("[this=%p] nsWebPDecoder::ReadHeader header specified ICCP "
    382                 "but no ICCP chunk found, ignoring\n",
    383                 this));
    384 
    385        ApplyColorProfile(nullptr, 0);
    386      }
    387    } else {
    388      ApplyColorProfile(nullptr, 0);
    389    }
    390  }
    391 
    392  if (flags & WebPFeatureFlags::ANIMATION_FLAG) {
    393    // The demuxer only knows how many frames it will have once it has the
    394    // complete buffer.
    395    if (WantsFrameCount() && !aIsComplete) {
    396      return LexerResult(Yield::NEED_MORE_DATA);
    397    }
    398 
    399    // A metadata decode expects to get the correct first frame timeout which
    400    // sadly is not provided by the normal WebP header parsing.
    401    WebPIterator iter;
    402    if (!WebPDemuxGetFrame(aDemuxer, 1, &iter)) {
    403      return aIsComplete ? LexerResult(TerminalState::FAILURE)
    404                         : LexerResult(Yield::NEED_MORE_DATA);
    405    }
    406 
    407    PostIsAnimated(FrameTimeout::FromRawMilliseconds(iter.duration));
    408    WebPDemuxReleaseIterator(&iter);
    409 
    410    uint32_t loopCount = WebPDemuxGetI(aDemuxer, WEBP_FF_LOOP_COUNT);
    411    if (loopCount > INT32_MAX) {
    412      loopCount = INT32_MAX;
    413    }
    414 
    415    MOZ_LOG(sWebPLog, LogLevel::Debug,
    416            ("[this=%p] nsWebPDecoder::ReadHeader -- loop count %u\n", this,
    417             loopCount));
    418    PostLoopCount(static_cast<int32_t>(loopCount) - 1);
    419  } else {
    420    // Single frames don't need a demuxer to be created.
    421    mNeedDemuxer = false;
    422  }
    423 
    424  uint32_t width = WebPDemuxGetI(aDemuxer, WEBP_FF_CANVAS_WIDTH);
    425  uint32_t height = WebPDemuxGetI(aDemuxer, WEBP_FF_CANVAS_HEIGHT);
    426  if (width > INT32_MAX || height > INT32_MAX) {
    427    return LexerResult(TerminalState::FAILURE);
    428  }
    429 
    430  PostSize(width, height);
    431 
    432  if (WantsFrameCount()) {
    433    uint32_t frameCount = WebPDemuxGetI(aDemuxer, WEBP_FF_FRAME_COUNT);
    434    PostFrameCount(frameCount);
    435  }
    436 
    437  bool alpha = flags & WebPFeatureFlags::ALPHA_FLAG;
    438  if (alpha) {
    439    mFormat = SurfaceFormat::OS_RGBA;
    440    PostHasTransparency();
    441  }
    442 
    443  MOZ_LOG(sWebPLog, LogLevel::Debug,
    444          ("[this=%p] nsWebPDecoder::ReadHeader -- %u x %u, alpha %d, "
    445           "animation %d, metadata decode %d, first frame decode %d\n",
    446           this, width, height, alpha, HasAnimation(), IsMetadataDecode(),
    447           IsFirstFrameDecode()));
    448 
    449  if (IsMetadataDecode()) {
    450    return LexerResult(TerminalState::SUCCESS);
    451  }
    452 
    453  return ReadPayload(aDemuxer, aIsComplete);
    454 }
    455 
    456 LexerResult nsWebPDecoder::ReadPayload(WebPDemuxer* aDemuxer,
    457                                       bool aIsComplete) {
    458  if (!HasAnimation()) {
    459    auto rv = ReadSingle(mData, mLength, FullFrame());
    460    if (rv.is<TerminalState>() &&
    461        rv.as<TerminalState>() == TerminalState::SUCCESS) {
    462      PostDecodeDone();
    463    }
    464    return rv;
    465  }
    466  return ReadMultiple(aDemuxer, aIsComplete);
    467 }
    468 
    469 LexerResult nsWebPDecoder::ReadSingle(const uint8_t* aData, size_t aLength,
    470                                      const OrientedIntRect& aFrameRect) {
    471  MOZ_ASSERT(!IsMetadataDecode());
    472  MOZ_ASSERT(aData);
    473  MOZ_ASSERT(aLength > 0);
    474 
    475  MOZ_LOG(
    476      sWebPLog, LogLevel::Debug,
    477      ("[this=%p] nsWebPDecoder::ReadSingle -- %zu bytes\n", this, aLength));
    478 
    479  if (!mDecoder && NS_FAILED(CreateFrame(aFrameRect))) {
    480    return LexerResult(TerminalState::FAILURE);
    481  }
    482 
    483  bool complete;
    484  do {
    485    VP8StatusCode status = WebPIUpdate(mDecoder, aData, aLength);
    486    switch (status) {
    487      case VP8_STATUS_OK:
    488        complete = true;
    489        break;
    490      case VP8_STATUS_SUSPENDED:
    491        complete = false;
    492        break;
    493      default:
    494        MOZ_LOG(sWebPLog, LogLevel::Error,
    495                ("[this=%p] nsWebPDecoder::ReadSingle -- append error %d\n",
    496                 this, status));
    497        return LexerResult(TerminalState::FAILURE);
    498    }
    499 
    500    int lastRow = -1;
    501    int width = 0;
    502    int height = 0;
    503    int stride = 0;
    504    uint8_t* rowStart =
    505        WebPIDecGetRGB(mDecoder, &lastRow, &width, &height, &stride);
    506 
    507    MOZ_LOG(
    508        sWebPLog, LogLevel::Debug,
    509        ("[this=%p] nsWebPDecoder::ReadSingle -- complete %d, read %d rows, "
    510         "has %d rows available\n",
    511         this, complete, mLastRow, lastRow));
    512 
    513    if (!rowStart || lastRow == -1 || lastRow == mLastRow) {
    514      return LexerResult(Yield::NEED_MORE_DATA);
    515    }
    516 
    517    if (width != mFrameRect.width || height != mFrameRect.height ||
    518        stride < mFrameRect.width * 4 || lastRow > mFrameRect.height) {
    519      MOZ_LOG(sWebPLog, LogLevel::Error,
    520              ("[this=%p] nsWebPDecoder::ReadSingle -- bad (w,h,s) = (%d, %d, "
    521               "%d)\n",
    522               this, width, height, stride));
    523      return LexerResult(TerminalState::FAILURE);
    524    }
    525 
    526    for (int row = mLastRow; row < lastRow; row++) {
    527      uint32_t* src = reinterpret_cast<uint32_t*>(rowStart + row * stride);
    528      WriteState result = mPipe.WriteBuffer(src);
    529 
    530      Maybe<SurfaceInvalidRect> invalidRect = mPipe.TakeInvalidRect();
    531      if (invalidRect) {
    532        PostInvalidation(invalidRect->mInputSpaceRect,
    533                         Some(invalidRect->mOutputSpaceRect));
    534      }
    535 
    536      if (result == WriteState::FAILURE) {
    537        MOZ_LOG(sWebPLog, LogLevel::Error,
    538                ("[this=%p] nsWebPDecoder::ReadSingle -- write pixels error\n",
    539                 this));
    540        return LexerResult(TerminalState::FAILURE);
    541      }
    542 
    543      if (result == WriteState::FINISHED) {
    544        MOZ_ASSERT(row == lastRow - 1, "There was more data to read?");
    545        complete = true;
    546        break;
    547      }
    548    }
    549 
    550    mLastRow = lastRow;
    551  } while (!complete);
    552 
    553  if (!complete) {
    554    return LexerResult(Yield::NEED_MORE_DATA);
    555  }
    556 
    557  EndFrame();
    558  return LexerResult(TerminalState::SUCCESS);
    559 }
    560 
    561 LexerResult nsWebPDecoder::ReadMultiple(WebPDemuxer* aDemuxer,
    562                                        bool aIsComplete) {
    563  MOZ_ASSERT(!IsMetadataDecode());
    564  MOZ_ASSERT(aDemuxer);
    565 
    566  MOZ_LOG(sWebPLog, LogLevel::Debug,
    567          ("[this=%p] nsWebPDecoder::ReadMultiple\n", this));
    568 
    569  bool complete = aIsComplete;
    570  WebPIterator iter;
    571  auto rv = LexerResult(Yield::NEED_MORE_DATA);
    572  if (WebPDemuxGetFrame(aDemuxer, mCurrentFrame + 1, &iter)) {
    573    switch (iter.blend_method) {
    574      case WEBP_MUX_BLEND:
    575        mBlend = BlendMethod::OVER;
    576        break;
    577      case WEBP_MUX_NO_BLEND:
    578        mBlend = BlendMethod::SOURCE;
    579        break;
    580      default:
    581        MOZ_ASSERT_UNREACHABLE("Unhandled blend method");
    582        break;
    583    }
    584 
    585    switch (iter.dispose_method) {
    586      case WEBP_MUX_DISPOSE_NONE:
    587        mDisposal = DisposalMethod::KEEP;
    588        break;
    589      case WEBP_MUX_DISPOSE_BACKGROUND:
    590        mDisposal = DisposalMethod::CLEAR;
    591        break;
    592      default:
    593        MOZ_ASSERT_UNREACHABLE("Unhandled dispose method");
    594        break;
    595    }
    596 
    597    mFormat = iter.has_alpha || mCurrentFrame > 0 ? SurfaceFormat::OS_RGBA
    598                                                  : SurfaceFormat::OS_RGBX;
    599    mTimeout = FrameTimeout::FromRawMilliseconds(iter.duration);
    600    OrientedIntRect frameRect(iter.x_offset, iter.y_offset, iter.width,
    601                              iter.height);
    602 
    603    rv = ReadSingle(iter.fragment.bytes, iter.fragment.size, frameRect);
    604    complete = complete && !WebPDemuxNextFrame(&iter);
    605    WebPDemuxReleaseIterator(&iter);
    606  }
    607 
    608  if (rv.is<TerminalState>() &&
    609      rv.as<TerminalState>() == TerminalState::SUCCESS) {
    610    // If we extracted one frame, and it is not the last, we need to yield to
    611    // the lexer to allow the upper layers to acknowledge the frame.
    612    if (!complete && !IsFirstFrameDecode()) {
    613      rv = LexerResult(Yield::OUTPUT_AVAILABLE);
    614    } else {
    615      PostDecodeDone();
    616    }
    617  }
    618 
    619  return rv;
    620 }
    621 
    622 Maybe<glean::impl::MemoryDistributionMetric> nsWebPDecoder::SpeedMetric()
    623    const {
    624  return Some(glean::image_decode::speed_webp);
    625 }
    626 
    627 }  // namespace image
    628 }  // namespace mozilla
	tor-browser The Tor Browser
	git clone https://git.dasho.dev/tor-browser.git
	Log \| Files \| Refs \| README \| LICENSE