Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(967)

Unified Diff: src/images/SkImageDecoder_libgif.cpp

Issue 1830943002: Revert of Delete SkImageDecoder (Closed) Base URL: https://skia.googlesource.com/skia.git@fix-animator
Patch Set: Created 4 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/images/SkImageDecoder_libbmp.cpp ('k') | src/images/SkImageDecoder_libico.cpp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: src/images/SkImageDecoder_libgif.cpp
diff --git a/src/images/SkImageDecoder_libgif.cpp b/src/images/SkImageDecoder_libgif.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2677b130736037bee2e72bbc694c13bbd6b6d0ea
--- /dev/null
+++ b/src/images/SkImageDecoder_libgif.cpp
@@ -0,0 +1,541 @@
+/*
+ * 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 = &subset;
+ } 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);
« no previous file with comments | « src/images/SkImageDecoder_libbmp.cpp ('k') | src/images/SkImageDecoder_libico.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698