SkWuffsCodec.cpp File Reference

#include "include/codec/SkCodec.h"
#include "include/codec/SkCodecAnimation.h"
#include "include/codec/SkEncodedImageFormat.h"
#include "include/codec/SkGifDecoder.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkSize.h"
#include "include/core/SkStream.h"
#include "include/core/SkTypes.h"
#include "include/private/SkEncodedInfo.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTo.h"
#include "modules/skcms/skcms.h"
#include "src/codec/SkCodecPriv.h"
#include "src/codec/SkFrameHolder.h"
#include "src/codec/SkSampler.h"
#include "src/codec/SkScalingCodec.h"
#include "src/core/SkDraw.h"
#include "src/core/SkRasterClip.h"
#include "src/core/SkStreamPriv.h"
#include <climits>
#include <cstdint>
#include <cstring>
#include <memory>
#include <utility>
#include <vector>
#include "wuffs-v0.3.c"

Go to the source code of this file.

Classes
class	SkWuffsFrame
class	SkWuffsFrameHolder
class	SkWuffsCodec

Namespaces
namespace	SkGifDecoder

Macros
#define	SK_WUFFS_CODEC_BUFFER_SIZE   4096
#define	SK_WUFFS_INITIALIZE_FLAGS   WUFFS_INITIALIZE__DEFAULT_OPTIONS

Functions
static bool	fill_buffer (wuffs_base__io_buffer *b, SkStream *s)
static bool	seek_buffer (wuffs_base__io_buffer *b, SkStream *s, uint64_t pos)
static SkCodecAnimation::DisposalMethod	wuffs_disposal_to_skia_disposal (wuffs_base__animation_disposal w)
static SkAlphaType	to_alpha_type (bool opaque)
static SkCodec::Result	reset_and_decode_image_config (wuffs_gif__decoder *decoder, wuffs_base__image_config *imgcfg, wuffs_base__io_buffer *b, SkStream *s)
SK_API bool	SkGifDecoder::IsGif (const void *, size_t)
std::unique_ptr< SkCodec >	SkGifDecoder::MakeFromStream (std::unique_ptr< SkStream > stream, SkCodec::SelectionPolicy selectionPolicy, SkCodec::Result *result)
SK_API std::unique_ptr< SkCodec >	SkGifDecoder::Decode (std::unique_ptr< SkStream >, SkCodec::Result *, SkCodecs::DecodeContext=nullptr)
SK_API std::unique_ptr< SkCodec >	SkGifDecoder::Decode (sk_sp< SkData >, SkCodec::Result *, SkCodecs::DecodeContext=nullptr)

Macro Definition Documentation

SK_WUFFS_CODEC_BUFFER_SIZE

#define SK_WUFFS_CODEC_BUFFER_SIZE   4096

Definition at line 66 of file SkWuffsCodec.cpp.

SK_WUFFS_INITIALIZE_FLAGS

#define SK_WUFFS_INITIALIZE_FLAGS   WUFFS_INITIALIZE__DEFAULT_OPTIONS

Definition at line 81 of file SkWuffsCodec.cpp.

Function Documentation

fill_buffer()

static bool fill_buffer ( wuffs_base__io_buffer *  b, SkStream *  s  )

static

Definition at line 84 of file SkWuffsCodec.cpp.

                                                               {
    b->compact();
    size_t num_read = s->read(b->data.ptr + b->meta.wi, b->data.len - b->meta.wi);
    b->meta.wi += num_read;
    // We hard-code false instead of s->isAtEnd(). In theory, Skia's
    // SkStream::isAtEnd() method has the same semantics as Wuffs'
    // wuffs_base__io_buffer_meta::closed field. Specifically, both are false
    // when reading from a network socket when all bytes *available right now*
    // have been read but there might be more later.
    //
    // However, SkStream is designed around synchronous I/O. The SkStream::read
    // method does not take a callback and, per its documentation comments, a
    // read request for N bytes should block until a full N bytes are
    // available. In practice, Blink's SkStream subclass builds on top of async
    // I/O and cannot afford to block. While it satisfies "the letter of the
    // law", in terms of what the C++ compiler needs, it does not satisfy "the
    // spirit of the law". Its read() can return short without blocking and its
    // isAtEnd() can return false positives.
    //
    // When closed is true, Wuffs treats incomplete input as a fatal error
    // instead of a recoverable "short read" suspension. We therefore hard-code
    // false and return kIncompleteInput (instead of kErrorInInput) up the call
    // stack even if the SkStream isAtEnd. The caller usually has more context
    // (more than what's in the SkStream) to differentiate the two, like this:
    // https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/platform/image-decoders/gif/gif_image_decoder.cc;l=115;drc=277dcc4d810ae4c0286d8af96d270ed9b686c5ff
    b->meta.closed = false;
    return num_read > 0;
}

