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

GifRecordType GIFAbstractDataset::FindFirstImage( GifFileType* hGifFile ){    GifRecordType RecordType = TERMINATE_RECORD_TYPE;    while( DGifGetRecordType(hGifFile, &RecordType) != GIF_ERROR           && RecordType != TERMINATE_RECORD_TYPE           && RecordType != IMAGE_DESC_RECORD_TYPE )    {        /* Skip extension records found before IMAGE_DESC_RECORD_TYPE */        if (RecordType == EXTENSION_RECORD_TYPE)        {            int nFunction;            GifByteType *pExtData = nullptr;            if (DGifGetExtension(hGifFile, &nFunction, &pExtData) == GIF_ERROR)                break;            while (pExtData != nullptr)            {                if (DGifGetExtensionNext(hGifFile, &pExtData) == GIF_ERROR)                    break;            }        }    }    return RecordType;}

value dGifGetExtension( value hdl ){  CAMLparam1(hdl);  CAMLlocal3(ext,exts,res);  CAMLlocal1(newres);  GifFileType *GifFile = (GifFileType*) hdl;  int func;  GifByteType *extData;  exts = Val_int(0);  if (DGifGetExtension(GifFile,&func, &extData) == GIF_ERROR){    failwith("DGifGetExtension");  }  while( extData != NULL ){    ext= alloc_string(extData[0]);    memcpy(String_val(ext), &extData[1], extData[0]);    newres = alloc_small(2,0);    caml_modify_field(newres, 0, ext);    caml_modify_field(newres, 1, exts);    exts= newres;    DGifGetExtensionNext(GifFile, &extData);  }  res = alloc_small(2,0);  caml_modify_field(res,0, Val_int(func));  caml_modify_field(res,1, exts);  CAMLreturn(res);}

static GifRecordTypegif_fileread(struct gif_state *h){    GifRecordType RecordType;    GifByteType *Extension;    int ExtCode, rc;    const char *type;    for (;;) {	if (GIF_ERROR == DGifGetRecordType(h->gif,&RecordType)) {	    if (FbiStuff::fim_filereading_debug())		FIM_FBI_PRINTF("gif: DGifGetRecordType failed/n");	    PrintGifError();	    return (GifRecordType)-1;	}	switch (RecordType) {	case IMAGE_DESC_RECORD_TYPE:	    if (FbiStuff::fim_filereading_debug())		FIM_FBI_PRINTF("gif: IMAGE_DESC_RECORD_TYPE found/n");	    return RecordType;	case EXTENSION_RECORD_TYPE:	    if (FbiStuff::fim_filereading_debug())		FIM_FBI_PRINTF("gif: EXTENSION_RECORD_TYPE found/n");	    for (rc = DGifGetExtension(h->gif,&ExtCode,&Extension);		 NULL != Extension;		 rc = DGifGetExtensionNext(h->gif,&Extension)) {		if (rc == GIF_ERROR) {		    if (FbiStuff::fim_filereading_debug())			FIM_FBI_PRINTF("gif: DGifGetExtension failed/n");		    PrintGifError();		    return (GifRecordType)-1;		}		if (FbiStuff::fim_filereading_debug()) {		    switch (ExtCode) {		    case COMMENT_EXT_FUNC_CODE:     type="comment";   break;		    case GRAPHICS_EXT_FUNC_CODE:    type="graphics";  break;		    case PLAINTEXT_EXT_FUNC_CODE:   type="plaintext"; break;		    case APPLICATION_EXT_FUNC_CODE: type="appl";      break;		    default:                        type="???";       break;		    }		    FIM_FBI_PRINTF("gif: extcode=0x%x [%s]/n",ExtCode,type);		}	    }	    break;	case TERMINATE_RECORD_TYPE:	    if (FbiStuff::fim_filereading_debug())		FIM_FBI_PRINTF("gif: TERMINATE_RECORD_TYPE found/n");	    return RecordType;	default:	    if (FbiStuff::fim_filereading_debug())		FIM_FBI_PRINTF("gif: unknown record type [%d]/n",RecordType);	    return (GifRecordType)-1;	}    }}

int fh_gif_getsize(const char *name,int *x,int *y, int /*wanted_width*/, int /*wanted_height*/){	int px,py;	GifFileType *gft;	GifByteType *extension;	int extcode;	GifRecordType rt;#if GIFLIB_MAJOR >= 5	int error;	gft=DGifOpenFileName(name, &error);#else	gft=DGifOpenFileName(name);#endif	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);				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);	return(FH_ERROR_FORMAT);}

int fh_gif_getsize(char *name,int *x,int *y){    int px,py;    GifFileType *gft;    GifByteType *extension;    int extcode;    GifRecordType rt;    gft=DGifOpenFileName(name);    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);		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);    return(FH_ERROR_FORMAT);}

