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

Side by Side Diff: src/images/SkImageDecoder_libgif.cpp

Issue 1828433004: 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 unified diff | Download patch
« no previous file with comments | « src/images/SkImageDecoder_libbmp.cpp ('k') | src/images/SkImageDecoder_libico.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 = &subset;
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);
OLDNEW
« 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