| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright 2006 The Android Open Source Project | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license that can be | |
| 5 * found in the LICENSE file. | |
| 6 */ | |
| 7 | |
| 8 #include "SkColor.h" | |
| 9 #include "SkColorPriv.h" | |
| 10 #include "SkColorTable.h" | |
| 11 #include "SkImageDecoder.h" | |
| 12 #include "SkRTConf.h" | |
| 13 #include "SkScaledBitmapSampler.h" | |
| 14 #include "SkStream.h" | |
| 15 #include "SkTemplates.h" | |
| 16 #include "SkUtils.h" | |
| 17 | |
| 18 #include "gif_lib.h" | |
| 19 | |
| 20 class SkGIFImageDecoder : public SkImageDecoder { | |
| 21 public: | |
| 22 Format getFormat() const override { | |
| 23 return kGIF_Format; | |
| 24 } | |
| 25 | |
| 26 protected: | |
| 27 Result onDecode(SkStream* stream, SkBitmap* bm, Mode mode) override; | |
| 28 | |
| 29 private: | |
| 30 typedef SkImageDecoder INHERITED; | |
| 31 }; | |
| 32 | |
| 33 static const uint8_t gStartingIterlaceYValue[] = { | |
| 34 0, 4, 2, 1 | |
| 35 }; | |
| 36 static const uint8_t gDeltaIterlaceYValue[] = { | |
| 37 8, 8, 4, 2 | |
| 38 }; | |
| 39 | |
| 40 SK_CONF_DECLARE(bool, c_suppressGIFImageDecoderWarnings, | |
| 41 "images.gif.suppressDecoderWarnings", true, | |
| 42 "Suppress GIF warnings and errors when calling image decode " | |
| 43 "functions."); | |
| 44 | |
| 45 | |
| 46 /* Implement the GIF interlace algorithm in an iterator. | |
| 47 1) grab every 8th line beginning at 0 | |
| 48 2) grab every 8th line beginning at 4 | |
| 49 3) grab every 4th line beginning at 2 | |
| 50 4) grab every 2nd line beginning at 1 | |
| 51 */ | |
| 52 class GifInterlaceIter { | |
| 53 public: | |
| 54 GifInterlaceIter(int height) : fHeight(height) { | |
| 55 fStartYPtr = gStartingIterlaceYValue; | |
| 56 fDeltaYPtr = gDeltaIterlaceYValue; | |
| 57 | |
| 58 fCurrY = *fStartYPtr++; | |
| 59 fDeltaY = *fDeltaYPtr++; | |
| 60 } | |
| 61 | |
| 62 int currY() const { | |
| 63 SkASSERT(fStartYPtr); | |
| 64 SkASSERT(fDeltaYPtr); | |
| 65 return fCurrY; | |
| 66 } | |
| 67 | |
| 68 void next() { | |
| 69 SkASSERT(fStartYPtr); | |
| 70 SkASSERT(fDeltaYPtr); | |
| 71 | |
| 72 int y = fCurrY + fDeltaY; | |
| 73 // We went from an if statement to a while loop so that we iterate | |
| 74 // through fStartYPtr until a valid row is found. This is so that images | |
| 75 // that are smaller than 5x5 will not trash memory. | |
| 76 while (y >= fHeight) { | |
| 77 if (gStartingIterlaceYValue + | |
| 78 SK_ARRAY_COUNT(gStartingIterlaceYValue) == fStartYPtr) { | |
| 79 // we done | |
| 80 SkDEBUGCODE(fStartYPtr = nullptr;) | |
| 81 SkDEBUGCODE(fDeltaYPtr = nullptr;) | |
| 82 y = 0; | |
| 83 } else { | |
| 84 y = *fStartYPtr++; | |
| 85 fDeltaY = *fDeltaYPtr++; | |
| 86 } | |
| 87 } | |
| 88 fCurrY = y; | |
| 89 } | |
| 90 | |
| 91 private: | |
| 92 const int fHeight; | |
| 93 int fCurrY; | |
| 94 int fDeltaY; | |
| 95 const uint8_t* fStartYPtr; | |
| 96 const uint8_t* fDeltaYPtr; | |
| 97 }; | |
| 98 | |
| 99 /////////////////////////////////////////////////////////////////////////////// | |
| 100 | |
| 101 static int DecodeCallBackProc(GifFileType* fileType, GifByteType* out, | |
| 102 int size) { | |
| 103 SkStream* stream = (SkStream*) fileType->UserData; | |
| 104 return (int) stream->read(out, size); | |
| 105 } | |
| 106 | |
| 107 void CheckFreeExtension(SavedImage* Image) { | |
| 108 if (Image->ExtensionBlocks) { | |
| 109 #if GIFLIB_MAJOR < 5 | |
| 110 FreeExtension(Image); | |
| 111 #else | |
| 112 GifFreeExtensions(&Image->ExtensionBlockCount, &Image->ExtensionBlocks); | |
| 113 #endif | |
| 114 } | |
| 115 } | |
| 116 | |
| 117 // return nullptr on failure | |
| 118 static const ColorMapObject* find_colormap(const GifFileType* gif) { | |
| 119 const ColorMapObject* cmap = gif->Image.ColorMap; | |
| 120 if (nullptr == cmap) { | |
| 121 cmap = gif->SColorMap; | |
| 122 } | |
| 123 | |
| 124 if (nullptr == cmap) { | |
| 125 // no colormap found | |
| 126 return nullptr; | |
| 127 } | |
| 128 // some sanity checks | |
| 129 if (cmap && ((unsigned)cmap->ColorCount > 256 || | |
| 130 cmap->ColorCount != (1 << cmap->BitsPerPixel))) { | |
| 131 cmap = nullptr; | |
| 132 } | |
| 133 return cmap; | |
| 134 } | |
| 135 | |
| 136 // return -1 if not found (i.e. we're completely opaque) | |
| 137 static int find_transpIndex(const SavedImage& image, int colorCount) { | |
| 138 int transpIndex = -1; | |
| 139 for (int i = 0; i < image.ExtensionBlockCount; ++i) { | |
| 140 const ExtensionBlock* eb = image.ExtensionBlocks + i; | |
| 141 if (eb->Function == 0xF9 && eb->ByteCount == 4) { | |
| 142 if (eb->Bytes[0] & 1) { | |
| 143 transpIndex = (unsigned char)eb->Bytes[3]; | |
| 144 // check for valid transpIndex | |
| 145 if (transpIndex >= colorCount) { | |
| 146 transpIndex = -1; | |
| 147 } | |
| 148 break; | |
| 149 } | |
| 150 } | |
| 151 } | |
| 152 return transpIndex; | |
| 153 } | |
| 154 | |
| 155 static SkImageDecoder::Result error_return(const SkBitmap& bm, const char msg[])
{ | |
| 156 if (!c_suppressGIFImageDecoderWarnings) { | |
| 157 SkDebugf("libgif error [%s] bitmap [%d %d] pixels %p colortable %p\n", | |
| 158 msg, bm.width(), bm.height(), bm.getPixels(), | |
| 159 bm.getColorTable()); | |
| 160 } | |
| 161 return SkImageDecoder::kFailure; | |
| 162 } | |
| 163 | |
| 164 static void gif_warning(const SkBitmap& bm, const char msg[]) { | |
| 165 if (!c_suppressGIFImageDecoderWarnings) { | |
| 166 SkDebugf("libgif warning [%s] bitmap [%d %d] pixels %p colortable %p\n", | |
| 167 msg, bm.width(), bm.height(), bm.getPixels(), | |
| 168 bm.getColorTable()); | |
| 169 } | |
| 170 } | |
| 171 | |
| 172 /** | |
| 173 * Skip rows in the source gif image. | |
| 174 * @param gif Source image. | |
| 175 * @param dst Scratch output needed by gif library call. Must be >= width bytes
. | |
| 176 * @param width Bytes per row in the source image. | |
| 177 * @param rowsToSkip Number of rows to skip. | |
| 178 * @return True on success, false on GIF_ERROR. | |
| 179 */ | |
| 180 static bool skip_src_rows(GifFileType* gif, uint8_t* dst, int width, int rowsToS
kip) { | |
| 181 for (int i = 0; i < rowsToSkip; i++) { | |
| 182 if (DGifGetLine(gif, dst, width) == GIF_ERROR) { | |
| 183 return false; | |
| 184 } | |
| 185 } | |
| 186 return true; | |
| 187 } | |
| 188 | |
| 189 /** | |
| 190 * GIFs with fewer then 256 color entries will sometimes index out of | |
| 191 * bounds of the color table (this is malformed, but libgif does not | |
| 192 * check sicne it is rare). This function checks for this error and | |
| 193 * fixes it. This makes the output image consistantly deterministic. | |
| 194 */ | |
| 195 static void sanitize_indexed_bitmap(SkBitmap* bm) { | |
| 196 if ((kIndex_8_SkColorType == bm->colorType()) && !(bm->empty())) { | |
| 197 SkAutoLockPixels alp(*bm); | |
| 198 if (bm->getPixels()) { | |
| 199 SkColorTable* ct = bm->getColorTable(); // Index8 must have it. | |
| 200 SkASSERT(ct != nullptr); | |
| 201 uint32_t count = ct->count(); | |
| 202 SkASSERT(count > 0); | |
| 203 SkASSERT(count <= 0x100); | |
| 204 if (count != 0x100) { // Full colortables can't go wrong. | |
| 205 // Count is a power of 2; asserted elsewhere. | |
| 206 uint8_t byteMask = (~(count - 1)); | |
| 207 bool warning = false; | |
| 208 uint8_t* addr = static_cast<uint8_t*>(bm->getPixels()); | |
| 209 int height = bm->height(); | |
| 210 int width = bm->width(); | |
| 211 size_t rowBytes = bm->rowBytes(); | |
| 212 while (--height >= 0) { | |
| 213 uint8_t* ptr = addr; | |
| 214 int x = width; | |
| 215 while (--x >= 0) { | |
| 216 if (0 != ((*ptr) & byteMask)) { | |
| 217 warning = true; | |
| 218 *ptr = 0; | |
| 219 } | |
| 220 ++ptr; | |
| 221 } | |
| 222 addr += rowBytes; | |
| 223 } | |
| 224 if (warning) { | |
| 225 gif_warning(*bm, "Index out of bounds."); | |
| 226 } | |
| 227 } | |
| 228 } | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 namespace { | |
| 233 // This function is a template argument, so can't be static. | |
| 234 int close_gif(GifFileType* gif) { | |
| 235 #if GIFLIB_MAJOR < 5 || (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0) | |
| 236 return DGifCloseFile(gif); | |
| 237 #else | |
| 238 return DGifCloseFile(gif, nullptr); | |
| 239 #endif | |
| 240 } | |
| 241 }//namespace | |
| 242 | |
| 243 SkImageDecoder::Result SkGIFImageDecoder::onDecode(SkStream* sk_stream, SkBitmap
* bm, Mode mode) { | |
| 244 #if GIFLIB_MAJOR < 5 | |
| 245 GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc); | |
| 246 #else | |
| 247 GifFileType* gif = DGifOpen(sk_stream, DecodeCallBackProc, nullptr); | |
| 248 #endif | |
| 249 if (nullptr == gif) { | |
| 250 return error_return(*bm, "DGifOpen"); | |
| 251 } | |
| 252 | |
| 253 SkAutoTCallIProc<GifFileType, close_gif> acp(gif); | |
| 254 | |
| 255 SavedImage temp_save; | |
| 256 temp_save.ExtensionBlocks=nullptr; | |
| 257 temp_save.ExtensionBlockCount=0; | |
| 258 SkAutoTCallVProc<SavedImage, CheckFreeExtension> acp2(&temp_save); | |
| 259 | |
| 260 int width, height; | |
| 261 GifRecordType recType; | |
| 262 GifByteType *extData; | |
| 263 #if GIFLIB_MAJOR >= 5 | |
| 264 int extFunction; | |
| 265 #endif | |
| 266 int transpIndex = -1; // -1 means we don't have it (yet) | |
| 267 int fillIndex = gif->SBackGroundColor; | |
| 268 | |
| 269 do { | |
| 270 if (DGifGetRecordType(gif, &recType) == GIF_ERROR) { | |
| 271 return error_return(*bm, "DGifGetRecordType"); | |
| 272 } | |
| 273 | |
| 274 switch (recType) { | |
| 275 case IMAGE_DESC_RECORD_TYPE: { | |
| 276 if (DGifGetImageDesc(gif) == GIF_ERROR) { | |
| 277 return error_return(*bm, "IMAGE_DESC_RECORD_TYPE"); | |
| 278 } | |
| 279 | |
| 280 if (gif->ImageCount < 1) { // sanity check | |
| 281 return error_return(*bm, "ImageCount < 1"); | |
| 282 } | |
| 283 | |
| 284 width = gif->SWidth; | |
| 285 height = gif->SHeight; | |
| 286 | |
| 287 SavedImage* image = &gif->SavedImages[gif->ImageCount-1]; | |
| 288 const GifImageDesc& desc = image->ImageDesc; | |
| 289 | |
| 290 int imageLeft = desc.Left; | |
| 291 int imageTop = desc.Top; | |
| 292 const int innerWidth = desc.Width; | |
| 293 const int innerHeight = desc.Height; | |
| 294 if (innerWidth <= 0 || innerHeight <= 0) { | |
| 295 return error_return(*bm, "invalid dimensions"); | |
| 296 } | |
| 297 | |
| 298 // check for valid descriptor | |
| 299 if (innerWidth > width) { | |
| 300 gif_warning(*bm, "image too wide, expanding output to size"); | |
| 301 width = innerWidth; | |
| 302 imageLeft = 0; | |
| 303 } else if (imageLeft + innerWidth > width) { | |
| 304 gif_warning(*bm, "shifting image left to fit"); | |
| 305 imageLeft = width - innerWidth; | |
| 306 } else if (imageLeft < 0) { | |
| 307 gif_warning(*bm, "shifting image right to fit"); | |
| 308 imageLeft = 0; | |
| 309 } | |
| 310 | |
| 311 | |
| 312 if (innerHeight > height) { | |
| 313 gif_warning(*bm, "image too tall, expanding output to size"); | |
| 314 height = innerHeight; | |
| 315 imageTop = 0; | |
| 316 } else if (imageTop + innerHeight > height) { | |
| 317 gif_warning(*bm, "shifting image up to fit"); | |
| 318 imageTop = height - innerHeight; | |
| 319 } else if (imageTop < 0) { | |
| 320 gif_warning(*bm, "shifting image down to fit"); | |
| 321 imageTop = 0; | |
| 322 } | |
| 323 | |
| 324 SkScaledBitmapSampler sampler(width, height, this->getSampleSize()); | |
| 325 | |
| 326 bm->setInfo(SkImageInfo::Make(sampler.scaledWidth(), sampler.scaledH
eight(), | |
| 327 kIndex_8_SkColorType, kPremul_SkAlphaT
ype)); | |
| 328 | |
| 329 if (SkImageDecoder::kDecodeBounds_Mode == mode) { | |
| 330 return kSuccess; | |
| 331 } | |
| 332 | |
| 333 | |
| 334 // now we decode the colortable | |
| 335 int colorCount = 0; | |
| 336 { | |
| 337 // Declare colorPtr here for scope. | |
| 338 SkPMColor colorPtr[256]; // storage for worst-case | |
| 339 const ColorMapObject* cmap = find_colormap(gif); | |
| 340 if (cmap != nullptr) { | |
| 341 SkASSERT(cmap->ColorCount == (1 << (cmap->BitsPerPixel))); | |
| 342 colorCount = cmap->ColorCount; | |
| 343 if (colorCount > 256) { | |
| 344 colorCount = 256; // our kIndex8 can't support more | |
| 345 } | |
| 346 for (int index = 0; index < colorCount; index++) { | |
| 347 colorPtr[index] = SkPackARGB32(0xFF, | |
| 348 cmap->Colors[index].Red, | |
| 349 cmap->Colors[index].Green
, | |
| 350 cmap->Colors[index].Blue)
; | |
| 351 } | |
| 352 } else { | |
| 353 // find_colormap() returned nullptr. Some (rare, broken) | |
| 354 // GIFs don't have a color table, so we force one. | |
| 355 gif_warning(*bm, "missing colormap"); | |
| 356 colorCount = 256; | |
| 357 sk_memset32(colorPtr, SK_ColorWHITE, colorCount); | |
| 358 } | |
| 359 transpIndex = find_transpIndex(temp_save, colorCount); | |
| 360 if (transpIndex >= 0) { | |
| 361 colorPtr[transpIndex] = SK_ColorTRANSPARENT; // ram in a tra
nsparent SkPMColor | |
| 362 fillIndex = transpIndex; | |
| 363 } else if (fillIndex >= colorCount) { | |
| 364 // gif->SBackGroundColor should be less than colorCount. | |
| 365 fillIndex = 0; // If not, fix it. | |
| 366 } | |
| 367 | |
| 368 SkAutoTUnref<SkColorTable> ctable(new SkColorTable(colorPtr, col
orCount)); | |
| 369 if (!this->allocPixelRef(bm, ctable)) { | |
| 370 return error_return(*bm, "allocPixelRef"); | |
| 371 } | |
| 372 } | |
| 373 | |
| 374 // abort if either inner dimension is <= 0 | |
| 375 if (innerWidth <= 0 || innerHeight <= 0) { | |
| 376 return error_return(*bm, "non-pos inner width/height"); | |
| 377 } | |
| 378 | |
| 379 SkAutoLockPixels alp(*bm); | |
| 380 | |
| 381 SkAutoTMalloc<uint8_t> storage(innerWidth); | |
| 382 uint8_t* scanline = storage.get(); | |
| 383 | |
| 384 // GIF has an option to store the scanlines of an image, plus a larg
er background, | |
| 385 // filled by a fill color. In this case, we will use a subset of the
larger bitmap | |
| 386 // for sampling. | |
| 387 SkBitmap subset; | |
| 388 SkBitmap* workingBitmap; | |
| 389 // are we only a subset of the total bounds? | |
| 390 if ((imageTop | imageLeft) > 0 || | |
| 391 innerWidth < width || innerHeight < height) { | |
| 392 // Fill the background. | |
| 393 memset(bm->getPixels(), fillIndex, bm->getSize()); | |
| 394 | |
| 395 // Create a subset of the bitmap. | |
| 396 SkIRect subsetRect(SkIRect::MakeXYWH(imageLeft / sampler.srcDX()
, | |
| 397 imageTop / sampler.srcDY(), | |
| 398 innerWidth / sampler.srcDX(
), | |
| 399 innerHeight / sampler.srcDY
())); | |
| 400 if (!bm->extractSubset(&subset, subsetRect)) { | |
| 401 return error_return(*bm, "Extract failed."); | |
| 402 } | |
| 403 // Update the sampler. We'll now be only sampling into the subse
t. | |
| 404 sampler = SkScaledBitmapSampler(innerWidth, innerHeight, this->g
etSampleSize()); | |
| 405 workingBitmap = ⊂ | |
| 406 } else { | |
| 407 workingBitmap = bm; | |
| 408 } | |
| 409 | |
| 410 // bm is already locked, but if we had to take a subset, it must be
locked also, | |
| 411 // so that getPixels() will point to its pixels. | |
| 412 SkAutoLockPixels alpWorking(*workingBitmap); | |
| 413 | |
| 414 if (!sampler.begin(workingBitmap, SkScaledBitmapSampler::kIndex, *th
is)) { | |
| 415 return error_return(*bm, "Sampler failed to begin."); | |
| 416 } | |
| 417 | |
| 418 // now decode each scanline | |
| 419 if (gif->Image.Interlace) { | |
| 420 // Iterate over the height of the source data. The sampler will | |
| 421 // take care of skipping unneeded rows. | |
| 422 GifInterlaceIter iter(innerHeight); | |
| 423 for (int y = 0; y < innerHeight; y++) { | |
| 424 if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) { | |
| 425 gif_warning(*bm, "interlace DGifGetLine"); | |
| 426 memset(scanline, fillIndex, innerWidth); | |
| 427 for (; y < innerHeight; y++) { | |
| 428 sampler.sampleInterlaced(scanline, iter.currY()); | |
| 429 iter.next(); | |
| 430 } | |
| 431 return kPartialSuccess; | |
| 432 } | |
| 433 sampler.sampleInterlaced(scanline, iter.currY()); | |
| 434 iter.next(); | |
| 435 } | |
| 436 } else { | |
| 437 // easy, non-interlace case | |
| 438 const int outHeight = workingBitmap->height(); | |
| 439 skip_src_rows(gif, scanline, innerWidth, sampler.srcY0()); | |
| 440 for (int y = 0; y < outHeight; y++) { | |
| 441 if (DGifGetLine(gif, scanline, innerWidth) == GIF_ERROR) { | |
| 442 gif_warning(*bm, "DGifGetLine"); | |
| 443 memset(scanline, fillIndex, innerWidth); | |
| 444 for (; y < outHeight; y++) { | |
| 445 sampler.next(scanline); | |
| 446 } | |
| 447 return kPartialSuccess; | |
| 448 } | |
| 449 // scanline now contains the raw data. Sample it. | |
| 450 sampler.next(scanline); | |
| 451 if (y < outHeight - 1) { | |
| 452 skip_src_rows(gif, scanline, innerWidth, sampler.srcDY()
- 1); | |
| 453 } | |
| 454 } | |
| 455 // skip the rest of the rows (if any) | |
| 456 int read = (outHeight - 1) * sampler.srcDY() + sampler.srcY0() +
1; | |
| 457 SkASSERT(read <= innerHeight); | |
| 458 skip_src_rows(gif, scanline, innerWidth, innerHeight - read); | |
| 459 } | |
| 460 sanitize_indexed_bitmap(bm); | |
| 461 return kSuccess; | |
| 462 } break; | |
| 463 | |
| 464 case EXTENSION_RECORD_TYPE: | |
| 465 #if GIFLIB_MAJOR < 5 | |
| 466 if (DGifGetExtension(gif, &temp_save.Function, | |
| 467 &extData) == GIF_ERROR) { | |
| 468 #else | |
| 469 if (DGifGetExtension(gif, &extFunction, &extData) == GIF_ERROR) { | |
| 470 #endif | |
| 471 return error_return(*bm, "DGifGetExtension"); | |
| 472 } | |
| 473 | |
| 474 while (extData != nullptr) { | |
| 475 /* Create an extension block with our data */ | |
| 476 #if GIFLIB_MAJOR < 5 | |
| 477 if (AddExtensionBlock(&temp_save, extData[0], | |
| 478 &extData[1]) == GIF_ERROR) { | |
| 479 #else | |
| 480 if (GifAddExtensionBlock(&temp_save.ExtensionBlockCount, | |
| 481 &temp_save.ExtensionBlocks, | |
| 482 extFunction, | |
| 483 extData[0], | |
| 484 &extData[1]) == GIF_ERROR) { | |
| 485 #endif | |
| 486 return error_return(*bm, "AddExtensionBlock"); | |
| 487 } | |
| 488 if (DGifGetExtensionNext(gif, &extData) == GIF_ERROR) { | |
| 489 return error_return(*bm, "DGifGetExtensionNext"); | |
| 490 } | |
| 491 #if GIFLIB_MAJOR < 5 | |
| 492 temp_save.Function = 0; | |
| 493 #endif | |
| 494 } | |
| 495 break; | |
| 496 | |
| 497 case TERMINATE_RECORD_TYPE: | |
| 498 break; | |
| 499 | |
| 500 default: /* Should be trapped by DGifGetRecordType */ | |
| 501 break; | |
| 502 } | |
| 503 } while (recType != TERMINATE_RECORD_TYPE); | |
| 504 | |
| 505 sanitize_indexed_bitmap(bm); | |
| 506 return kSuccess; | |
| 507 } | |
| 508 | |
| 509 /////////////////////////////////////////////////////////////////////////////// | |
| 510 DEFINE_DECODER_CREATOR(GIFImageDecoder); | |
| 511 /////////////////////////////////////////////////////////////////////////////// | |
| 512 | |
| 513 static bool is_gif(SkStreamRewindable* stream) { | |
| 514 char buf[GIF_STAMP_LEN]; | |
| 515 if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) { | |
| 516 if (memcmp(GIF_STAMP, buf, GIF_STAMP_LEN) == 0 || | |
| 517 memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 || | |
| 518 memcmp(GIF89_STAMP, buf, GIF_STAMP_LEN) == 0) { | |
| 519 return true; | |
| 520 } | |
| 521 } | |
| 522 return false; | |
| 523 } | |
| 524 | |
| 525 static SkImageDecoder* sk_libgif_dfactory(SkStreamRewindable* stream) { | |
| 526 if (is_gif(stream)) { | |
| 527 return new SkGIFImageDecoder; | |
| 528 } | |
| 529 return nullptr; | |
| 530 } | |
| 531 | |
| 532 static SkImageDecoder_DecodeReg gReg(sk_libgif_dfactory); | |
| 533 | |
| 534 static SkImageDecoder::Format get_format_gif(SkStreamRewindable* stream) { | |
| 535 if (is_gif(stream)) { | |
| 536 return SkImageDecoder::kGIF_Format; | |
| 537 } | |
| 538 return SkImageDecoder::kUnknown_Format; | |
| 539 } | |
| 540 | |
| 541 static SkImageDecoder_FormatReg gFormatReg(get_format_gif); | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1820503002:
Delete SkImageDecoder (Closed)
Base URL: https://skia.googlesource.com/skia.git@fix-animator