bool img_load_gif(img_t *img, const fileinfo_t *file){	GifFileType *gif;	GifRowType *rows = NULL;	GifRecordType rec;	ColorMapObject *cmap;	DATA32 bgpixel, *data, *ptr;	DATA32 *prev_frame = NULL;	Imlib_Image im;	int i, j, bg, r, g, b;	int x, y, w, h, sw, sh;	int px, py, pw, ph;	int intoffset[] = { 0, 4, 2, 1 };	int intjump[] = { 8, 8, 4, 2 };	int transp = -1;	unsigned int disposal = 0, prev_disposal = 0;	unsigned int delay = 0;	bool err = false;	if (img->multi.cap == 0) {		img->multi.cap = 8;		img->multi.frames = (img_frame_t*)		                    s_malloc(sizeof(img_frame_t) * img->multi.cap);	}	img->multi.cnt = img->multi.sel = 0;	img->multi.length = img->multi.repeat = 0;#if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5	gif = DGifOpenFileName(file->path, NULL);#else	gif = DGifOpenFileName(file->path);#endif	if (gif == NULL) {		warn("could not open gif file: %s", file->name);		return false;	}	bg = gif->SBackGroundColor;	sw = gif->SWidth;	sh = gif->SHeight;	px = py = pw = ph = 0;	do {		if (DGifGetRecordType(gif, &rec) == GIF_ERROR) {			err = true;			break;		}		if (rec == EXTENSION_RECORD_TYPE) {			int ext_code;			GifByteType *ext = NULL;			DGifGetExtension(gif, &ext_code, &ext);			while (ext) {				if (ext_code == GRAPHICS_EXT_FUNC_CODE) {					if (ext[1] & 1)						transp = (int) ext[4];					else						transp = -1;					delay = 10 * ((unsigned int) ext[3] << 8 | (unsigned int) ext[2]);					if (delay)						delay = MAX(delay, MIN_GIF_DELAY);					disposal = (unsigned int) ext[1] >> 2 & 0x7;				} else if (ext_code == APPLICATION_EXT_FUNC_CODE) {					if (ext[0] == 11 && memcmp(ext+1, "NETSCAPE2.0", 11) == 0) {						DGifGetExtensionNext(gif, &ext);						if (ext && ext[0] == 3 && ext[1] == 1)							img->multi.repeat = ((int) ext[3] << 8 | (int) ext[2]) - 1;					}				}				ext = NULL;				DGifGetExtensionNext(gif, &ext);			}		} else if (rec == IMAGE_DESC_RECORD_TYPE) {

bool img_load_gif(img_t *img, const fileinfo_t *file){	GifFileType *gif;	GifRowType *rows = NULL;	GifRecordType rec;	ColorMapObject *cmap;	DATA32 bgpixel, *data, *ptr;	DATA32 *prev_frame = NULL;	Imlib_Image im;	int i, j, bg, r, g, b;	int x, y, w, h, sw, sh;	int px, py, pw, ph;	int intoffset[] = { 0, 4, 2, 1 };	int intjump[] = { 8, 8, 4, 2 };	int transp = -1;	unsigned int disposal = 0, prev_disposal = 0;	unsigned int delay = 0;	bool err = false;	if (img->multi.cap == 0) {		img->multi.cap = 8;		img->multi.frames = (img_frame_t*)		                    s_malloc(sizeof(img_frame_t) * img->multi.cap);	}	img->multi.cnt = img->multi.sel = 0;	img->multi.length = 0;#if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5	gif = DGifOpenFileName(file->path, NULL);#else	gif = DGifOpenFileName(file->path);#endif	if (gif == NULL) {		warn("could not open gif file: %s", file->name);		return false;	}	bg = gif->SBackGroundColor;	sw = gif->SWidth;	sh = gif->SHeight;	px = py = pw = ph = 0;	do {		if (DGifGetRecordType(gif, &rec) == GIF_ERROR) {			err = true;			break;		}		if (rec == EXTENSION_RECORD_TYPE) {			int ext_code;			GifByteType *ext = NULL;			DGifGetExtension(gif, &ext_code, &ext);			while (ext) {				if (ext_code == GRAPHICS_EXT_FUNC_CODE) {					if (ext[1] & 1)						transp = (int) ext[4];					else						transp = -1;					delay = 10 * ((unsigned int) ext[3] << 8 | (unsigned int) ext[2]);					disposal = (unsigned int) ext[1] >> 2 & 0x7;				}				ext = NULL;				DGifGetExtensionNext(gif, &ext);			}		} else if (rec == IMAGE_DESC_RECORD_TYPE) {			if (DGifGetImageDesc(gif) == GIF_ERROR) {				err = true;				break;			}			x = gif->Image.Left;			y = gif->Image.Top;			w = gif->Image.Width;			h = gif->Image.Height;			rows = (GifRowType*) s_malloc(h * sizeof(GifRowType));			for (i = 0; i < h; i++)				rows[i] = (GifRowType) s_malloc(w * sizeof(GifPixelType));			if (gif->Image.Interlace) {				for (i = 0; i < 4; i++) {					for (j = intoffset[i]; j < h; j += intjump[i])						DGifGetLine(gif, rows[j], w);				}			} else {				for (i = 0; i < h; i++)					DGifGetLine(gif, rows[i], w);			}			ptr = data = (DATA32*) s_malloc(sizeof(DATA32) * sw * sh);			cmap = gif->Image.ColorMap ? gif->Image.ColorMap : gif->SColorMap;			r = cmap->Colors[bg].Red;			g = cmap->Colors[bg].Green;			b = cmap->Colors[bg].Blue;			bgpixel = 0x00ffffff & (r << 16 | g << 8 | b);			for (i = 0; i < sh; i++) {				for (j = 0; j < sw; j++) {					if (i < y || i >= y + h || j < x || j >= x + w ||					    rows[i-y][j-x] == transp)					{						if (prev_frame != NULL && (prev_disposal != 2 ||//.........这里部分代码省略.........

unsigned char      *loader_gif(FILE *f, int *w, int *h, int *t){  unsigned char      *data, *ptr;  GifFileType        *gif;  GifRowType         *rows;  GifRecordType       rec;  ColorMapObject     *cmap;  int                 i, j, done, bg, csize, r, g, b;  int                 intoffset[] = {0, 4, 2, 1};  int                 intjump[] = {8, 8, 4, 2};  int                 istransp, transp;  int                 fd;  done = 0;  istransp = 0;  fd = fileno(f);  /* Apparently rewind(f) isn't sufficient */  lseek(fd, (long) 0, 0);  gif = DGifOpenFileHandle(fd);  transp = -1;  data = NULL;  rows = NULL;  if (!gif)    return NULL;  do    {      if (DGifGetRecordType(gif, &rec) == GIF_ERROR)	{	  PrintGifError();	  rec = TERMINATE_RECORD_TYPE;	}      if ((rec == IMAGE_DESC_RECORD_TYPE) && (!done))	{	  if (DGifGetImageDesc(gif) == GIF_ERROR)	    {	      PrintGifError();	      rec = TERMINATE_RECORD_TYPE;	    }	  *w = gif->Image.Width;	  *h = gif->Image.Height;	  if(*h > 32767 || *w > 32767)	    {	      return NULL;	    }	  rows = malloc(*h * sizeof(GifRowType *));	  if (!rows)	    {	      DGifCloseFile(gif);	      return NULL;	    }	  data = _gdk_malloc_image(*w, *h);	  if (!data)	    {	      DGifCloseFile(gif);	      free(rows);	      return NULL;	    }	  for (i = 0; i < *h; i++)	    rows[i] = NULL;	  for (i = 0; i < *h; i++)	    {	      rows[i] = malloc(*w * sizeof(GifPixelType));	      if (!rows[i])		{		  DGifCloseFile(gif);		  for (i = 0; i < *h; i++)		    if (rows[i])		      free(rows[i]);		  free(rows);		  free(data);		  return NULL;		}	    }	  if (gif->Image.Interlace)	    {	      for (i = 0; i < 4; i++)		{		  for (j = intoffset[i]; j < *h; j += intjump[i])		    DGifGetLine(gif, rows[j], *w);		}	    }	  else	    {	      for (i = 0; i < *h; i++)		DGifGetLine(gif, rows[i], *w);	    }	  done = 1;	}      else if (rec == EXTENSION_RECORD_TYPE)	{	  int                 ext_code;	  GifByteType        *ext;	  ext = NULL;	  DGifGetExtension(gif, &ext_code, &ext);//.........这里部分代码省略.........

//.........这里部分代码省略.........		exit(EXIT_FAILURE);	    }	    printf("image # %d/nimage left %d/nimage top %d/n",		   ImageNum++,		   GifFile->Image.Left, GifFile->Image.Top);	    if (GifFile->Image.Interlace)		printf("interlaced/n");	    if (GifFile->Image.ColorMap)	    {		if (GifFile->Image.ColorMap->ColorCount >= (int)strlen(NameTable))		{		    (void) fprintf(stderr,				   "%s: global color map has unprintable pixels/n",				   FileName);		    exit(EXIT_FAILURE);		}		printf("image map/n");		for (i = 0; i < GifFile->Image.ColorMap->ColorCount; i++)		    printf("/trgb %03d %03d %03d is %c/n",			   GifFile->Image.ColorMap ->Colors[i].Red,			   GifFile->Image.ColorMap ->Colors[i].Green,			   GifFile->Image.ColorMap ->Colors[i].Blue,			   NameTable[i]);		printf("end/n/n");	    }	    printf("image bits %d by %d/n",		   GifFile->Image.Width, GifFile->Image.Height);	    Line = (GifPixelType *) malloc(GifFile->Image.Width *					   sizeof(GifPixelType));	    for (i = 0; i < GifFile->Image.Height; i++) {		if (DGifGetLine(GifFile, Line, GifFile->Image.Width)		    == GIF_ERROR) {		    PrintGifError();		    exit(EXIT_FAILURE);		}		for (cp = Line; cp < Line + GifFile->Image.Width; cp++)		    putchar(NameTable[*cp]);		putchar('/n');	    }	    free((char *) Line);	    putchar('/n');	    break;	case EXTENSION_RECORD_TYPE:	    if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {		PrintGifError();		exit(EXIT_FAILURE);	    }	    if (ExtCode == COMMENT_EXT_FUNC_CODE)		printf("comment/n");	    else if (ExtCode == PLAINTEXT_EXT_FUNC_CODE)		printf("plaintext/n");	    else if (isalpha(ExtCode))		printf("extension %02x    # %c/n", ExtCode, ExtCode);	    else		printf("extension %02x/n", ExtCode);	    while (Extension != NULL) {		VisibleDumpBuffer((char *)(Extension + 1), Extension[0]);		putchar('/n');		if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {		    PrintGifError();		    exit(EXIT_FAILURE);		}	    }	    printf("end/n/n");	    break;	case TERMINATE_RECORD_TYPE:	    break;	default:		/* Should be traps by DGifGetRecordType */	    break;	}    }    while	(RecordType != TERMINATE_RECORD_TYPE);    /* Tell EMACS this is a picture... */    printf("# The following sets edit modes for GNU EMACS/n");    printf("# Local ");		/* ...break this up, so that EMACS doesn't */    printf("Variables:/n");	/* get confused when visiting *this* file! */    printf("# mode:picture/n");    printf("# truncate-lines:t/n");    printf("# End:/n");    if (fdin == -1)	(void) printf("# End of %s dump/n", FileName);    if (DGifCloseFile(GifFile) == GIF_ERROR) {	PrintGifError();	exit(EXIT_FAILURE);    }}

/****************************************************************************** Main sequence******************************************************************************/int main(int argc, char **argv){    GifFileType *GifFileIn = NULL, *GifFileOut = NULL;    GifRecordType RecordType;    int CodeSize, ExtCode, ErrorCode;    GifByteType *CodeBlock, *Extension;    /*     * Command-line processing goes here.     */    /* Use stdin as input (note this also read screen descriptor in: */    if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL) {	PrintGifError(ErrorCode);	exit(EXIT_FAILURE);    }    /* Use the stdout as output: */    if ((GifFileOut = EGifOpenFileHandle(1, &ErrorCode)) == NULL) {	PrintGifError(ErrorCode);	exit(EXIT_FAILURE);    }    /* And dump out its screen information: */    if (EGifPutScreenDesc(GifFileOut,	GifFileIn->SWidth, GifFileIn->SHeight,	GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,	GifFileIn->SColorMap) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);    /* Scan the content of the input GIF file and load the image(s) in: */    do {	if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)	    QuitGifError(GifFileIn, GifFileOut);	switch (RecordType) {	    case IMAGE_DESC_RECORD_TYPE:		if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* Put image descriptor to out file: */		if (EGifPutImageDesc(GifFileOut,		    GifFileIn->Image.Left, GifFileIn->Image.Top,		    GifFileIn->Image.Width, GifFileIn->Image.Height,		    GifFileIn->Image.Interlace,		    GifFileIn->Image.ColorMap) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* Now read image itself in decoded form as we dont really   */		/* care what we have there, and this is much faster.	     */		if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR ||		    EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		while (CodeBlock != NULL) {		    if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR ||			EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		}		break;	    case EXTENSION_RECORD_TYPE:		/* pass through extension records */		if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (EGifPutExtensionLeader(GifFileOut, ExtCode) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (EGifPutExtensionBlock(GifFileOut, 					  Extension[0],					  Extension + 1) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		while (Extension != NULL) {		    if (DGifGetExtensionNext(GifFileIn, &Extension)==GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		    if (Extension != NULL)			if (EGifPutExtensionBlock(GifFileOut, 						  Extension[0],						  Extension + 1) == GIF_ERROR)			    QuitGifError(GifFileIn, GifFileOut);		}		if (EGifPutExtensionTrailer(GifFileOut) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		break;	    case TERMINATE_RECORD_TYPE:		break;	    default:	     /* Should be trapped by DGifGetRecordType */		break;	}    }    while (RecordType != TERMINATE_RECORD_TYPE);    if (DGifCloseFile(GifFileIn, &ErrorCode) == GIF_ERROR)    {	PrintGifError(ErrorCode);	if (GifFileIn != NULL) {	    EGifCloseFile(GifFileIn, NULL);	}	exit(EXIT_FAILURE);    }    if (EGifCloseFile(GifFileOut, &ErrorCode) == GIF_ERROR)//.........这里部分代码省略.........

GDALDataset *GIFDataset::Open( GDALOpenInfo * poOpenInfo ){    if( !Identify( poOpenInfo ) )        return NULL;    if( poOpenInfo->eAccess == GA_Update )    {        CPLError( CE_Failure, CPLE_NotSupported,                   "The GIF driver does not support update access to existing"                  " files./n" );        return NULL;    }/* -------------------------------------------------------------------- *//*      Open the file and ingest.                                       *//* -------------------------------------------------------------------- */    GifFileType 	*hGifFile;    VSILFILE                *fp;    int                  nGifErr;    fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );    if( fp == NULL )        return NULL;    hGifFile = GIFAbstractDataset::myDGifOpen( fp, VSIGIFReadFunc );    if( hGifFile == NULL )    {        VSIFCloseL( fp );        CPLError( CE_Failure, CPLE_OpenFailed,                   "DGifOpen() failed for %s./n"                  "Perhaps the gif file is corrupt?/n",                  poOpenInfo->pszFilename );        return NULL;    }    /* The following code enables us to detect GIF datasets eligible */    /* for BIGGIF driver even with an unpatched giflib  */    /* -------------------------------------------------------------------- */    /*      Find the first image record.                                    */    /* -------------------------------------------------------------------- */    GifRecordType RecordType = TERMINATE_RECORD_TYPE;    while( DGifGetRecordType(hGifFile, &RecordType) != GIF_ERROR        && RecordType != TERMINATE_RECORD_TYPE        && RecordType != IMAGE_DESC_RECORD_TYPE )    {        /* Skip extension records found before IMAGE_DESC_RECORD_TYPE */        if (RecordType == EXTENSION_RECORD_TYPE)        {            int nFunction;            GifByteType *pExtData;            if (DGifGetExtension(hGifFile, &nFunction, &pExtData) == GIF_ERROR)                break;            while (pExtData != NULL)            {                if (DGifGetExtensionNext(hGifFile, &pExtData) == GIF_ERROR)                    break;            }        }    }    if( RecordType == IMAGE_DESC_RECORD_TYPE  &&        DGifGetImageDesc(hGifFile) != GIF_ERROR)    {        int width = hGifFile->SavedImages[0].ImageDesc.Width;        int height = hGifFile->SavedImages[0].ImageDesc.Height;        if ((double) width * (double) height > 100000000.0 )        {            CPLDebug( "GIF",                      "Due to limitations of the GDAL GIF driver we deliberately avoid/n"                      "opening large GIF files (larger than 100 megapixels).");            GIFAbstractDataset::myDGifCloseFile( hGifFile );            VSIFCloseL( fp );            return NULL;        }    }    GIFAbstractDataset::myDGifCloseFile( hGifFile );    VSIFSeekL( fp, 0, SEEK_SET);    hGifFile = GIFAbstractDataset::myDGifOpen( fp, VSIGIFReadFunc );    if( hGifFile == NULL )    {        VSIFCloseL( fp );        CPLError( CE_Failure, CPLE_OpenFailed,                   "DGifOpen() failed for %s./n"                  "Perhaps the gif file is corrupt?/n",                  poOpenInfo->pszFilename );        return NULL;    }    nGifErr = DGifSlurp( hGifFile );    if( nGifErr != GIF_OK || hGifFile->SavedImages == NULL )    {//.........这里部分代码省略.........

CPLErr BIGGIFDataset::ReOpen(){/* -------------------------------------------------------------------- *//*      If the file is already open, close it so we can restart.        *//* -------------------------------------------------------------------- */    if( hGifFile != NULL )        DGifCloseFile( hGifFile );/* -------------------------------------------------------------------- *//*      If we are actually reopening, then we assume that access to     *//*      the image data is not strictly once through sequential, and     *//*      we will try to create a working database in a temporary         *//*      directory to hold the image as we read through it the second    *//*      time.                                                           *//* -------------------------------------------------------------------- */    if( hGifFile != NULL )    {        GDALDriver *poGTiffDriver = (GDALDriver*) GDALGetDriverByName("GTiff");                if( poGTiffDriver != NULL )        {            /* Create as a sparse file to avoid filling up the whole file */            /* while closing and then destroying this temporary dataset */            const char* apszOptions[] = { "COMPRESS=LZW", "SPARSE_OK=YES", NULL };            CPLString osTempFilename = CPLGenerateTempFilename("biggif");            osTempFilename += ".tif";            poWorkDS = poGTiffDriver->Create( osTempFilename,                                               nRasterXSize, nRasterYSize, 1,                                               GDT_Byte, const_cast<char**>(apszOptions));        }    }/* -------------------------------------------------------------------- *//*      Open                                                            *//* -------------------------------------------------------------------- */    VSIFSeekL( fp, 0, SEEK_SET );    nLastLineRead = -1;#if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5    int nError;    hGifFile = DGifOpen( fp, VSIGIFReadFunc, &nError );#else    hGifFile = DGifOpen( fp, VSIGIFReadFunc );#endif    if( hGifFile == NULL )    {        CPLError( CE_Failure, CPLE_OpenFailed,                   "DGifOpen() failed.  Perhaps the gif file is corrupt?/n" );        return CE_Failure;    }/* -------------------------------------------------------------------- *//*      Find the first image record.                                    *//* -------------------------------------------------------------------- */    GifRecordType RecordType = TERMINATE_RECORD_TYPE;    while( DGifGetRecordType(hGifFile, &RecordType) != GIF_ERROR           && RecordType != TERMINATE_RECORD_TYPE           && RecordType != IMAGE_DESC_RECORD_TYPE )    {        /* Skip extension records found before IMAGE_DESC_RECORD_TYPE */        if (RecordType == EXTENSION_RECORD_TYPE)        {            int nFunction;            GifByteType *pExtData;            if (DGifGetExtension(hGifFile, &nFunction, &pExtData) == GIF_ERROR)                break;            while (pExtData != NULL)            {                if (DGifGetExtensionNext(hGifFile, &pExtData) == GIF_ERROR)                    break;            }        }    }    if( RecordType != IMAGE_DESC_RECORD_TYPE )    {        DGifCloseFile( hGifFile );        hGifFile = NULL;        CPLError( CE_Failure, CPLE_OpenFailed,                   "Failed to find image description record in GIF file." );        return CE_Failure;    }        if (DGifGetImageDesc(hGifFile) == GIF_ERROR)    {        DGifCloseFile( hGifFile );        hGifFile = NULL;        CPLError( CE_Failure, CPLE_OpenFailed,                   "Image description reading failed in GIF file." );        return CE_Failure;    }        return CE_None;//.........这里部分代码省略.........

void DDGifSlurp(GifInfo *info, bool shouldDecode) {    GifRecordType RecordType;    GifByteType *ExtData;    int codeSize;    int ExtFunction;    do {        if (DGifGetRecordType(info->gifFilePtr, &RecordType) == GIF_ERROR)            return;        switch (RecordType) {            case IMAGE_DESC_RECORD_TYPE:                if (DGifGetImageDesc(info->gifFilePtr, !shouldDecode) == GIF_ERROR)                    return;                const uint_fast16_t requiredScreenWidth = info->gifFilePtr->Image.Left + info->gifFilePtr->Image.Width;                const uint_fast16_t requiredScreenHeight = info->gifFilePtr->Image.Top + info->gifFilePtr->Image.Height;                if (requiredScreenWidth > info->gifFilePtr->SWidth || requiredScreenHeight > info->gifFilePtr->SHeight) {                    if (shouldDecode) {                        void *tmpRasterBits = realloc(info->rasterBits,                                                      requiredScreenWidth * requiredScreenHeight * sizeof(GifPixelType));                        if (tmpRasterBits == NULL) {                            info->gifFilePtr->Error = D_GIF_ERR_NOT_ENOUGH_MEM;                            return;                        }                        info->rasterBits = tmpRasterBits;                    }                    else {                        info->gifFilePtr->SWidth = requiredScreenWidth;                        info->gifFilePtr->SHeight = requiredScreenHeight;                    }                }                if (shouldDecode) {                    if (info->gifFilePtr->Image.Interlace) {                        uint_fast16_t i, j;                        /*                         * The way an interlaced image should be read -                         * offsets and jumps...                         */                        uint_fast8_t InterlacedOffset[] = {0, 4, 2, 1};                        uint_fast8_t InterlacedJumps[] = {8, 8, 4, 2};                        /* Need to perform 4 passes on the image */                        for (i = 0; i < 4; i++)                            for (j = InterlacedOffset[i]; j < info->gifFilePtr->Image.Height; j += InterlacedJumps[i]) {                                if (DGifGetLine(info->gifFilePtr, info->rasterBits + j * info->gifFilePtr->Image.Width,                                                info->gifFilePtr->Image.Width) == GIF_ERROR)                                    return;                            }                    }                    else {                        if (DGifGetLine(                                info->gifFilePtr, info->rasterBits,                                info->gifFilePtr->Image.Width * info->gifFilePtr->Image.Height) == GIF_ERROR)                            return;                    }                    return;                }                else {                    if (DGifGetCode(info->gifFilePtr, &codeSize, &ExtData) == GIF_ERROR)                        return;                    while (ExtData != NULL) {                        if (DGifGetCodeNext(info->gifFilePtr, &ExtData) == GIF_ERROR)                            return;                    }                }                break;            case EXTENSION_RECORD_TYPE:                if (DGifGetExtension(info->gifFilePtr, &ExtFunction, &ExtData) == GIF_ERROR)                    return;                if (!shouldDecode) {                    GraphicsControlBlock *tmpInfos = realloc(info->controlBlock,                                                             (info->gifFilePtr->ImageCount + 1) *                                                             sizeof(GraphicsControlBlock));                    if (tmpInfos == NULL) {                        info->gifFilePtr->Error = D_GIF_ERR_NOT_ENOUGH_MEM;                        return;                    }                    info->controlBlock = tmpInfos;                    info->controlBlock[info->gifFilePtr->ImageCount].DelayTime = DEFAULT_FRAME_DURATION_MS;                    if (readExtensions(ExtFunction, ExtData, info) == GIF_ERROR)                        return;                }                while (ExtData != NULL) {                    if (DGifGetExtensionNext(info->gifFilePtr, &ExtData,                                             &ExtFunction) == GIF_ERROR)                        return;                    if (!shouldDecode) {                        if (readExtensions(ExtFunction, ExtData, info) == GIF_ERROR)                            return;                    }                }                break;            case TERMINATE_RECORD_TYPE:                break;            default: /* Should be trapped by DGifGetRecordType */                break;//.........这里部分代码省略.........

bool CxImageGIF::Decode(CxFile *fp){	if (fp == NULL) return false;	GifFileType *GifFile = NULL;	GifRecordType RecordType;	GifByteType *Extension;	GifColorType *ColorMap;	int i, j, Count, Row, Col, Width, Height, ExtCode, ColorMapSize;	static int InterlacedOffset[] = { 0, 4, 2, 1 }, /* The way Interlaced image should. */	    InterlacedJumps[] = { 8, 8, 4, 2 };    /* be read - offsets and jumps... */	try	{		GifFile = DGifOpen(fp, readCxFile);		if (!Create(GifFile->SWidth,GifFile->SHeight,8,CXIMAGE_FORMAT_GIF))			throw "Can't allocate memory";		do		{			DGifGetRecordType(GifFile, &RecordType);			switch (RecordType)			{			case IMAGE_DESC_RECORD_TYPE:				DGifGetImageDesc(GifFile);				Row = GifFile->Image.Top; /* Image Position relative to Screen. */				Col = GifFile->Image.Left;				Width = GifFile->Image.Width;				Height = GifFile->Image.Height;				if (GifFile->Image.Left + GifFile->Image.Width > GifFile->SWidth ||					GifFile->Image.Top + GifFile->Image.Height > GifFile->SHeight)						throw "Image is not confined to screen dimension, aborted./n";				if (GifFile->Image.Interlace)				{					/* Need to perform 4 passes on the images: */					for (Count = i = 0; i < 4; i++)						for (j = Row + InterlacedOffset[i]; j < Row + Height; j += InterlacedJumps[i])								DGifGetLine(GifFile, GetBits(GifFile->SHeight - j - 1) + Col, Width);				}				else {					for (i = 0; i < Height; i++)						DGifGetLine(GifFile,GetBits(GifFile->SHeight - Row++ - 1) + Col,Width);			    }				break;			case EXTENSION_RECORD_TYPE:				/* Skip any extension blocks in file: */				DGifGetExtension(GifFile, &ExtCode, &Extension);				while (Extension != NULL)					DGifGetExtensionNext(GifFile, &Extension);				break;			default:				break;			}		}while (RecordType != TERMINATE_RECORD_TYPE);		ColorMap = (GifFile->Image.ColorMap ? GifFile->Image.ColorMap->Colors : GifFile->SColorMap->Colors);		ColorMapSize = GifFile->Image.ColorMap ? GifFile->Image.ColorMap->ColorCount : GifFile->SColorMap->ColorCount;		if(ColorMap && ColorMapSize)		{			RGBQUAD* ppal=GetPalette();			for (i=0; i < ColorMapSize; i++) {				ppal[i].rgbRed = ColorMap[i].Red;				ppal[i].rgbGreen = ColorMap[i].Green;				ppal[i].rgbBlue = ColorMap[i].Blue;			}			head.biClrUsed = ColorMapSize;			if(GifFile->SBackGroundColor)			{				info.nBkgndIndex = GifFile->SBackGroundColor;				info.nBkgndColor.rgbRed = ColorMap[info.nBkgndIndex].Red;				info.nBkgndColor.rgbGreen = ColorMap[info.nBkgndIndex].Green;				info.nBkgndColor.rgbBlue = ColorMap[info.nBkgndIndex].Blue;			}		}		DGifCloseFile(GifFile);		GifFile = NULL;	} catch (int errid) {		strncpy(info.szLastError,GifGetErrorMessage(errid),255);		if(GifFile != NULL) DGifCloseFile(GifFile);		return false;	} catch (char *message) {		strncpy(info.szLastError,message,255);		if(GifFile != NULL) DGifCloseFile(GifFile);		return false;	}	return true;}

/******************************************************************************* Perform the disassembly operation - take one input files into few output.   *******************************************************************************/static int DoDisassemblyNum(const char *InFileName, char *OutFileName, int FileNum){    int	ExtCode, CodeSize, FileEmpty;    GifRecordType RecordType;    char CrntFileName[80], *p;    GifByteType *Extension, *CodeBlock;    GifFileType *GifFileIn = NULL, *GifFileOut = NULL;	int ErrorCode;    /* If name has type postfix, strip it out, and make sure name is less    */    /* or equal to 6 chars, so we will have 2 chars in name for numbers.     */    //strupr(OutFileName);		      /* Make sure all is upper case */	#if 0	printf("OutFileName : %s/n", OutFileName);	if ((p = strrchr(OutFileName, '.')) != NULL && strlen(p) <= 4) p[0] = 0;    if ((p = strrchr(OutFileName, '/')) != NULL ||	(p = strrchr(OutFileName, '//')) != NULL ||	(p = strrchr(OutFileName, ':')) != NULL) {	if (strlen(p) > 7) p[7] = 0;   /* p includes the '/', '//', ':' char */    }    else {	/* Only name is given for current directory: */	//if (strlen(OutFileName) > 6) OutFileName[6] = 0;    }	printf("OutFileName : %s/n", OutFileName);	#endif    /* Open input file: */    if (InFileName != NULL) {	if ((GifFileIn = DGifOpenFileName(InFileName, &ErrorCode)) == NULL)	    return QuitGifError(GifFileIn, GifFileOut);    }    else {	/* Use the stdin instead: */	if ((GifFileIn = DGifOpenFileHandle(0, &ErrorCode)) == NULL)	    return QuitGifError(GifFileIn, GifFileOut);    }    /* Scan the content of GIF file and dump image(s) to seperate file(s): */	//sprintf(CrntFileName, "%s_%02d.gif", OutFileName, FileNum);	sprintf(CrntFileName, "%s", OutFileName);	if ((GifFileOut = EGifOpenFileName(CrntFileName, TRUE, &ErrorCode)) == NULL)	    return QuitGifError(GifFileIn, GifFileOut);	FileEmpty = TRUE;	/* And dump out its exactly same screen information: */	if (EGifPutScreenDesc(GifFileOut,	    GifFileIn->SWidth, GifFileIn->SHeight,	    GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,	    GifFileIn->SColorMap) == GIF_ERROR)	    return QuitGifError(GifFileIn, GifFileOut);	do {	    if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)			return QuitGifError(GifFileIn, GifFileOut);	    switch (RecordType) {		case IMAGE_DESC_RECORD_TYPE:		    FileEmpty = FALSE;		    if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    /* Put same image descriptor to out file: */		    if (EGifPutImageDesc(GifFileOut,			GifFileIn->Image.Left, GifFileIn->Image.Top,			GifFileIn->Image.Width, GifFileIn->Image.Height,			GifFileIn->Image.Interlace,			GifFileIn->Image.ColorMap) == GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    /* Now read image itself in decoded form as we dont      */		    /* really care what is there, and this is much faster.   */		    if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR		     || EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    while (CodeBlock != NULL)			if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR ||			    EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    break;		case EXTENSION_RECORD_TYPE:		    FileEmpty = FALSE;		    /* Skip any extension blocks in file: */		    if (DGifGetExtension(GifFileIn, &ExtCode, &Extension)			== GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],							Extension) == GIF_ERROR)				return QuitGifError(GifFileIn, GifFileOut);		    /* No support to more than one extension blocks, discard */		    while (Extension != NULL)			if (DGifGetExtensionNext(GifFileIn, &Extension)			    == GIF_ERROR)			    return QuitGifError(GifFileIn, GifFileOut);		    break;		case TERMINATE_RECORD_TYPE:		    break;//.........这里部分代码省略.........

int main(int argc, char **argv) {   //   // local vars   //   GifFileType *GIFfile;   GifRecordType GIFtype;   GifByteType *GIFextension;   GifPixelType *GIFline;   uint32_t **lower_array,**upper_array;   double **image_array;   double f,fmin,fmax;   int x,y,z,h,i,j,k,n,p;   int image_width,image_height,image_count,color_resolution,GIFcode,ret;   float pixel_size,arg,rx,ry,rz;   char type,comment[256];   struct fab_vars v;   init_vars(&v);   //   // command line args   //   if (!((argc == 3) || (argc == 4) || (argc == 5) || (argc == 6) || (argc == 7) || (argc == 10))) {      printf("command line: gif_png in.gif out.png [type [arg [points [size [rx ry rz]]]]]/n");      printf("   in.gif = input gif file/n");      printf("   out.png = output PNG file/n");      printf("   type = 'z' of density, 'h' for height (default z)/n");      printf("   arg = gamma for 'z', threshold for 'h' (default 1)/n");      printf("   points = points to interpolate per point (linear, default 0)/n");      printf("   size = voxel size (mm, default from file))/n");      printf("   to be implemented: rx,ry,rz = x,y,z rotation angles (degrees; default 0)/n");      exit(-1);      }   type = 'z';   p = 0;   arg = 1;   rx = ry = rz = 0;   pixel_size = -1;   image_width = -1;   image_height = -1;   if (argc >= 4) {      sscanf(argv[3],"%c",&type);      if (!((type == 'z') || (type == 'h'))) {         printf("gif_png: oops -- type must be 'z' or 'h'/n");         exit(-1);         }   if (argc >= 5)      sscanf(argv[4],"%f",&arg);      }   if (argc >= 6)      sscanf(argv[5],"%d",&p);   if (argc >= 7)      sscanf(argv[6],"%f",&pixel_size);   if (argc >= 10) {      sscanf(argv[7],"%f",&rx);      sscanf(argv[8],"%f",&ry);      sscanf(argv[9],"%f",&rz);      }   //   // scan the file    //   printf("read %s/n",argv[1]);   color_resolution = -1;   GIFfile = DGifOpenFileName(argv[1]);   if (GIFfile == NULL) {      printf("gif_png: oops -- can not open %s/n",argv[1]);      exit(-1);      }   GIFline = malloc(MAX_LINE*sizeof(GifPixelType));   do {      DGifGetRecordType(GIFfile,&GIFtype);      switch (GIFtype) {         case IMAGE_DESC_RECORD_TYPE:            DGifGetImageDesc(GIFfile);            image_width = GIFfile->SWidth;            image_height = GIFfile->SHeight;            image_count = GIFfile->ImageCount;            color_resolution = GIFfile->SColorResolution;            for (y = 0; y < GIFfile->SHeight; ++y) {               ret = DGifGetLine(GIFfile,GIFline,GIFfile->SWidth);               if (ret != GIF_OK) {                  printf("gif_png: oops -- error reading line/n");                  exit(-1);                  }               }            break;         case EXTENSION_RECORD_TYPE:            DGifGetExtension(GIFfile,&GIFcode,&GIFextension);            if (GIFcode == COMMENT_EXT_FUNC_CODE) {               n = GIFextension[0];               for (i = 1; i <= n; ++i)                  comment[i-1] = GIFextension[i];               comment[n] = 0;               if (pixel_size == -1)                  sscanf(comment,"mm per pixel: %f;",&pixel_size);               }            while (GIFextension != NULL)               DGifGetExtensionNext(GIFfile,&GIFextension);            break;         case SCREEN_DESC_RECORD_TYPE:            DGifGetScreenDesc(GIFfile);            break;//.........这里部分代码省略.........

SkCodec::Result SkGifCodec::ReadUpToFirstImage(GifFileType* gif, uint32_t* transIndex) {    // Use this as a container to hold information about any gif extension    // blocks.  This generally stores transparency and animation instructions.    SavedImage saveExt;    SkAutoTCallVProc<SavedImage, FreeExtension> autoFreeExt(&saveExt);    saveExt.ExtensionBlocks = nullptr;    saveExt.ExtensionBlockCount = 0;    GifByteType* extData;    int32_t extFunction;    // We will loop over components of gif images until we find an image.  Once    // we find an image, we will decode and return it.  While many gif files    // contain more than one image, we will simply decode the first image.    GifRecordType recordType;    do {        // Get the current record type        if (GIF_ERROR == DGifGetRecordType(gif, &recordType)) {            return gif_error("DGifGetRecordType failed./n", kInvalidInput);        }        switch (recordType) {            case IMAGE_DESC_RECORD_TYPE: {                *transIndex = find_trans_index(saveExt);                // FIXME: Gif files may have multiple images stored in a single                //        file.  This is most commonly used to enable                //        animations.  Since we are leaving animated gifs as a                //        TODO, we will return kSuccess after decoding the                //        first image in the file.  This is the same behavior                //        as SkImageDecoder_libgif.                //                //        Most times this works pretty well, but sometimes it                //        doesn't.  For example, I have an animated test image                //        where the first image in the file is 1x1, but the                //        subsequent images are meaningful.  This currently                //        displays the 1x1 image, which is not ideal.  Right                //        now I am leaving this as an issue that will be                //        addressed when we implement animated gifs.                //                //        It is also possible (not explicitly disallowed in the                //        specification) that gif files provide multiple                //        images in a single file that are all meant to be                //        displayed in the same frame together.  I will                //        currently leave this unimplemented until I find a                //        test case that expects this behavior.                return kSuccess;            }            // Extensions are used to specify special properties of the image            // such as transparency or animation.            case EXTENSION_RECORD_TYPE:                // Read extension data                if (GIF_ERROR == DGifGetExtension(gif, &extFunction, &extData)) {                    return gif_error("Could not get extension./n", kIncompleteInput);                }                // Create an extension block with our data                while (nullptr != extData) {                    // Add a single block#if GIFLIB_MAJOR < 5                    if (AddExtensionBlock(&saveExt, extData[0],                                          &extData[1]) == GIF_ERROR) {#else                    if (GIF_ERROR == GifAddExtensionBlock(&saveExt.ExtensionBlockCount,                                                          &saveExt.ExtensionBlocks,                                                          extFunction, extData[0], &extData[1])) {#endif                        return gif_error("Could not add extension block./n", kIncompleteInput);                    }                    // Move to the next block                    if (GIF_ERROR == DGifGetExtensionNext(gif, &extData)) {                        return gif_error("Could not get next extension./n", kIncompleteInput);                    }                }                break;            // Signals the end of the gif file            case TERMINATE_RECORD_TYPE:                break;            default:                // DGifGetRecordType returns an error if the record type does                // not match one of the above cases.  This should not be                // reached.                SkASSERT(false);                break;        }    } while (TERMINATE_RECORD_TYPE != recordType);    return gif_error("Could not find any images to decode in gif file./n", kInvalidInput);}bool SkGifCodec::GetDimensions(GifFileType* gif, SkISize* size, SkIRect* frameRect) {    // Get the encoded dimension values    SavedImage* image = &gif->SavedImages[gif->ImageCount - 1];    const GifImageDesc& desc = image->ImageDesc;    int frameLeft = desc.Left;    int frameTop = desc.Top;    int frameWidth = desc.Width;    int frameHeight = desc.Height;    int width = gif->SWidth;//.........这里部分代码省略.........

int main(int argc, char **argv) {   //   // local vars   //   GifFileType *GIFfile;   GifRecordType GIFtype;   GifByteType *GIFextension;   GifPixelType *GIFline;   uint32_t w[8],**lower_array,**upper_array;   int x,y,z,i,j,k,n,p,imin,imax;   int image_width,image_height,image_count,color_resolution,GIFcode,ret;   float threshold,voxel_size;   char comment[256],rules[255][20];   struct fab_vars v;   init_vars(&v);   //   // command line args   //   if (!((argc == 3) || (argc == 4) || (argc == 5) || (argc == 6))) {      printf("command line: gif_stl in.gif out.stl [threshold [size [points [angle]]]]/n");      printf("   in.gif = input GIF section file/n");      printf("   out.stl = output STL file/n");      printf("   threshold: surface intensity threshold (0 = min, 1 = max, default 0.5))/n");      printf("   size = voxel size (mm, default from file))/n");      printf("   points = points to interpolate per point (default 0)/n");      printf("   to be implemented: angle = minimum relative face angle to decimate vertices (default 0)/n");      exit(-1);      }   p = 0;   threshold = 0.5;   voxel_size = -1;   image_width = -1;   image_height = -1;   image_count = -1;   if (argc >= 4)      sscanf(argv[3],"%f",&threshold);   if (argc >= 5)      sscanf(argv[4],"%f",&voxel_size);   if (argc >= 6)      sscanf(argv[5],"%d",&p);   //   // initialize the rule table   //   init_rules(rules);   //   // scan the file    //   printf("read %s/n",argv[1]);   color_resolution = -1;#if GIFLIB_MAJOR >= 5   GIFfile = DGifOpenFileName(argv[1], NULL);#else   GIFfile = DGifOpenFileName(argv[1]);#endif   if (GIFfile == NULL) {      printf("gif_stl: oops -- can not open %s/n",argv[1]);      exit(-1);      }   GIFline = malloc(MAX_LINE*sizeof(GifPixelType));   imin = 256;   imax = 0;   do {      DGifGetRecordType(GIFfile,&GIFtype);      switch (GIFtype) {         case IMAGE_DESC_RECORD_TYPE:            DGifGetImageDesc(GIFfile);            image_width = GIFfile->SWidth;            image_height = GIFfile->SHeight;            image_count = GIFfile->ImageCount;            color_resolution = GIFfile->SColorResolution;            for (y = 0; y < GIFfile->SHeight; ++y) {               ret = DGifGetLine(GIFfile,GIFline,GIFfile->SWidth);               if (ret != GIF_OK) {                  printf("gif_stl: oops -- error reading line/n");                  exit(-1);                  }               for (x = 0; x < GIFfile->SWidth; ++x) {                  if (GIFline[x] < imin) imin = GIFline[x];                  if (GIFline[x] > imax) imax = GIFline[x];                  }               }            break;         case EXTENSION_RECORD_TYPE:            DGifGetExtension(GIFfile,&GIFcode,&GIFextension);            if (GIFcode == COMMENT_EXT_FUNC_CODE) {               n = GIFextension[0];               for (i = 1; i <= n; ++i)                  comment[i-1] = GIFextension[i];               comment[n] = 0;               if (voxel_size == -1)                  sscanf(comment,"mm per pixel: %f;",&voxel_size);               }            while (GIFextension != NULL)               DGifGetExtensionNext(GIFfile,&GIFextension);            break;         case SCREEN_DESC_RECORD_TYPE:            DGifGetScreenDesc(GIFfile);            break;         case TERMINATE_RECORD_TYPE:            break;//.........这里部分代码省略.........

//.........这里部分代码省略.........		    PROGRAM_NAME, ++ImageNum, Col, Row, Width, Height);		if (GifFile -> ILeft + GifFile -> IWidth > GifFile -> SWidth ||		   GifFile -> ITop + GifFile -> IHeight > GifFile -> SHeight) {		    fprintf(stderr, "Image %d is not confined to screen dimension, aborted./n");		    exit(-2);		}		if (GifFile -> IInterlace) {		    /* Need to perform 4 passes on the images: */		    for (Count = i = 0; i < 4; i++)			for (j = Row + InterlacedOffset[i]; j < Row + Height;						 j += InterlacedJumps[i]) {			    GifQprintf("/b/b/b/b%-4d", Count++);			    if (DGifGetLine(GifFile,				&ScreenBuffer[MIN(j, MaximumScreenHeight)][Col],				Width) == GIF_ERROR) {				PrintGifError();				exit(-1);			    }			}		}		else {		    for (i = 0; i < Height; i++, Row++) {			GifQprintf("/b/b/b/b%-4d", i);			if (DGifGetLine(GifFile, &ScreenBuffer[MIN(Row, MaximumScreenHeight)][Col],				Width) == GIF_ERROR) {			    PrintGifError();			    MaximumScreenHeight = MIN(i - 1, MaximumScreenHeight);			}		    }		}		break;	    case EXTENSION_RECORD_TYPE:		/* Skip any extension blocks in file: */		if (DGifGetExtension(GifFile, &ExtCode, &Extension) == GIF_ERROR) {		    PrintGifError();		    exit(-1);		}		while (Extension != NULL) {		    if (DGifGetExtensionNext(GifFile, &Extension) == GIF_ERROR) {			PrintGifError();			exit(-1);		    }		}		break;	    case TERMINATE_RECORD_TYPE:		break;	    default:		    /* Should be traps by DGifGetRecordType. */		break;	}    }    while (RecordType != TERMINATE_RECORD_TYPE);    /* Lets display it - set the global variables required and do it: */    BackGround = GifFile -> SBackGroundColor;    ColorMap = (GifFile -> IColorMap ? GifFile -> IColorMap :				       GifFile -> SColorMap);    ColorMapSize = 1 << (GifFile -> IColorMap ? GifFile -> IBitsPerPixel :						GifFile -> SBitsPerPixel);    gettextinfo(&TextInfo);	     /* Save current mode so we can recover. */    initgraph(&GraphDriver, &GraphMode, BGIPath);    if (graphresult() != grOk)	 	       /* Error occured during init. */	GIF_EXIT("Graphics System Error, failed to initialize driver.");    if (getmaxcolor() + 1 < ColorMapSize) {

intget_gif_saved_images( GifFileType *gif, int subimage, SavedImage **ret, int *ret_images  ){    GifRecordType RecordType;    GifByteType *ExtData;    SavedImage temp_save;	int curr_image = 0, ret_count = *ret_images ;	int status = GIF_OK;	memset( &temp_save, 0x00, sizeof( temp_save ) );	do	{		if ( (status = DGifGetRecordType(gif, &RecordType)) == GIF_ERROR)		{			break;		}		switch (RecordType)		{	    	case IMAGE_DESC_RECORD_TYPE:				if ((status = get_gif_image_desc(gif, &temp_save)) == GIF_OK)				{					int size = temp_save.ImageDesc.Width*temp_save.ImageDesc.Height ;					temp_save.RasterBits = realloc( temp_save.RasterBits, size );					status = DGifGetLine(gif, (unsigned char*)temp_save.RasterBits, size);					if (status == GIF_OK)					{						if( curr_image == subimage || subimage < 0 )						{							append_gif_saved_image( &temp_save, ret, &(ret_count));						}					}					++curr_image ;				}				break;	    	case EXTENSION_RECORD_TYPE:				status = DGifGetExtension(gif,&temp_save.Function,&ExtData);				while (ExtData != NULL && status == GIF_OK )				{            		/* Create an extension block with our data */            		if ((status = AddExtensionBlock(&temp_save, ExtData[0], (char*)&(ExtData[1]))) == GIF_OK)				    	status = DGifGetExtensionNext(gif, &ExtData);            		temp_save.Function = 0;				}				break;	    	case TERMINATE_RECORD_TYPE:				break;	    	default:	/* Should be trapped by DGifGetRecordType */				break;		}    }while( status == GIF_OK && RecordType != TERMINATE_RECORD_TYPE);/*	if( status == GIF_OK && *ret == NULL )		append_gif_saved_image( &temp_save, ret, &(ret_count));	else*/	free_gif_saved_image( &temp_save, True );	*ret_images = ret_count ;    return status;}

//.........这里部分代码省略.........	QuitGifError(GifFileIn, GifFileOut);    /* Scan the content of the GIF file and load the image(s) in: */    do {	if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)	    QuitGifError(GifFileIn, GifFileOut);	switch (RecordType) {	    case IMAGE_DESC_RECORD_TYPE:		if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* Put the image descriptor to out file: */		l = (int) (GifFileIn->Image.Left * XScale + 0.5);		w = (int) (GifFileIn->Image.Width * XScale + 0.5);		t = (int) (GifFileIn->Image.Top * YScale + 0.5);		h = (int) (GifFileIn->Image.Height * YScale + 0.5);		if (l < 0) l = 0;		if (t < 0) t = 0;		if (l + w > XSize) w = XSize - l;		if (t + h > YSize) h = YSize - t;		if (EGifPutImageDesc(GifFileOut, l, t, w, h,		    GifFileIn->Image.Interlace,		    GifFileIn->Image.ColorMap) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (GifFileIn->Image.Interlace) {		    GIF_EXIT("Cannt resize interlaced images - use GifInter first.");		}		else {		    GifQprintf("/n%s: Image %d at (%d, %d) [%dx%d]:     ",			PROGRAM_NAME, ++ImageNum,			GifFileOut->Image.Left, GifFileOut->Image.Top,			GifFileOut->Image.Width, GifFileOut->Image.Height);		    for (i = GifFileIn->Image.Height, y = 0.0, last_iy = -1;			 i-- > 0;			 y += YScale) {			if (DGifGetLine(GifFileIn, LineIn,					GifFileIn->Image.Width) == GIF_ERROR)			    QuitGifError(GifFileIn, GifFileOut);			iy = (int) y;			if (last_iy < iy && last_iy < YSize) {			    ResizeLine(LineIn, LineOut,				       GifFileIn->Image.Width, GifFileOut->Image.Width);			    for (;				 last_iy < iy && last_iy < GifFileOut->Image.Height - 1;				 last_iy++) {				GifQprintf("/b/b/b/b%-4d", last_iy + 1);				if (EGifPutLine(GifFileOut, LineOut,						GifFileOut->Image.Width) ==								    GIF_ERROR)				    QuitGifError(GifFileIn, GifFileOut);			    }			}		    }		    /* If scale is not dividable - dump last lines: */		    while (++last_iy < GifFileOut->Image.Height) {			GifQprintf("/b/b/b/b%-4d", last_iy);			if (EGifPutLine(GifFileOut, LineOut,					GifFileOut->Image.Width) == GIF_ERROR)			    QuitGifError(GifFileIn, GifFileOut);		    }		}		break;	    case EXTENSION_RECORD_TYPE:		/* Skip any extension blocks in file: */		if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],							Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* No support to more than one extension blocks, so discard: */		while (Extension != NULL) {		    if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		}		break;	    case TERMINATE_RECORD_TYPE:		break;	    default:		    /* Should be traps by DGifGetRecordType. */		break;	}    }    while (RecordType != TERMINATE_RECORD_TYPE);    if (DGifCloseFile(GifFileIn) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);    if (EGifCloseFile(GifFileOut) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);    free(LineOut);    free(LineIn);    return 0;}

/****************************************************************************** This routine reads an entire GIF into core, hanging all its state info off the GifFileType pointer.  Call DGifOpenFileName() or DGifOpenFileHandle() first to initialize I/O.  Its inverse is EGifSpew().*******************************************************************************/intDGifSlurp(GifFileType *GifFile){    size_t ImageSize;    GifRecordType RecordType;    SavedImage *sp;    GifByteType *ExtData;    int ExtFunction;    GifFile->ExtensionBlocks = NULL;    GifFile->ExtensionBlockCount = 0;    do {        if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR)            return (GIF_ERROR);        switch (RecordType) {          case IMAGE_DESC_RECORD_TYPE:              if (DGifGetImageDesc(GifFile) == GIF_ERROR)                  return (GIF_ERROR);              sp = &GifFile->SavedImages[GifFile->ImageCount - 1];              /* Allocate memory for the image */              if (sp->ImageDesc.Width < 0 && sp->ImageDesc.Height < 0 &&                      sp->ImageDesc.Width > (INT_MAX / sp->ImageDesc.Height)) {                  return GIF_ERROR;              }              ImageSize = sp->ImageDesc.Width * sp->ImageDesc.Height;              if (ImageSize > (SIZE_MAX / sizeof(GifPixelType))) {                  return GIF_ERROR;              }              sp->RasterBits = (unsigned char *)malloc(ImageSize *                      sizeof(GifPixelType));              if (sp->RasterBits == NULL) {                  return GIF_ERROR;              }	      if (sp->ImageDesc.Interlace) {		  int i, j;		   /* 		    * The way an interlaced image should be read - 		    * offsets and jumps...		    */		  int InterlacedOffset[] = { 0, 4, 2, 1 };		  int InterlacedJumps[] = { 8, 8, 4, 2 };		  /* Need to perform 4 passes on the image */		  for (i = 0; i < 4; i++)		      for (j = InterlacedOffset[i]; 			   j < sp->ImageDesc.Height;			   j += InterlacedJumps[i]) {			  if (DGifGetLine(GifFile, 					  sp->RasterBits+j*sp->ImageDesc.Width, 					  sp->ImageDesc.Width) == GIF_ERROR)			      return GIF_ERROR;		      }	      }	      else {		  if (DGifGetLine(GifFile,sp->RasterBits,ImageSize)==GIF_ERROR)		      return (GIF_ERROR);	      }              if (GifFile->ExtensionBlocks) {                  sp->ExtensionBlocks = GifFile->ExtensionBlocks;                  sp->ExtensionBlockCount = GifFile->ExtensionBlockCount;                  GifFile->ExtensionBlocks = NULL;                  GifFile->ExtensionBlockCount = 0;              }              break;          case EXTENSION_RECORD_TYPE:              if (DGifGetExtension(GifFile,&ExtFunction,&ExtData) == GIF_ERROR)                  return (GIF_ERROR);	      /* Create an extension block with our data */	      if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,				       &GifFile->ExtensionBlocks, 				       ExtFunction, ExtData[0], &ExtData[1])		  == GIF_ERROR)		  return (GIF_ERROR);              while (ExtData != NULL) {                  if (DGifGetExtensionNext(GifFile, &ExtData) == GIF_ERROR)                      return (GIF_ERROR);                  /* Continue the extension block */		  if (ExtData != NULL)		      if (GifAddExtensionBlock(&GifFile->ExtensionBlockCount,					       &GifFile->ExtensionBlocks,					       CONTINUE_EXT_FUNC_CODE, 					       ExtData[0], &ExtData[1]) == GIF_ERROR)                      return (GIF_ERROR);              }              break;          case TERMINATE_RECORD_TYPE://.........这里部分代码省略.........

//.........这里部分代码省略.........				}			}			buffer = malloc(width * sizeof(GifColorType));			if (!buffer) {				RErrorCode = RERR_NOMEMORY;				goto bye;			}			image = RCreateImage(width, height, False);			if (!image) {				goto bye;			}			if (gif->Image.Interlace) {				int l;				int pelsPerLine;				if (RRGBAFormat == image->format)					pelsPerLine = width * 4;				else					pelsPerLine = width * 3;				for (j = 0; j < 4; j++) {					for (k = InterlacedOffset[j]; k < height; k += InterlacedJumps[j]) {						if (DGifGetLine(gif, buffer, width) == GIF_ERROR) {							goto giferr;						}						cptr = image->data + (k * pelsPerLine);						for (l = 0; l < width; l++) {							int pixel = buffer[l];							*cptr++ = rmap[pixel];							*cptr++ = gmap[pixel];							*cptr++ = bmap[pixel];						}					}				}			} else {				cptr = image->data;				for (j = 0; j < height; j++) {					if (DGifGetLine(gif, buffer, width) == GIF_ERROR) {						goto giferr;					}					for (k = 0; k < width; k++) {						int pixel = buffer[k];						*cptr++ = rmap[pixel];						*cptr++ = gmap[pixel];						*cptr++ = bmap[pixel];						if (RRGBAFormat == image->format)							cptr++;					}				}			}			break;		case EXTENSION_RECORD_TYPE:			/* skip all extension blocks */			if (DGifGetExtension(gif, &extCode, &extension) == GIF_ERROR) {				goto giferr;			}			while (extension) {				if (DGifGetExtensionNext(gif, &extension) == GIF_ERROR) {					goto giferr;				}			}			break;		default:			break;		}	} while (recType != TERMINATE_RECORD_TYPE && i <= index);	/* yuck! */	goto did_not_get_any_errors; giferr:	switch (GifLastError()) {	case D_GIF_ERR_OPEN_FAILED:		RErrorCode = RERR_OPEN;		break;	case D_GIF_ERR_READ_FAILED:		RErrorCode = RERR_READ;		break;	default:		RErrorCode = RERR_BADIMAGEFILE;		break;	} bye:	if (image)		RReleaseImage(image);	image = NULL; did_not_get_any_errors:	if (buffer)		free(buffer);	if (gif)		DGifCloseFile(gif);	return image;}

//.........这里部分代码省略.........                  ColorMapEntry->Green,                  ColorMapEntry->Blue,                  trans_index == line[y] ? 0 : 255                );              }            }          }        }        else {          ofs = 0;          for (x = 0; x < im->height; x++) {            if (DGifGetLine(im->gif, line, 0) != GIF_OK) {              warn("Image::Scale unable to read GIF file (%s)/n", SvPVX(im->path));              image_gif_finish(im);              return 0;            }            for (y = 0; y < im->width; y++) {              ColorMapEntry = &ColorMap->Colors[line[y]];              im->pixbuf[ofs++] = COL_FULL(                ColorMapEntry->Red,                ColorMapEntry->Green,                ColorMapEntry->Blue,                trans_index == line[y] ? 0 : 255              );            }          }        }        Safefree(line);        break;      case EXTENSION_RECORD_TYPE:        if (DGifGetExtension(im->gif, &ExtFunction, &ExtData) == GIF_ERROR) {          warn("Image::Scale unable to read GIF file (%s)/n", SvPVX(im->path));          image_gif_finish(im);          return 0;        }        if (ExtFunction == 0xF9) { // transparency info          if (ExtData[1] & 1)            trans_index = ExtData[4];          else            trans_index = -1;          im->has_alpha = 1;          DEBUG_TRACE("GIF transparency index: %d/n", trans_index);        }        while (ExtData != NULL) {          /* Create an extension block with our data */#ifdef GIFLIB_API_50          if (GifAddExtensionBlock(&im->gif->ExtensionBlockCount, &im->gif->ExtensionBlocks, ExtFunction, ExtData[0], &ExtData[1]) == GIF_ERROR) {#else          temp_save.Function = ExtFunction;          if (AddExtensionBlock(&temp_save, ExtData[0], &ExtData[1]) == GIF_ERROR) {#endif#ifdef GIFLIB_API_41            PrintGifError();#endif            warn("Image::Scale unable to read GIF file (%s)/n", SvPVX(im->path));            image_gif_finish(im);            return 0;          }          if (DGifGetExtensionNext(im->gif, &ExtData) == GIF_ERROR) {#ifdef GIFLIB_API_41

//.........这里部分代码省略.........	    QuitGifError(GifFileIn, GifFileOut);	switch (RecordType) {	    case IMAGE_DESC_RECORD_TYPE:		if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if ((++ImageNum == ImageN) && ImageNFlag) {		    /* We are suppose to modify this image color map, do it: */		    GifFileIn->SColorMap =ModifyColorMap(GifFileIn->SColorMap);		    if (!HasGIFOutput) {			/* We can quit here, as we have the color map: */			if (GifFileIn != NULL) DGifCloseFile(GifFileIn);			fclose(ColorFile);			exit(EXIT_SUCCESS);		    }		}		if (HasGIFOutput)		    if (EGifPutImageDesc(GifFileOut,			GifFileIn->Image.Left, GifFileIn->Image.Top,			GifFileIn->Image.Width, GifFileIn->Image.Height,			GifFileIn->Image.Interlace,			GifFileIn->Image.ColorMap) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		if (!TranslateFlag || (ImageNFlag && (ImageN != ImageNum)))		{		    /* Now read image itself in decoded form as we don't */		    /* really care what we have there, and this is much  */		    /* faster.						 */		    if (DGifGetCode(GifFileIn, &CodeSize, &CodeBlock) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		    if (HasGIFOutput)			if (EGifPutCode(GifFileOut, CodeSize, CodeBlock) == GIF_ERROR)			    QuitGifError(GifFileIn, GifFileOut);		    while (CodeBlock != NULL) {			if (DGifGetCodeNext(GifFileIn, &CodeBlock) == GIF_ERROR)			    QuitGifError(GifFileIn, GifFileOut);			if (HasGIFOutput)			    if (EGifPutCodeNext(GifFileOut, CodeBlock) == GIF_ERROR)				QuitGifError(GifFileIn, GifFileOut);		    }		}		else	/* we need to mung pixels intices */		{		    int	i;		    register GifPixelType *cp;		    GifPixelType *Line			= (GifPixelType *) malloc(GifFileIn->Image.Width *						  sizeof(GifPixelType));		    for (i = 0; i < GifFileIn->Image.Height; i++) {			if (DGifGetLine(GifFileIn, Line,GifFileIn->Image.Width)			    == GIF_ERROR) {			    QuitGifError(GifFileIn, GifFileOut);			}			/* translation step goes here */			for (cp = Line; cp < Line+GifFileIn->Image.Width; cp++)			    *cp = Translation[*cp];			if (EGifPutLine(GifFileOut,					Line, GifFileIn->Image.Width)			    == GIF_ERROR) {			    QuitGifError(GifFileIn, GifFileOut);			}		    }		    free((char *) Line);		}		break;	    case EXTENSION_RECORD_TYPE:		/* Skip any extension blocks in file: */		if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (HasGIFOutput)		    if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],							Extension) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		/* No support to more than one extension blocks, so discard: */		while (Extension != NULL) {		    if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		}		break;	    case TERMINATE_RECORD_TYPE:		break;	    default:		    /* Should be traps by DGifGetRecordType. */		break;	}    }    while (RecordType != TERMINATE_RECORD_TYPE);    if (DGifCloseFile(GifFileIn) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);    if (HasGIFOutput)	if (EGifCloseFile(GifFileOut) == GIF_ERROR)	    QuitGifError(GifFileIn, GifFileOut);    return 0;}

/******************************************************************************* Interpret the command line and scan the given GIF file.		      *******************************************************************************/void main(int argc, char **argv){    int	Error, NumFiles, ExtCode;    GifRecordType RecordType;    GifByteType *Extension;    char **FileName = NULL;    GifRowType *ImageBuffer;    GifFileType *GifFileIn = NULL, *GifFileOut = NULL;    if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuitePrint,		&InterlacedFlag, &SequencialFlag, &HelpFlag,		&NumFiles, &FileName)) != FALSE ||		(NumFiles > 1 && !HelpFlag)) {	if (Error)	    GAPrintErrMsg(Error);	else if (NumFiles > 1)	    GIF_MESSAGE("Error in command line parsing - one GIF file please.");	GAPrintHowTo(CtrlStr);	exit(1);    }    if (HelpFlag) {	fprintf(stderr, VersionStr);	GAPrintHowTo(CtrlStr);	exit(0);    }    if (NumFiles == 1) {	if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)	    QuitGifError(GifFileIn, GifFileOut);    }    else {	/* Use the stdin instead: */	if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)	    QuitGifError(GifFileIn, GifFileOut);    }    /* Open stdout for the output file: */    if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)	QuitGifError(GifFileIn, GifFileOut);    /* And dump out exactly same screen information: */    if (EGifPutScreenDesc(GifFileOut,	GifFileIn -> SWidth, GifFileIn -> SHeight,	GifFileIn -> SColorResolution, GifFileIn -> SBackGroundColor,	GifFileIn -> SBitsPerPixel, GifFileIn -> SColorMap) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);    /* Scan the content of the GIF file and load the image(s) in: */    do {	if (DGifGetRecordType(GifFileIn, &RecordType) == GIF_ERROR)	    QuitGifError(GifFileIn, GifFileOut);	switch (RecordType) {	    case IMAGE_DESC_RECORD_TYPE:		if (DGifGetImageDesc(GifFileIn) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* Put the image descriptor to out file: */		if (EGifPutImageDesc(GifFileOut,		    GifFileIn -> ILeft, GifFileIn -> ITop,		    GifFileIn -> IWidth, GifFileIn -> IHeight,		    InterlacedFlag, GifFileIn -> IBitsPerPixel,		    GifFileIn -> IColorMap) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* Load the image (either Interlaced or not), and dump it as */		/* defined in GifFileOut -> IInterlaced.		     */		if (LoadImage(GifFileIn, &ImageBuffer) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (DumpImage(GifFileOut, ImageBuffer) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		break;	    case EXTENSION_RECORD_TYPE:		/* Skip any extension blocks in file: */		if (DGifGetExtension(GifFileIn, &ExtCode, &Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		if (EGifPutExtension(GifFileOut, ExtCode, Extension[0],							Extension) == GIF_ERROR)		    QuitGifError(GifFileIn, GifFileOut);		/* No support to more than one extension blocks, so discard: */		while (Extension != NULL) {		    if (DGifGetExtensionNext(GifFileIn, &Extension) == GIF_ERROR)			QuitGifError(GifFileIn, GifFileOut);		}		break;	    case TERMINATE_RECORD_TYPE:		break;	    default:		    /* Should be traps by DGifGetRecordType. */		break;	}    }    while (RecordType != TERMINATE_RECORD_TYPE);    if (DGifCloseFile(GifFileIn) == GIF_ERROR)	QuitGifError(GifFileIn, GifFileOut);//.........这里部分代码省略.........

static GifRowType *DGifDecompress(GifFileType *gifFile, short *transparentColor){	static int InterlacedOffset[] =	{ 0, 4, 2, 1 }, InterlacedJumps[] =	{ 8, 8, 4, 2 };	int i, j, row, col, width, height = 0;	GifRowType *ScreenBuffer = NULL;	int rowSize = gifFile->SWidth * sizeof(GifPixelType);	ScreenBuffer = (GifRowType *) gif_malloc(gifFile->SHeight * sizeof(GifRowType *));	if (ScreenBuffer == NULL)	{		return NULL;	}	int Size = gifFile->SWidth * sizeof(GifPixelType);	ScreenBuffer[0] = (GifRowType) gif_malloc(Size);	if (ScreenBuffer[0] == NULL)	{		goto cleanup;	}	for (i = 0; i < gifFile->SWidth; i++)	{		ScreenBuffer[0][i] = gifFile->SBackGroundColor;	}	for (i = 1; i < gifFile->SHeight; i++)	{		ScreenBuffer[i] = (GifRowType) gif_malloc(Size);		if (ScreenBuffer[i] == NULL)		{			goto cleanup;		}		memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);	}	*transparentColor = GIF_NOT_TRANSPARENT;	GifRecordType recordType;	do	{		if (DGifGetRecordType(gifFile, &recordType) == GIF_ERROR)		{			goto cleanup;		}		switch (recordType)		{			case IMAGE_DESC_RECORD_TYPE:			{				if (DGifGetImageDesc(gifFile) == GIF_ERROR)				{					goto cleanup;				}				row = gifFile->Image.Top;				col = gifFile->Image.Left;				width = gifFile->Image.Width;				height = gifFile->Image.Height;				GifPixelType *gifPixelType;				int location = 0;				if (gifFile->Image.Interlace)				{					for (i = 0; i < 4; i++)					{						for (j = row + InterlacedOffset[i]; j < row + height; j += InterlacedJumps[i])						{							gifPixelType = &ScreenBuffer[j][col];							if (DGifGetLine(gifFile, gifPixelType, width) == GIF_ERROR)							{								goto cleanup;							}							location += rowSize;						}					}				}				else				{					for (i = 0; i < height; i++)					{						if (DGifGetLine(gifFile, &ScreenBuffer[row++][col], width) == GIF_ERROR)						{							goto cleanup;						}					}				}				break;			}			case EXTENSION_RECORD_TYPE:			{				GifByteType *extension;				int extCode;				if (DGifGetExtension(gifFile, &extCode, &extension) == GIF_ERROR)				{					goto cleanup;				}				switch (extCode)				{//.........这里部分代码省略.........