reset_and_decode_image_config()

static SkCodec::Result reset_and_decode_image_config ( wuffs_gif__decoder *  decoder, wuffs_base__image_config *  imgcfg, wuffs_base__io_buffer *  b, SkStream *  s  )

static

Definition at line 147 of file SkWuffsCodec.cpp.

                                                                                  {
    // Calling decoder->initialize will memset most or all of it to zero,
    // depending on SK_WUFFS_INITIALIZE_FLAGS.
    wuffs_base__status status =
        decoder->initialize(sizeof__wuffs_gif__decoder(), WUFFS_VERSION, SK_WUFFS_INITIALIZE_FLAGS);
    if (status.repr != nullptr) {
        SkCodecPrintf("initialize: %s", status.message());
        return SkCodec::kInternalError;
    }
 
    // See https://bugs.chromium.org/p/skia/issues/detail?id=12055
    decoder->set_quirk_enabled(WUFFS_GIF__QUIRK_IGNORE_TOO_MUCH_PIXEL_DATA, true);
 
    while (true) {
        status = decoder->decode_image_config(imgcfg, b);
        if (status.repr == nullptr) {
            break;
        } else if (status.repr != wuffs_base__suspension__short_read) {
            SkCodecPrintf("decode_image_config: %s", status.message());
            return SkCodec::kErrorInInput;
        } else if (!fill_buffer(b, s)) {
            return SkCodec::kIncompleteInput;
        }
    }
 
    // A GIF image's natural color model is indexed color: 1 byte per pixel,
    // indexing a 256-element palette.
    //
    // For Skia, we override that to decode to 4 bytes per pixel, BGRA or RGBA.
    uint32_t pixfmt = WUFFS_BASE__PIXEL_FORMAT__INVALID;
    switch (kN32_SkColorType) {
        case kBGRA_8888_SkColorType:
            pixfmt = WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL;
            break;
        case kRGBA_8888_SkColorType:
            pixfmt = WUFFS_BASE__PIXEL_FORMAT__RGBA_NONPREMUL;
            break;
        default:
            return SkCodec::kInternalError;
    }
    if (imgcfg) {
        imgcfg->pixcfg.set(pixfmt, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, imgcfg->pixcfg.width(),
                           imgcfg->pixcfg.height());
    }
 
    return SkCodec::kSuccess;
}

seek_buffer()

static bool seek_buffer ( wuffs_base__io_buffer *  b, SkStream *  s, uint64_t  pos  )

static

Definition at line 113 of file SkWuffsCodec.cpp.

                                                                             {
    // Try to re-position the io_buffer's meta.ri read-index first, which is
    // cheaper than seeking in the backing SkStream.
    if ((pos >= b->meta.pos) && (pos - b->meta.pos <= b->meta.wi)) {
        b->meta.ri = pos - b->meta.pos;
        return true;
    }
    // Seek in the backing SkStream.
    if ((pos > SIZE_MAX) || (!s->seek(pos))) {
        return false;
    }
    b->meta.wi = 0;
    b->meta.ri = 0;
    b->meta.pos = pos;
    b->meta.closed = false;
    return true;
}

to_alpha_type()

static SkAlphaType to_alpha_type ( bool  opaque )

static

Definition at line 143 of file SkWuffsCodec.cpp.

                                              {
    return opaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
}

wuffs_disposal_to_skia_disposal()

static SkCodecAnimation::DisposalMethod wuffs_disposal_to_skia_disposal ( wuffs_base__animation_disposal  w )

static

Definition at line 131 of file SkWuffsCodec.cpp.

                                      {
    switch (w) {
        case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND:
            return SkCodecAnimation::DisposalMethod::kRestoreBGColor;
        case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS:
            return SkCodecAnimation::DisposalMethod::kRestorePrevious;
        default:
            return SkCodecAnimation::DisposalMethod::kKeep;
    }
}