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

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

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

value dGifGetRecordType( value hdl ){  CAMLparam1(hdl);  GifRecordType RecordType;  if (DGifGetRecordType((GifFileType*) hdl, &RecordType) == GIF_ERROR) {    failwith("DGifGetRecordType");  }  CAMLreturn(Val_int(RecordType));}

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

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

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

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 )    {//.........这里部分代码省略.........

//.........这里部分代码省略.........    /* the GIF file parameters itself.					     */    if ((ScreenBuffer = (GifRowType *)	malloc(GifFile -> SHeight * sizeof(GifRowType *))) == NULL)	    GIF_EXIT("Failed to allocate memory required, aborted.");    Size = GifFile -> SWidth * sizeof(GifPixelType);/* Size in bytes of one row.*/    if ((ScreenBuffer[0] = (GifRowType) malloc(Size)) == NULL)    /* First row. */	GIF_EXIT("Failed to allocate memory required, aborted.");    for (i = 0; i < GifFile -> SWidth; i++)  /* Set its color to BackGround. */	ScreenBuffer[0][i] = GifFile -> SBackGroundColor;    MaximumScreenHeight = GifFile -> SHeight - 1;    for (i = 1; i < GifFile -> SHeight; i++) {	/* Allocate the other rows, and set their color to background too: */	if ((ScreenBuffer[i] = (GifRowType) malloc(Size)) == NULL) {	    if (i > 30) {		/* Free some memory for the BGI driver and auxilary. */		for (j = 1; j < 28; j++)	    	    free((char *) ScreenBuffer[i - j]);	    	MaximumScreenHeight = i - 28;	    	fprintf(stderr, "/n%s: Failed to allocate all memory required, last line %d./n",			PROGRAM_NAME, MaximumScreenHeight);	    	break;	    }	    else		GIF_EXIT("Failed to allocate memory required, aborted.");	}	memcpy(ScreenBuffer[i], ScreenBuffer[0], Size);    }    /* Scan the content of the GIF file and load the image(s) in: */    do {	if (DGifGetRecordType(GifFile, &RecordType) == GIF_ERROR) {	    PrintGifError();	    break;	}	switch (RecordType) {	    case IMAGE_DESC_RECORD_TYPE:		if (DGifGetImageDesc(GifFile) == GIF_ERROR) {		    PrintGifError();		    exit(-1);		}		Row = GifFile -> ITop; /* Image Position relative to Screen. */		Col = GifFile -> ILeft;		Width = GifFile -> IWidth;		Height = GifFile -> IHeight;		GifQprintf("/n%s: Image %d at (%d, %d) [%dx%d]:     ",		    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);

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;//.........这里部分代码省略.........

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 ||//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

int FileGIF::read_frame(VFrame *output, VFrame *input){	data = input->get_data();	offset = 0;	size = input->get_compressed_size();	GifFileType *gif_file;	GifRowType *gif_buffer;	gif_file = DGifOpen(this, input_func);			if(gif_file == 0)	{		printf("FileGIF::read_frame %d: %s/n", __LINE__, GifErrorString());		return 1;	}	gif_buffer = (GifRowType*)malloc(sizeof(GifRowType) * gif_file->SHeight);	int row_size = gif_file->SWidth * sizeof(GifPixelType);	gif_buffer[0] = (GifRowType)malloc(row_size);	for(int i = 0; i < gif_file->SWidth; i++)	{		gif_buffer[0][i] = gif_file->SBackGroundColor;	}	for(int i = 0; i < gif_file->SHeight; i++)	{		gif_buffer[i] = (GifRowType)malloc(row_size);		memcpy(gif_buffer[i], gif_buffer[0], row_size);	}	GifRecordType record_type;	do	{		if(DGifGetRecordType(gif_file, &record_type) == GIF_ERROR)		{			printf("FileGIF::read_frame %d: %s/n", __LINE__, GifErrorString());			break;		}				switch(record_type)		{			case IMAGE_DESC_RECORD_TYPE:			{				if(DGifGetImageDesc(gif_file) == GIF_ERROR)				{					printf("FileGIF::read_frame %d: %s/n", __LINE__, GifErrorString());					break;				}				int row = gif_file->Image.Top;				int col = gif_file->Image.Left;				int width = gif_file->Image.Width;				int height = gif_file->Image.Height;				if(gif_file->Image.Left + gif_file->Image.Width > gif_file->SWidth ||		 		  gif_file->Image.Top + gif_file->Image.Height > gif_file->SHeight)				{					DGifCloseFile(gif_file);					for(int k = 0; k < gif_file->SHeight; k++)					{						free(gif_buffer[k]);					}					free(gif_buffer);					return 1;				}								if (gif_file->Image.Interlace) 				{				    static int InterlacedOffset[] = { 0, 4, 2, 1 };				    static int InterlacedJumps[] = { 8, 8, 4, 2 };/* Need to perform 4 passes on the images: */		    		for (int i = 0; i < 4; i++)					{						for (int j = row + InterlacedOffset[i]; 							j < row + height;							j += InterlacedJumps[i]) 						{			    			if (DGifGetLine(gif_file, 								&gif_buffer[j][col],								width) == GIF_ERROR) 							{								DGifCloseFile(gif_file);								for(int k = 0; k < gif_file->SHeight; k++)								{									free(gif_buffer[k]);								}								free(gif_buffer);								return 1;			    			}						}					}				}				else 				{		    		for (int i = 0; i < height; i++) 					{						if (DGifGetLine(gif_file, &gif_buffer[row++][col],							width) == GIF_ERROR) 						{							DGifCloseFile(gif_file);//.........这里部分代码省略.........

/****************************************************************************** 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://.........这里部分代码省略.........

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

/* * Partially based on code in gif2rgb from giflib, by Gershon Elber. */RImage *RLoadGIF(const char *file, int index){	RImage *image = NULL;	unsigned char *cptr;	GifFileType *gif = NULL;	GifPixelType *buffer = NULL;	int i, j, k;	int width, height;	GifRecordType recType;	ColorMapObject *colormap;	unsigned char rmap[256];	unsigned char gmap[256];	unsigned char bmap[256];	if (index < 0)		index = 0;	/* default error message */	RErrorCode = RERR_BADINDEX;	gif = DGifOpenFileName(file);	if (!gif) {		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;		}		return NULL;	}	if (gif->SWidth < 1 || gif->SHeight < 1) {		DGifCloseFile(gif);		RErrorCode = RERR_BADIMAGEFILE;		return NULL;	}	colormap = gif->SColorMap;	i = 0;	do {		int extCode;		GifByteType *extension;		if (DGifGetRecordType(gif, &recType) == GIF_ERROR) {			goto giferr;		}		switch (recType) {		case IMAGE_DESC_RECORD_TYPE:			if (i++ != index)				break;			if (DGifGetImageDesc(gif) == GIF_ERROR) {				goto giferr;			}			width = gif->Image.Width;			height = gif->Image.Height;			if (gif->Image.ColorMap)				colormap = gif->Image.ColorMap;			/* the gif specs talk about a default colormap, but it			 * doesnt say what the heck is this default colormap */			if (!colormap) {				/*				 * Well, since the spec says the colormap can be anything,				 * lets just render it with whatever garbage the stack				 * has :)				 *				 goto bye;				 */			} else {				for (j = 0; j < colormap->ColorCount; j++) {					rmap[j] = colormap->Colors[j].Red;					gmap[j] = colormap->Colors[j].Green;					bmap[j] = colormap->Colors[j].Blue;				}			}			buffer = malloc(width * sizeof(GifColorType));			if (!buffer) {				RErrorCode = RERR_NOMEMORY;				goto bye;			}			image = RCreateImage(width, height, False);			if (!image) {				goto bye;//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

//.........这里部分代码省略.........    }    BackGroundColor = GifFileIn->SBackGroundColor;    /* If size was specified, it is used to derive the scale: */    if (SizeFlag) {	XScale = XSize / ((double) GifFileIn->SWidth);	YScale = YSize / ((double) GifFileIn->SHeight);    }    else    {	XSize = (int) (GifFileIn->SWidth * XScale + 0.5);	YSize = (int) (GifFileIn->SHeight * YScale + 0.5);    }    /* As at this time we know the Screen size of the input gif file, and as */    /* all image(s) in file must be less/equal to it, we can allocate the    */    /* scan lines for the input file, and output file. The number of lines   */    /* to allocate for each is set by ScaleDown & XScale & YScale:	     */    LineOut = (GifRowType) malloc(XSize * sizeof(GifPixelType));    LineIn = (GifRowType) malloc(GifFileIn->SWidth * sizeof(GifPixelType));    /* Open stdout for the output file: */    if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)	QuitGifError(GifFileIn, GifFileOut);    /* And dump out its new scaled screen information: */    if (EGifPutScreenDesc(GifFileOut, XSize, YSize,	GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,	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: */		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;

/****************************************************************************** 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)//.........这里部分代码省略.........

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);//.........这里部分代码省略.........

/******************************************************************************* 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);//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

/******************************************************************************* Interpret the command line and scan the given GIF file.		      *******************************************************************************/int main(int argc, char **argv){    int	Error, NumFiles, ExtCode, CodeSize, ImageNum = 0,	ImageNFlag = FALSE, ImageN, HelpFlag = FALSE, HasGIFOutput;    GifRecordType RecordType;    GifByteType *Extension, *CodeBlock;    char **FileName = NULL, *ColorFileName, *TranslateFileName;    GifFileType *GifFileIn = NULL, *GifFileOut = NULL;    if ((Error = GAGetArgs(argc, argv, CtrlStr, &GifQuietPrint, &SaveFlag, 		&TranslateFlag, &TranslateFileName,		&LoadFlag, &ColorFileName,		&GammaFlag, &Gamma, &ImageNFlag, &ImageN,		&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(EXIT_FAILURE);    }    if (HelpFlag) {	fprintf(stderr, VersionStr);	GAPrintHowTo(CtrlStr);	exit(EXIT_SUCCESS);    }    if (SaveFlag + LoadFlag + GammaFlag + TranslateFlag > 1)	GIF_EXIT("Can not handle more than one of -s -l, -t, or -g at the same time.");    if (NumFiles == 1) {	if ((GifFileIn = DGifOpenFileName(*FileName)) == NULL)	    QuitGifError(GifFileIn, GifFileOut);    }    else {	/* Use stdin instead: */	if ((GifFileIn = DGifOpenFileHandle(0)) == NULL)	    QuitGifError(GifFileIn, GifFileOut);    }    if (SaveFlag) {	/* We are dumping out the color map as text file to stdout: */	ColorFile = stdout;    }    else {	if (TranslateFlag) {	    /* We are loading new color map from specified file: */	    if ((TranslateFile = fopen(TranslateFileName, "rt")) == NULL)		GIF_EXIT("Failed to open specified color translation file.");	}	if (LoadFlag) {	    /* We are loading new color map from specified file: */	    if ((ColorFile = fopen(ColorFileName, "rt")) == NULL)		GIF_EXIT("Failed to open specified color map file.");	}    }    if ((HasGIFOutput = (LoadFlag || TranslateFlag || GammaFlag)) != 0) {	/* Open stdout for GIF output file: */	if ((GifFileOut = EGifOpenFileHandle(1)) == NULL)	    QuitGifError(GifFileIn, GifFileOut);    }    if (!ImageNFlag) {	/* We are suppose to modify the screen color map, so 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);	}    }    /* And dump out its new possible repositioned screen information: */    if (HasGIFOutput)	if (EGifPutScreenDesc(GifFileOut,	    GifFileIn->SWidth, GifFileIn->SHeight,	    GifFileIn->SColorResolution, GifFileIn->SBackGroundColor,	    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);		if ((++ImageNum == ImageN) && ImageNFlag) {		    /* We are suppose to modify this image color map, do it: */		    GifFileIn->SColorMap =ModifyColorMap(GifFileIn->SColorMap);		    if (!HasGIFOutput) {//.........这里部分代码省略.........

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)				{//.........这里部分代码省略.........