自学教程：C++ DGifCloseFile函数代码示例

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;}

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;}

static voidgif_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;  }}

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 );    }}