/*
* Copyright 2006 The Android Open Source Project
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "SkColor.h"
#include "SkColorPriv.h"
#include "SkColorTable.h"
#include "SkImageDecoder.h"
#include "SkRTConf.h"
#include "SkScaledBitmapSampler.h"
#include "SkStream.h"
#include "SkTemplates.h"
#include "SkUtils.h"
#include "gif_lib.h"
class SkGIFImageDecoder : public SkImageDecoder {
public:
Format getFormat() const override {
return kGIF_Format;
}
protected:
Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override;
private:
typedef SkImageDecoder INHERITED;
};
static const uint8_t gStartingIterlaceYValue[] = {
0, 4, 2, 1
};
static const uint8_t gDeltaIterlaceYValue[] = {
8, 8, 4, 2
};
SK_CONF_DECLARE(bool, c_suppressGIFImageDecoderWarnings,
"images.gif.suppressDecoderWarnings", true,
"Suppress GIF warnings and errors when calling image decode "
"functions.");
/* Implement the GIF interlace algorithm in an iterator.
1) grab every 8th line beginning at 0
2) grab every 8th line beginning at 4
3) grab every 4th line beginning at 2
4) grab every 2nd line beginning at 1
*/
class GifInterlaceIter {
public:
GifInterlaceIter(int height) : fHeight(height) {
fStartYPtr = gStartingIterlaceYValue;
fDeltaYPtr = gDeltaIterlaceYValue;
fCurrY = *fStartYPtr++;
fDeltaY = *fDeltaYPtr++;
}
int currY() const {
SkASSERT(fStartYPtr);
SkASSERT(fDeltaYPtr);
return fCurrY;
}
void next() {
SkASSERT(fStartYPtr);
SkASSERT(fDeltaYPtr);
int y = fCurrY + fDeltaY;
// We went from an if statement to a while loop so that we iterate
// through fStartYPtr until a valid row is found. This is so that images
// that are smaller than 5x5 will not trash memory.
while (y >= fHeight) {
if (gStartingIterlaceYValue +
SK_ARRAY_COUNT(gStartingIterlaceYValue) == fStartYPtr) {
// we done
SkDEBUGCODE(fStartYPtr = nullptr;)
SkDEBUGCODE(fDeltaYPtr = nullptr;)
y = 0;
} else {
y = *fStartYPtr++;
fDeltaY = *fDeltaYPtr++;
}
}
fCurrY = y;
}
private:
const int fHeight;
int fCurrY;
int fDeltaY;
const uint8_t* fStartYPtr;
const uint8_t* fDeltaYPtr;
};
///////////////////////////////////////////////////////////////////////////////
static int DecodeCallBackProc(GifFileType* fileType, GifByteType* out,
int size) {
SkStream* stream = (SkStream*) fileType->UserData;
return (int) stream->read(out, size);
}
void CheckFreeExtension(SavedImage* Image) {
if (Image->ExtensionBlocks) {
#if GIFLIB_MAJOR < 5
FreeExtension(Image);
#else
GifFreeExtensions(&Image->ExtensionBlockCount, &Image->ExtensionBlocks);
#endif
}
}
// return nullptr on failure
static const ColorMapObject* find_colormap(const GifFileType* gif) {
const ColorMapObject* cmap = gif->Image.ColorMap;
if (nullptr == cmap) {
cmap = gif->SColorMap;
}
if (nullptr == cmap) {
// no colormap found
return nullptr;
}
// some sanity checks
if (cmap && ((unsigned)cmap->ColorCount > 256 ||
cmap->ColorCount != (1 << cmap->BitsPerPixel))) {
cmap = nullptr;
}
return cmap;
}
// return -1 if not found (i.e. we're completely opaque)
static int find_transpIndex(const SavedImage& image, int colorCount) {
int transpIndex = -1;
for (int i = 0; i < image.ExtensionBlockCount; ++i) {
const ExtensionBlock* eb = image.ExtensionBlocks + i;
if (eb->Function == 0xF9 && eb->ByteCount == 4) {
if (eb->Bytes[0] & 1) {
transpIndex = (unsigned char)eb->Bytes[3];
// check for valid transpIndex
if (transpIndex >= colorCount) {
transpIndex = -1;
}
break;
}
}
}
return transpIndex;
}
static SkImageDecoder::Result error_return(const SkBitmap& bm, const char msg[]) {
if (!c_suppressGIFImageDecoderWarnings) {
SkDebugf("libgif error [%s] bitmap [%d %d] pixels %p colortable %p\n",
msg, bm.width(), bm.height(), bm.getPixels(),
bm.getColorTable());
}
return SkImageDecoder::kFailure;
}
static void gif_warning(const SkBitmap& bm, const char msg[]) {
if (!c_suppressGIFImageDecoderWarnings) {
SkDebugf("libgif warning [%s] bitmap [%d %d] pixels %p colortable %p\n",
msg, bm.width(), bm.height(), bm.getPixels(),
bm.getColorTable());
}
}
/**
* Skip rows in the source gif image.
* @param gif Source image.
* @param dst Scratch output needed by gif library call. Must be >= width bytes.
* @param width Bytes per row in the source image.
* @param rowsToSkip Number of rows to skip.
* @return True on success, false on GIF_ERROR.
*/
static bool skip_src_rows(GifFileType* gif, uint8_t* dst, int width, int rowsToSkip) {
for (int i = 0; i < rowsToSkip; i++) {
if (DGifGetLine(gif, dst, width) == GIF_ERROR) {
return false;
}
}
return true;
}
/**
* GIFs with fewer then 256 color entries will sometimes index out of
* bounds of the color table (this is malformed, but libgif does not
* check sicne it is rare). This function checks for this error and
* fixes it. This makes the output image consistantly deterministic.
*/
static void sanitize_indexed_bitmap(SkBitmap* bm) {
if ((kIndex_8_SkColorType == bm->colorType()) && !(bm->empty())) {
SkAutoLockPixels alp(*bm);
if (bm->getPixels()) {
SkColorTable* ct = bm->getColorTable(); // Index8 must have it.
SkASSERT(ct != nullptr);
uint32_t count = ct->count();
SkASSERT(count > 0);
SkASSERT(count <= 0x100);
if (count != 0x100) { // Full colortables can't go wrong.
// Count is a power of 2; asserted elsewhere.
uint8_t byteMask = (~(count - 1));
bool warning = false;
uint8_t* addr = static_cast<uint8_t*>(bm->getPixels());
int height = bm->height();
int width = bm->width();
size_t rowBytes = bm->rowBytes();
while (--height >= 0) {
uint8_t* ptr = addr;
int x = width;
while (--x >= 0) {
if (0 != ((*ptr) & byteMask)) {
warning = true;
*ptr = 0;
}
++ptr;
}
addr += rowBytes;
}
if (warning) {
gif_warning(*bm, "Index out of bounds.");
}
}
}
}
}
namespace {
// This function is a template argument, so can't be static.
int close_gif(GifFileType* gif) {
#if GIFLIB_MAJOR < 5 || (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0)
return DGifCloseFile(gif);
#else
return DGifCloseFile(gif, nullptr);
#endif
}
}//namespace
SkImageDecoder::Result SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap* bm, Mode mode) {
#if GIFLIB_MAJOR < 5
GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc);
#else
GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc, nullptr);
#endif
if (nullptr == gif) {
return error_return(*bm, "DGifOpen");
}
SkAutoTCallIProc<GifFileType, close_gif> acp(gif);
SavedImage temp_save;
temp_save.ExtensionBlocks=nullptr;
temp_save.ExtensionBlockCount=0;
SkAutoTCallVProc<SavedImage, CheckFreeExtension> acp2(&temp_save);
int width, height;
GifRecordType recType;
GifByteType *extData;
#if GIFLIB_MAJOR >= 5
int extFunction;
#endif
int transpIndex = -1; // -1 means we don't have it (yet)
int fillIndex = gif->SBackGroundColor;
do {
if (DGifGetRecordType(gif, &recType) == GIF_ERROR) {
return error_return(*bm, "DGifGetRecordType");
}
switch (recType) {
case IMAGE_DESC_RECORD_TYPE: {
if (DGifGetImageDesc(gif) == GIF_ERROR) {
return error_return(*bm, "IMAGE_DESC_RECORD_TYPE");
}
if (gif->ImageCount < 1) { // sanity check
return error_return(*bm, "ImageCount < 1");
}
width = gif->SWidth;
height = gif->SHeight;
SavedImage* image = &gif->SavedImages[gif->ImageCount-1];
const GifImageDesc& desc = image->ImageDesc;
int imageLeft = desc.Left;
int imageTop = desc.Top;
const int innerWidth = desc.Width;
const int innerHeight = desc.Height;
if (innerWidth <= 0 || innerHeight <= 0) {
return error_return(*bm, "invalid dimensions");
}
// check for valid descriptor
if (innerWidth > width) {
gif_warning(*bm, "image too wide, expanding output to size");
width = innerWidth;
imageLeft = 0;
} else if (imageLeft + innerWidth > width) {
gif_warning(*bm, "shifting image left to fit");
imageLeft = width - innerWidth;
} else if (imageLeft < 0) {
gif_warning(*bm, "shifting image right to fit");
imageLeft = 0;
}
if (innerHeight > height) {
gif_warning(*bm, "image too tall, expanding output to size");
height = innerHeight;
imageTop = 0;
} else if (imageTop + innerHeight > height) {
gif_warning(*bm, "shifting image up to fit");
imageTop = height - innerHeight;
} else if (imageTop < 0) {
gif_warning(*bm, "shifting image down to fit");
imageTop = 0;
}
SkScaledBitmapSampler sampler(width, height, this->getSampleSize());
bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledHeight(),
kIndex_8_SkColorType, kPremul_SkAlphaType));
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return kSuccess;
}
// now we decode the colortable
int colorCount = 0;
{
// Declare colorPtr here for scope.
SkPMColor colorPtr[256]; // storage for worst-case
const ColorMapObject* cmap = find_colormap(gif);
if (cmap != nullptr) {
SkASSERT(cmap->ColorCount == (1 << (cmap->BitsPerPixel)));
colorCount = cmap->ColorCount;
if (colorCount > 256) {
colorCount = 256; // our kIndex8 can't support more
}
for (int index = 0; index < colorCount; index++) {
colorPtr[index] = SkPackARGB32(0xFF,
cmap->Colors[index].Red,
cmap->Colors[index].Green,
cmap->Colors[index].Blue);
}
} else {
// find_colormap() returned nullptr. Some (rare, broken)
// GIFs don't have a color table, so we force one.
gif_warning(*bm, "missing colormap");
colorCount = 256;
sk_memset32(colorPtr, SK_ColorWHITE, colorCount);
}
transpIndex = find_transpIndex(temp_save, colorCount);
if (transpIndex >= 0) {
colorPtr[transpIndex] = SK_ColorTRANSPARENT; // ram in a transparent SkPMColor
fillIndex = transpIndex;
} else if (fillIndex >= colorCount) {
// gif->SBackGroundColor should be less than colorCount.
fillIndex = 0; // If not, fix it.
}
SkAutoTUnref<SkColorTable> ctable(new SkColorTable(colorPtr, colorCount));
if (!this->allocPixelRef(bm, ctable)) {
return error_return(*bm, "allocPixelRef");
}
}
// abort if either inner dimension is <= 0
if (innerWidth <= 0 || innerHeight <= 0) {
return error_return(*bm, "non-pos inner width/height");
}
SkAutoLockPixels alp(*bm);
SkAutoTMalloc<uint8_t> storage(innerWidth);
uint8_t* scanline = storage.get();
// GIF has an option to store the scanlines of an image, plus a larger background,
// filled by a fill color. In this case, we will use a subset of the larger bitmap
// for sampling.
SkBitmap subset;
SkBitmap* workingBitmap;
// are we only a subset of the total bounds?
if ((imageTop | imageLeft) > 0 ||
innerWidth < width || innerHeight < height) {
// Fill the background.
memset(bm->getPixels(), fillIndex, bm->getSize());
// Create a subset of the bitmap.
SkIRect subsetRect(SkIRect::MakeXYWH(imageLeft / sampler.srcDX(),
imageTop / sampler.srcDY(),
innerWidth / sampler.srcDX(),
innerHeight / sampler.srcDY()));
if (!bm->extractSubset(&subset, subsetRect)) {
return error_return(*bm, "Extract failed.");
}
// Update the sampler. We'll now be only sampling into the subset.
sampler = SkScaledBitmapSampler(innerWidth, innerHeight, this->getSampleSize());
workingBitmap = ⊂
} else {
workingBitmap = bm;
}
// bm is already locked, but if we had to take a subset, it must be locked also,
// so that getPixels() will point to its pixels.
SkAutoLockPixels alpWorking(*workingBitmap);
if (!sampler.begin(workingBitmap, SkScaledBitmapSampler::kIndex, *this)) {
return error_return(*bm, "Sampler failed to begin.");
}
// now decode each scanline
if (gif->Image.Interlace) {
// Iterate over the height of the source data. The sampler will
// take care of skipping unneeded rows.
GifInterlaceIter iter(innerHeight);
for (int y = 0; y < innerHeight; y++) {
if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) {
gif_warning(*bm, "interlace DGifGetLine");
memset(scanline, fillIndex, innerWidth);
for (; y < innerHeight; y++) {
sampler.sampleInterlaced(scanline, iter.currY());
iter.next();
}
return kPartialSuccess;
}
sampler.sampleInterlaced(scanline, iter.currY());
iter.next();
}
} else {
// easy, non-interlace case
const int outHeight = workingBitmap->height();
skip_src_rows(gif, scanline, innerWidth, sampler.srcY0());
for (int y = 0; y < outHeight; y++) {
if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) {
gif_warning(*bm, "DGifGetLine");
memset(scanline, fillIndex, innerWidth);
for (; y < outHeight; y++) {
sampler.next(scanline);
}
return kPartialSuccess;
}
// scanline now contains the raw data. Sample it.
sampler.next(scanline);
if (y < outHeight - 1) {
skip_src_rows(gif, scanline, innerWidth, sampler.srcDY() - 1);
}
}
// skip the rest of the rows (if any)
int read = (outHeight - 1) * sampler.srcDY() + sampler.srcY0() + 1;
SkASSERT(read <= innerHeight);
skip_src_rows(gif, scanline, innerWidth, innerHeight - read);
}
sanitize_indexed_bitmap(bm);
return kSuccess;
} break;
case EXTENSION_RECORD_TYPE:
#if GIFLIB_MAJOR < 5
if (DGifGetExtension(gif, &temp_save.Function,
&extData) == GIF_ERROR) {
#else
if (DGifGetExtension(gif, &extFunction, &extData) == GIF_ERROR) {
#endif
return error_return(*bm, "DGifGetExtension");
}
while (extData != nullptr) {
/* Create an extension block with our data */
#if GIFLIB_MAJOR < 5
if (AddExtensionBlock(&temp_save, extData[0],
&extData[1]) == GIF_ERROR) {
#else
if (GifAddExtensionBlock(&temp_save.ExtensionBlockCount,
&temp_save.ExtensionBlocks,
extFunction,
extData[0],
&extData[1]) == GIF_ERROR) {
#endif
return error_return(*bm, "AddExtensionBlock");
}
if (DGifGetExtensionNext(gif, &extData) == GIF_ERROR) {
return error_return(*bm, "DGifGetExtensionNext");
}
#if GIFLIB_MAJOR < 5
temp_save.Function = 0;
#endif
}
break;
case TERMINATE_RECORD_TYPE:
break;
default: /* Should be trapped by DGifGetRecordType */
break;
}
} while (recType != TERMINATE_RECORD_TYPE);
sanitize_indexed_bitmap(bm);
return kSuccess;
}
///////////////////////////////////////////////////////////////////////////////
DEFINE_DECODER_CREATOR(GIFImageDecoder);
///////////////////////////////////////////////////////////////////////////////
static bool is_gif(SkStreamRewindable* stream) {
char buf[GIF_STAMP_LEN];
if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) {
if (memcmp(GIF_STAMP, buf, GIF_STAMP_LEN) == 0 ||
memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 ||
memcmp(GIF89_STAMP, buf, GIF_STAMP_LEN) == 0) {
return true;
}
}
return false;
}
static SkImageDecoder* sk_libgif_dfactory(SkStreamRewindable* stream) {
if (is_gif(stream)) {
return new SkGIFImageDecoder;
}
return nullptr;
}
static SkImageDecoder_DecodeReg gReg(sk_libgif_dfactory);
static SkImageDecoder::Format get_format_gif(SkStreamRewindable* stream) {
if (is_gif(stream)) {
return SkImageDecoder::kGIF_Format;
}
return SkImageDecoder::kUnknown_Format;
}
static SkImageDecoder_FormatReg gFormatReg(get_format_gif);