PixRectArray::PixRectArray(const StringArray &fileNames, StringArray &errors) { USES_CONVERSION; m_updateCounter = 0; for(size_t i = 0; i < fileNames.size(); i++) { const String &name = fileNames[i]; try { if(FileNameSplitter(name).getExtension().equalsIgnoreCase(_T(".gif"))) { int error; const char *namea = T2A(name.cstr()); GifFileType *gifFile = DGifOpenFileName(namea, &error); if(gifFile == NULL) { throwException(_T("%s"), GifErrorString(error)); } if(DGifSlurp(gifFile) != GIF_OK) { const String msg = GifErrorString(gifFile->Error); DGifCloseFile(gifFile, &error); throwException(_T("%s"), msg.cstr()); } const int imageCount = gifFile->ImageCount; for(int k = 0; k < imageCount; k++) { add(new GifPixRect(gifFile, k)); } DGifCloseFile(gifFile, &error); } else { add(GifPixRect::load(name)); } } catch(Exception e) { errors.add(e.what()); } } }
/* * This function cleans up the gif object after the decode completes * It is used in a SkAutoTCallIProc template */ void SkGifCodec::CloseGif(GifFileType* gif) { #if GIFLIB_MAJOR < 5 || (GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 0) DGifCloseFile(gif); #else DGifCloseFile(gif, nullptr); #endif }
int GIFAbstractDataset::myDGifCloseFile( GifFileType *hGifFile ) { #if defined(GIFLIB_MAJOR) && ((GIFLIB_MAJOR == 5 && GIFLIB_MINOR >= 1) || GIFLIB_MAJOR > 5) int nErrorCode; return DGifCloseFile( hGifFile, &nErrorCode ); #else return DGifCloseFile( hGifFile ); #endif }
bool compress_custom(void* input_data, InputFunc input_func, void* output_data, OutputFunc output_func, int sample_size) { GifFileType* input_gif = NULL; GifFileType* output_gif = NULL; int result = GIF_ERROR; // Check sample if (sample_size <= 0) { return false; } input_gif = DGifOpen(input_data, input_func, &error_code); if (input_gif == NULL) { LOGE(EMSG("Can't open input gif")); return false; } DGifSlurp(input_gif); if (input_gif->ImageCount == 0) { LOGE(EMSG("Gif frame count is 0")); DGifCloseFile(input_gif, &error_code); return false; } // Save gif output_gif = EGifOpen(output_data, output_func, &error_code); if (output_gif == NULL) { LOGE(EMSG("Can't open output gif")); DGifCloseFile(input_gif, &error_code); return false; } if (do_compress(input_gif, output_gif, sample_size)) { result = EGifSpew(output_gif); } // Free GifFreeExtensions(&output_gif->ExtensionBlockCount, &output_gif->ExtensionBlocks); if (output_gif->SavedImages) { GifFreeSavedImages(output_gif); output_gif->SavedImages = NULL; } // Close gif DGifCloseFile(input_gif, &error_code); return result == GIF_OK; }
value dGifCloseFile( value hdl ) { CAMLparam1(hdl); /* For the bug libungif/giflib 4.1.0 */ /* This may add a new memory leak, but it is better than having segmentation faults */ ((GifFileType *)hdl)->Image.ColorMap = NULL; #if (GIFLIB_MAJOR <= 4) DGifCloseFile( (GifFileType *) hdl); #else DGifCloseFile( (GifFileType *) hdl, NULL ); #endif CAMLreturn0; }
Image* readGifFile ( int infile ) { Image *img = 0; #if defined(INCLUDE_GIF) /* * we don't use DGifOpenFile because file io might be intercepted * (because of threading) */ FileSource fileSrc; GifFileType *gf; fileSrc.fd = infile; if ( !(gf = DGifOpen( &fileSrc, readGifFileSource)) ) return 0; img = readGif( gf); DGifCloseFile( gf); #endif return img; }
/****************************************************************************** * Close both input and output file (if open), and exit. * ******************************************************************************/ static void QuitGifError(GifFileType *GifFileIn, GifFileType *GifFileOut) { PrintGifError(); if (GifFileIn != NULL) DGifCloseFile(GifFileIn); if (GifFileOut != NULL) EGifCloseFile(GifFileOut); exit(EXIT_FAILURE); }
static void cleanUp(GifInfo* info) { free(info->backupPtr); info->backupPtr = NULL; free(info->infos); info->infos = NULL; free(info->rasterBits); info->rasterBits = NULL; free(info->comment); info->comment = NULL; GifFileType* GifFile = info->gifFilePtr; if (GifFile->SavedImages != NULL) { SavedImage *sp; for (sp = GifFile->SavedImages; sp < GifFile->SavedImages + GifFile->ImageCount; sp++) { if (sp->ImageDesc.ColorMap != NULL) { GifFreeMapObject(sp->ImageDesc.ColorMap); sp->ImageDesc.ColorMap = NULL; } } free(GifFile->SavedImages); GifFile->SavedImages = NULL; } DGifCloseFile(GifFile); free(info); }
int main(int argc, char **argv) { argv++; if(!*argv) usage(); int errorCode; GifFileType *gifFile = DGifOpenFileName(*argv, &errorCode); if(gifFile == NULL) { printf("Error:%s\n", GifErrorString(errorCode)); exit(-1); } CHECKGIFOK(DGifSlurp(gifFile)); _tprintf(_T("GifFile:Size:(%d,%d)\n"), gifFile->SWidth, gifFile->SHeight); _tprintf(_T("GifFile:BackgroundColor:%d, AspectByte:%d, ColorResultion:%d\n"), gifFile->SBackGroundColor, gifFile->AspectByte, gifFile->SColorResolution); _tprintf(_T("GifFile ")); dumpImageDesc(gifFile->Image); _tprintf(_T("GifFile:")); dumpColorMap(gifFile->SColorMap); _tprintf(_T("GifFile.ExtentionBlocks:\n")); dumpExtensionBlocks(gifFile->ExtensionBlocks, gifFile->ExtensionBlockCount); for(int i = 0; i < gifFile->ImageCount; i++) { dumpSavedImage(i, gifFile->SavedImages[i]); } if(DGifCloseFile(gifFile, &errorCode) != GIF_OK) { CHECKGIFOK(errorCode); } return 0; }
/****************************************************************************** * Close both input and output file (if open), and exit. * ******************************************************************************/ static void QuitGifError(GifFileType *GifFileIn, GifFileType *GifFileOut) { fprintf(stderr, "\nFollowing unrecoverable error occured:"); PrintGifError(); if (GifFileIn != NULL) DGifCloseFile(GifFileIn); if (GifFileOut != NULL) EGifCloseFile(GifFileOut); exit(EXIT_FAILURE); }
void AnimatedImage::load(CWnd *parent, ByteInputStream &in) { int error; GifFileType *gifFile = DGifOpen(&in, readGifStreamFunction, &error); if(gifFile == NULL) { THROWGIFERROR(error); } try { if(DGifSlurp(gifFile) != GIF_OK) { THROWGIFERROR(gifFile->Error); } createFromGifFile(parent, gifFile); DGifCloseFile(gifFile, &error); } catch(...) { DGifCloseFile(gifFile, &error); throw; } }
MCGIFImageLoader::~MCGIFImageLoader() { if (m_gif != nil) { int t_error_code; DGifCloseFile(m_gif, &t_error_code); m_gif = nil; } }
/****************************************************************************** * Close both input and output file (if open), and exit. * ******************************************************************************/ static int QuitGifError(GifFileType *GifFileIn, GifFileType *GifFileOut) { int ErrorCode; // PrintGifError(ErrorCode); if (GifFileIn != NULL) DGifCloseFile(GifFileIn, &ErrorCode); if (GifFileOut != NULL) EGifCloseFile(GifFileOut, &ErrorCode); //exit(1); return -1; }
static int DGifCloseMem(GifFileType *gifFile) { if (gifFile->UserData != NULL) { GifMemoryType *gifMemoryType = (GifMemoryType *) gifFile->UserData; gif_free(gifMemoryType); } return DGifCloseFile(gifFile); }
static int decode_gif_pixels(struct gps_map *map, unsigned char *out, int x, int y, int width, int height, int bpp, int row_stride) { struct raster_map *raster_map = map->data; GifFileType *gf; GifRecordType record_type; int r; if (bpp != 24) return -1; gf = DGifOpenFileName(raster_map->bitmap_filename); if (gf == NULL) { gps_error("%s: %s", raster_map->bitmap_filename, strerror(errno)); return -1; } r = -1; do { if (DGifGetRecordType(gf, &record_type) == GIF_ERROR) { PrintGifError(); goto fail; } switch (record_type) { case IMAGE_DESC_RECORD_TYPE: if (DGifGetImageDesc(gf) == GIF_ERROR) { PrintGifError(); goto fail; } if (gf->Image.Width != map->width || gf->Image.Height != map->height) { gps_error("%s: GIF subimages not supported", raster_map->bitmap_filename); goto fail; } if (gf->Image.Interlace) { gps_error("%s: interlaced GIFs not supported", raster_map->bitmap_filename); goto fail; } output_gif_pixels(map, gf, x, y, width, height, row_stride, out); break; case EXTENSION_RECORD_TYPE: gps_error("%s: GIF extensions not supported", raster_map->bitmap_filename); goto fail; case UNDEFINED_RECORD_TYPE: case SCREEN_DESC_RECORD_TYPE: case TERMINATE_RECORD_TYPE: break; } } while (record_type != IMAGE_DESC_RECORD_TYPE); r = 0; fail: DGifCloseFile(gf); return r; }
GifFilesCloser::~GifFilesCloser() { if (mGifIn) { DGifCloseFile(mGifIn); mGifIn = NULL; } if (mGifOut) { EGifCloseFile(mGifOut); mGifOut = NULL; } }
BIGGIFDataset::~BIGGIFDataset() { FlushCache(); if( hGifFile ) DGifCloseFile( hGifFile ); if( fp != NULL ) VSIFCloseL( fp ); CloseDependentDatasets(); }
void cleanUp(GifInfo *info) { free(info->backupPtr); info->backupPtr = NULL; free(info->controlBlock); info->controlBlock = NULL; free(info->rasterBits); info->rasterBits = NULL; free(info->comment); info->comment = NULL; DGifCloseFile(info->gifFilePtr); free(info); }
int main(int argc, char **argv) { int i, ErrorCode; GifFileType *GifFileIn, *GifFileOut = (GifFileType *)NULL; if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL) { PrintGifError(ErrorCode); exit(EXIT_FAILURE); } if (DGifSlurp(GifFileIn) == GIF_ERROR) { PrintGifError(GifFileIn->Error); exit(EXIT_FAILURE); } if ((GifFileOut = EGifOpenFileHandle(1, &ErrorCode)) == NULL) { PrintGifError(ErrorCode); exit(EXIT_FAILURE); } /* * Your operations on in-core structures go here. * This code just copies the header and each image from the incoming file. */ GifFileOut->SWidth = GifFileIn->SWidth; GifFileOut->SHeight = GifFileIn->SHeight; GifFileOut->SColorResolution = GifFileIn->SColorResolution; GifFileOut->SBackGroundColor = GifFileIn->SBackGroundColor; GifFileOut->SColorMap = GifMakeMapObject( GifFileIn->SColorMap->ColorCount, GifFileIn->SColorMap->Colors); for (i = 0; i < GifFileIn->ImageCount; i++) (void) GifMakeSavedImage(GifFileOut, &GifFileIn->SavedImages[i]); /* * Note: don't do DGifCloseFile early, as this will * deallocate all the memory containing the GIF data! * * Further note: EGifSpew() doesn't try to validity-check any of this * data; it's *your* responsibility to keep your changes consistent. * Caveat hacker! */ if (EGifSpew(GifFileOut) == GIF_ERROR) PrintGifError(GifFileOut->Error); if (DGifCloseFile(GifFileIn, &ErrorCode) == GIF_ERROR) PrintGifError(ErrorCode); if (EGifCloseFile(GifFileOut, &ErrorCode) == GIF_ERROR) PrintGifError(ErrorCode); return 0; }
int fh_gif_getsize(const char *name,int *x,int *y, int wanted_width, int wanted_height) { int err = 0; int px,py; GifFileType *gft; GifByteType *extension; int extcode; GifRecordType rt; gft=DGifOpenFileName(name, &err); if(gft==NULL) gflush; do { if(DGifGetRecordType(gft,&rt) == GIF_ERROR) grflush; switch(rt) { case IMAGE_DESC_RECORD_TYPE: if(DGifGetImageDesc(gft)==GIF_ERROR) grflush; px=gft->Image.Width; py=gft->Image.Height; *x=px; *y=py; DGifCloseFile(gft, &err); return(FH_ERROR_OK); break; case EXTENSION_RECORD_TYPE: if(DGifGetExtension(gft,&extcode,&extension)==GIF_ERROR) grflush; while(extension!=NULL) if(DGifGetExtensionNext(gft,&extension)==GIF_ERROR) grflush; break; default: break; } } while( rt!= TERMINATE_RECORD_TYPE ); DGifCloseFile(gft, &err); return(FH_ERROR_FORMAT); }
SkGIFMovie::SkGIFMovie(SkStream* stream) { fGIF = DGifOpen( stream, Decode ); if (NULL == fGIF) return; if (DGifSlurp(fGIF) != GIF_OK) { DGifCloseFile(fGIF); fGIF = NULL; } fCurrIndex = -1; fLastDrawIndex = -1; }
inline bool GIFInput::close (void) { if (m_gif_file) { if (DGifCloseFile (m_gif_file) == GIF_ERROR) { error ("Error trying to close the file."); return false; } m_gif_file = NULL; } m_cached_data.clear (); return true; }
static void gif_done(void *data) { struct gif_state *h = (struct gif_state *) data; if (FbiStuff::fim_filereading_debug()) FIM_FBI_PRINTF("gif: done, cleaning up\n"); DGifCloseFile(h->gif); fclose(h->infile); if (h->il) fim_free(h->il); fim_free(h->row); fim_free(h); }
static int read_gif_header(struct gps_map *map) { GifFileType *gif_file; struct raster_map *raster_map = map->data; gif_file = DGifOpenFileName(raster_map->bitmap_filename); if (gif_file == NULL) { gps_error("%s: %s", raster_map->bitmap_filename, strerror(errno)); return -1; } map->width = gif_file->SWidth; map->height = gif_file->SHeight; DGifCloseFile(gif_file); return 0; }
void cleanUp(GifInfo *info) { info->surfaceDescriptor = NULL; free(info->backupPtr); info->backupPtr = NULL; free(info->controlBlock); info->controlBlock = NULL; free(info->rasterBits); info->rasterBits = NULL; free(info->comment); info->comment = NULL; GifFileType *GifFile = info->gifFilePtr; DGifCloseFile(GifFile); free(info); }
static GifFileType *loadGif(ByteInputStream &in) { int error; GifFileType *gf = DGifOpen(&in, readGifStreamFunction, &error); if(gf == NULL) { THROWGIFERROR(error); } try { if(DGifSlurp(gf) != GIF_OK) { THROWGIFERROR(gf->Error); } return gf; } catch(...) { DGifCloseFile(gf, &error); throw; } }
static ULONG WINAPI GifDecoder_Release(IWICBitmapDecoder *iface) { GifDecoder *This = (GifDecoder*)iface; ULONG ref = InterlockedDecrement(&This->ref); TRACE("(%p) refcount=%u\n", iface, ref); if (ref == 0) { This->lock.DebugInfo->Spare[0] = 0; DeleteCriticalSection(&This->lock); DGifCloseFile(This->gif); HeapFree(GetProcessHeap(), 0, This); } return ref; }
SkGIFMovie::SkGIFMovie(SkStream* stream) { #if GIFLIB_MAJOR < 5 fGIF = DGifOpen( stream, Decode ); #else fGIF = DGifOpen( stream, Decode, NULL ); #endif if (NULL == fGIF) return; if (DGifSlurp(fGIF) != GIF_OK) { DGifCloseFile(fGIF); fGIF = NULL; } fCurrIndex = -1; fLastDrawIndex = -1; }
image* load_image (char* file, image_format fmt) { image* img = NULL; if (fmt == imgIRMID) { FILE* fp; fp = fopen (file, "r"); image simage; fread (&simage, sizeof(image), 1, fp); img = (image*) malloc (simage.size); fseek (fp, 0, SEEK_SET); fread (img, simage.size, 1, fp); fclose (fp); } else if (fmt == imgGIF) { GifFileType* GifFileIn = DGifOpenFileName (file); int size = GifFileIn->SWidth * GifFileIn->SHeight * sizeof (rtbyte) + sizeof (image) - sizeof (rtbyte); img = (image*) malloc (size); img->size = size; img->dimx = GifFileIn->SWidth; img->dimy = GifFileIn->SHeight; img->dimc = 1; img->dimz = 1; img->dimt = 1; img->xyz = img->xy = img->dimx * img->dimy; img->len = img->xy * sizeof (rdword); img->clr = clrmGrey; GifRecordType record; GifRowType pixels = (GifRowType) new GifPixelType[img->xy]; do { DGifGetRecordType(GifFileIn, &record); if (record != IMAGE_DESC_RECORD_TYPE) continue; DGifGetImageDesc (GifFileIn); for (int row = 0; row < img->dimy; ++row) DGifGetLine (GifFileIn, pixels + row * img->dimx, img->dimx); } while (record != TERMINATE_RECORD_TYPE); for (uint n = 0; n < img->xy; ++n) data(img)[n] = (rtbyte)pixels[n]; DGifCloseFile (GifFileIn); } return (img); }
BIGGIFDataset::~BIGGIFDataset() { FlushCache(); if( hGifFile ) DGifCloseFile( hGifFile ); if( fp != NULL ) VSIFCloseL( fp ); if( poWorkDS != NULL ) { CPLString osTempFilename = poWorkDS->GetDescription(); GDALClose( (GDALDatasetH) poWorkDS ); poWorkDS = NULL; GDALDriver *poGTiff = (GDALDriver *) GDALGetDriverByName( "GTiff" ); poGTiff->Delete( osTempFilename ); } }