1 2 /* 3 * Copyright 2006 The Android Open Source Project 4 * 5 * Use of this source code is governed by a BSD-style license that can be 6 * found in the LICENSE file. 7 */ 8 9 10 #include "SkMovie.h" 11 #include "SkColor.h" 12 #include "SkColorPriv.h" 13 #include "SkStream.h" 14 #include "SkTemplates.h" 15 #include "SkUtils.h" 16 17 #include "gif_lib.h" 18 19 class SkGIFMovie : public SkMovie { 20 public: 21 SkGIFMovie(SkStream* stream); 22 virtual ~SkGIFMovie(); 23 24 protected: 25 virtual bool onGetInfo(Info*); 26 virtual bool onSetTime(SkMSec); 27 virtual bool onGetBitmap(SkBitmap*); 28 29 private: 30 GifFileType* fGIF; 31 int fCurrIndex; 32 int fLastDrawIndex; 33 SkBitmap fBackup; 34 }; 35 36 static int Decode(GifFileType* fileType, GifByteType* out, int size) { 37 SkStream* stream = (SkStream*) fileType->UserData; 38 return (int) stream->read(out, size); 39 } 40 41 SkGIFMovie::SkGIFMovie(SkStream* stream) 42 { 43 fGIF = DGifOpen( stream, Decode ); 44 if (NULL == fGIF) 45 return; 46 47 if (DGifSlurp(fGIF) != GIF_OK) 48 { 49 DGifCloseFile(fGIF); 50 fGIF = NULL; 51 } 52 fCurrIndex = -1; 53 fLastDrawIndex = -1; 54 } 55 56 SkGIFMovie::~SkGIFMovie() 57 { 58 if (fGIF) 59 DGifCloseFile(fGIF); 60 } 61 62 static SkMSec savedimage_duration(const SavedImage* image) 63 { 64 for (int j = 0; j < image->ExtensionBlockCount; j++) 65 { 66 if (image->ExtensionBlocks[j].Function == GRAPHICS_EXT_FUNC_CODE) 67 { 68 int size = image->ExtensionBlocks[j].ByteCount; 69 SkASSERT(size >= 4); 70 const uint8_t* b = (const uint8_t*)image->ExtensionBlocks[j].Bytes; 71 return ((b[2] << 8) | b[1]) * 10; 72 } 73 } 74 return 0; 75 } 76 77 bool SkGIFMovie::onGetInfo(Info* info) 78 { 79 if (NULL == fGIF) 80 return false; 81 82 SkMSec dur = 0; 83 for (int i = 0; i < fGIF->ImageCount; i++) 84 dur += savedimage_duration(&fGIF->SavedImages[i]); 85 86 info->fDuration = dur; 87 info->fWidth = fGIF->SWidth; 88 info->fHeight = fGIF->SHeight; 89 info->fIsOpaque = false; // how to compute? 90 return true; 91 } 92 93 bool SkGIFMovie::onSetTime(SkMSec time) 94 { 95 if (NULL == fGIF) 96 return false; 97 98 SkMSec dur = 0; 99 for (int i = 0; i < fGIF->ImageCount; i++) 100 { 101 dur += savedimage_duration(&fGIF->SavedImages[i]); 102 if (dur >= time) 103 { 104 fCurrIndex = i; 105 return fLastDrawIndex != fCurrIndex; 106 } 107 } 108 fCurrIndex = fGIF->ImageCount - 1; 109 return true; 110 } 111 112 static void copyLine(uint32_t* dst, const unsigned char* src, const ColorMapObject* cmap, 113 int transparent, int width) 114 { 115 for (; width > 0; width--, src++, dst++) { 116 if (*src != transparent) { 117 const GifColorType& col = cmap->Colors[*src]; 118 *dst = SkPackARGB32(0xFF, col.Red, col.Green, col.Blue); 119 } 120 } 121 } 122 123 static void copyInterlaceGroup(SkBitmap* bm, const unsigned char*& src, 124 const ColorMapObject* cmap, int transparent, int copyWidth, 125 int copyHeight, const GifImageDesc& imageDesc, int rowStep, 126 int startRow) 127 { 128 int row; 129 // every 'rowStep'th row, starting with row 'startRow' 130 for (row = startRow; row < copyHeight; row += rowStep) { 131 uint32_t* dst = bm->getAddr32(imageDesc.Left, imageDesc.Top + row); 132 copyLine(dst, src, cmap, transparent, copyWidth); 133 src += imageDesc.Width; 134 } 135 136 // pad for rest height 137 src += imageDesc.Width * ((imageDesc.Height - row + rowStep - 1) / rowStep); 138 } 139 140 static void blitInterlace(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap, 141 int transparent) 142 { 143 int width = bm->width(); 144 int height = bm->height(); 145 GifWord copyWidth = frame->ImageDesc.Width; 146 if (frame->ImageDesc.Left + copyWidth > width) { 147 copyWidth = width - frame->ImageDesc.Left; 148 } 149 150 GifWord copyHeight = frame->ImageDesc.Height; 151 if (frame->ImageDesc.Top + copyHeight > height) { 152 copyHeight = height - frame->ImageDesc.Top; 153 } 154 155 // deinterlace 156 const unsigned char* src = (unsigned char*)frame->RasterBits; 157 158 // group 1 - every 8th row, starting with row 0 159 copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 8, 0); 160 161 // group 2 - every 8th row, starting with row 4 162 copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 8, 4); 163 164 // group 3 - every 4th row, starting with row 2 165 copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 4, 2); 166 167 copyInterlaceGroup(bm, src, cmap, transparent, copyWidth, copyHeight, frame->ImageDesc, 2, 1); 168 } 169 170 static void blitNormal(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap, 171 int transparent) 172 { 173 int width = bm->width(); 174 int height = bm->height(); 175 const unsigned char* src = (unsigned char*)frame->RasterBits; 176 uint32_t* dst = bm->getAddr32(frame->ImageDesc.Left, frame->ImageDesc.Top); 177 GifWord copyWidth = frame->ImageDesc.Width; 178 if (frame->ImageDesc.Left + copyWidth > width) { 179 copyWidth = width - frame->ImageDesc.Left; 180 } 181 182 GifWord copyHeight = frame->ImageDesc.Height; 183 if (frame->ImageDesc.Top + copyHeight > height) { 184 copyHeight = height - frame->ImageDesc.Top; 185 } 186 187 int srcPad, dstPad; 188 dstPad = width - copyWidth; 189 srcPad = frame->ImageDesc.Width - copyWidth; 190 for (; copyHeight > 0; copyHeight--) { 191 copyLine(dst, src, cmap, transparent, copyWidth); 192 src += frame->ImageDesc.Width; 193 dst += width; 194 } 195 } 196 197 static void fillRect(SkBitmap* bm, GifWord left, GifWord top, GifWord width, GifWord height, 198 uint32_t col) 199 { 200 int bmWidth = bm->width(); 201 int bmHeight = bm->height(); 202 uint32_t* dst = bm->getAddr32(left, top); 203 GifWord copyWidth = width; 204 if (left + copyWidth > bmWidth) { 205 copyWidth = bmWidth - left; 206 } 207 208 GifWord copyHeight = height; 209 if (top + copyHeight > bmHeight) { 210 copyHeight = bmHeight - top; 211 } 212 213 for (; copyHeight > 0; copyHeight--) { 214 sk_memset32(dst, col, copyWidth); 215 dst += bmWidth; 216 } 217 } 218 219 static void drawFrame(SkBitmap* bm, const SavedImage* frame, const ColorMapObject* cmap) 220 { 221 int transparent = -1; 222 223 for (int i = 0; i < frame->ExtensionBlockCount; ++i) { 224 ExtensionBlock* eb = frame->ExtensionBlocks + i; 225 if (eb->Function == GRAPHICS_EXT_FUNC_CODE && 226 eb->ByteCount == 4) { 227 bool has_transparency = ((eb->Bytes[0] & 1) == 1); 228 if (has_transparency) { 229 transparent = (unsigned char)eb->Bytes[3]; 230 } 231 } 232 } 233 234 if (frame->ImageDesc.ColorMap != NULL) { 235 // use local color table 236 cmap = frame->ImageDesc.ColorMap; 237 } 238 239 if (cmap == NULL || cmap->ColorCount != (1 << cmap->BitsPerPixel)) { 240 SkDEBUGFAIL("bad colortable setup"); 241 return; 242 } 243 244 if (frame->ImageDesc.Interlace) { 245 blitInterlace(bm, frame, cmap, transparent); 246 } else { 247 blitNormal(bm, frame, cmap, transparent); 248 } 249 } 250 251 static bool checkIfWillBeCleared(const SavedImage* frame) 252 { 253 for (int i = 0; i < frame->ExtensionBlockCount; ++i) { 254 ExtensionBlock* eb = frame->ExtensionBlocks + i; 255 if (eb->Function == GRAPHICS_EXT_FUNC_CODE && 256 eb->ByteCount == 4) { 257 // check disposal method 258 int disposal = ((eb->Bytes[0] >> 2) & 7); 259 if (disposal == 2 || disposal == 3) { 260 return true; 261 } 262 } 263 } 264 return false; 265 } 266 267 static void getTransparencyAndDisposalMethod(const SavedImage* frame, bool* trans, int* disposal) 268 { 269 *trans = false; 270 *disposal = 0; 271 for (int i = 0; i < frame->ExtensionBlockCount; ++i) { 272 ExtensionBlock* eb = frame->ExtensionBlocks + i; 273 if (eb->Function == GRAPHICS_EXT_FUNC_CODE && 274 eb->ByteCount == 4) { 275 *trans = ((eb->Bytes[0] & 1) == 1); 276 *disposal = ((eb->Bytes[0] >> 2) & 7); 277 } 278 } 279 } 280 281 // return true if area of 'target' is completely covers area of 'covered' 282 static bool checkIfCover(const SavedImage* target, const SavedImage* covered) 283 { 284 if (target->ImageDesc.Left <= covered->ImageDesc.Left 285 && covered->ImageDesc.Left + covered->ImageDesc.Width <= 286 target->ImageDesc.Left + target->ImageDesc.Width 287 && target->ImageDesc.Top <= covered->ImageDesc.Top 288 && covered->ImageDesc.Top + covered->ImageDesc.Height <= 289 target->ImageDesc.Top + target->ImageDesc.Height) { 290 return true; 291 } 292 return false; 293 } 294 295 static void disposeFrameIfNeeded(SkBitmap* bm, const SavedImage* cur, const SavedImage* next, 296 SkBitmap* backup, SkColor color) 297 { 298 // We can skip disposal process if next frame is not transparent 299 // and completely covers current area 300 bool curTrans; 301 int curDisposal; 302 getTransparencyAndDisposalMethod(cur, &curTrans, &curDisposal); 303 bool nextTrans; 304 int nextDisposal; 305 getTransparencyAndDisposalMethod(next, &nextTrans, &nextDisposal); 306 if ((curDisposal == 2 || curDisposal == 3) 307 && (nextTrans || !checkIfCover(next, cur))) { 308 switch (curDisposal) { 309 // restore to background color 310 // -> 'background' means background under this image. 311 case 2: 312 fillRect(bm, cur->ImageDesc.Left, cur->ImageDesc.Top, 313 cur->ImageDesc.Width, cur->ImageDesc.Height, 314 color); 315 break; 316 317 // restore to previous 318 case 3: 319 bm->swap(*backup); 320 break; 321 } 322 } 323 324 // Save current image if next frame's disposal method == 3 325 if (nextDisposal == 3) { 326 const uint32_t* src = bm->getAddr32(0, 0); 327 uint32_t* dst = backup->getAddr32(0, 0); 328 int cnt = bm->width() * bm->height(); 329 memcpy(dst, src, cnt*sizeof(uint32_t)); 330 } 331 } 332 333 bool SkGIFMovie::onGetBitmap(SkBitmap* bm) 334 { 335 const GifFileType* gif = fGIF; 336 if (NULL == gif) 337 return false; 338 339 if (gif->ImageCount < 1) { 340 return false; 341 } 342 343 const int width = gif->SWidth; 344 const int height = gif->SHeight; 345 if (width <= 0 || height <= 0) { 346 return false; 347 } 348 349 // no need to draw 350 if (fLastDrawIndex >= 0 && fLastDrawIndex == fCurrIndex) { 351 return true; 352 } 353 354 int startIndex = fLastDrawIndex + 1; 355 if (fLastDrawIndex < 0 || !bm->readyToDraw()) { 356 // first time 357 358 startIndex = 0; 359 360 // create bitmap 361 bm->setConfig(SkBitmap::kARGB_8888_Config, width, height, 0); 362 if (!bm->allocPixels(NULL)) { 363 return false; 364 } 365 // create bitmap for backup 366 fBackup.setConfig(SkBitmap::kARGB_8888_Config, width, height, 0); 367 if (!fBackup.allocPixels(NULL)) { 368 return false; 369 } 370 } else if (startIndex > fCurrIndex) { 371 // rewind to 1st frame for repeat 372 startIndex = 0; 373 } 374 375 int lastIndex = fCurrIndex; 376 if (lastIndex < 0) { 377 // first time 378 lastIndex = 0; 379 } else if (lastIndex > fGIF->ImageCount - 1) { 380 // this block must not be reached. 381 lastIndex = fGIF->ImageCount - 1; 382 } 383 384 SkColor bgColor = SkPackARGB32(0, 0, 0, 0); 385 if (gif->SColorMap != NULL) { 386 const GifColorType& col = gif->SColorMap->Colors[fGIF->SBackGroundColor]; 387 bgColor = SkColorSetARGB(0xFF, col.Red, col.Green, col.Blue); 388 } 389 390 static SkColor paintingColor = SkPackARGB32(0, 0, 0, 0); 391 // draw each frames - not intelligent way 392 for (int i = startIndex; i <= lastIndex; i++) { 393 const SavedImage* cur = &fGIF->SavedImages[i]; 394 if (i == 0) { 395 bool trans; 396 int disposal; 397 getTransparencyAndDisposalMethod(cur, &trans, &disposal); 398 if (!trans && gif->SColorMap != NULL) { 399 paintingColor = bgColor; 400 } else { 401 paintingColor = SkColorSetARGB(0, 0, 0, 0); 402 } 403 404 bm->eraseColor(paintingColor); 405 fBackup.eraseColor(paintingColor); 406 } else { 407 // Dispose previous frame before move to next frame. 408 const SavedImage* prev = &fGIF->SavedImages[i-1]; 409 disposeFrameIfNeeded(bm, prev, cur, &fBackup, paintingColor); 410 } 411 412 // Draw frame 413 // We can skip this process if this index is not last and disposal 414 // method == 2 or method == 3 415 if (i == lastIndex || !checkIfWillBeCleared(cur)) { 416 drawFrame(bm, cur, gif->SColorMap); 417 } 418 } 419 420 // save index 421 fLastDrawIndex = lastIndex; 422 return true; 423 } 424 425 /////////////////////////////////////////////////////////////////////////////// 426 427 #include "SkTRegistry.h" 428 429 SkMovie* Factory(SkStream* stream) { 430 char buf[GIF_STAMP_LEN]; 431 if (stream->read(buf, GIF_STAMP_LEN) == GIF_STAMP_LEN) { 432 if (memcmp(GIF_STAMP, buf, GIF_STAMP_LEN) == 0 || 433 memcmp(GIF87_STAMP, buf, GIF_STAMP_LEN) == 0 || 434 memcmp(GIF89_STAMP, buf, GIF_STAMP_LEN) == 0) { 435 // must rewind here, since our construct wants to re-read the data 436 stream->rewind(); 437 return SkNEW_ARGS(SkGIFMovie, (stream)); 438 } 439 } 440 return NULL; 441 } 442 443 static SkTRegistry<SkMovie*, SkStream*> gReg(Factory); 444