ebgif.c

基于minigui开发的一套图形控件系统

        return -1;                /* image loading error*/
    }
    GifScreen->transparent = -1;
    GifScreen->delayTime = -1;
    GifScreen->inputFlag = -1;
    GifScreen->disposal = 0;

    if (!ReadOK (src, buf, 7)) 
	{
#ifdef _DEBUG
        fprintf (stderr, "load_gif: bad screen descriptor\n");
#endif
        return -1;                /* image loading error*/
    }
    GifScreen->Width = LM_to_uint (buf[0], buf[1]);
    GifScreen->Height = LM_to_uint (buf[2], buf[3]);
    GifScreen->BitPixel = 2 << (buf[4] & 0x07);
    GifScreen->ColorResolution = (((buf[4] & 0x70) >> 3) + 1);
    GifScreen->Background = buf[5];
    GifScreen->AspectRatio = buf[6];

    if (BitSet(buf[4], LOCALCOLORMAP)) 
	{        /* Global Colormap */
        if (ReadColorMap (src, GifScreen->BitPixel, GifScreen->ColorMap)) 
		{
#ifdef _DEBUG
            fprintf (stderr, "load_gif: bad global colormap\n");
#endif
            return -1;                /* image loading error*/
        }
    }

		return 0;
}

static int ReadImageDesc (FILE *src, IMAGEDESC* ImageDesc, GIFSCREEN* GifScreen)
{
	unsigned char buf[16];
	if (!ReadOK (src, buf, 9)) 
	{
#ifdef _DEBUG
		fprintf (stderr, "load_gif: bad image size\n");
#endif
		return -1;
	}
	ImageDesc->Top= LM_to_uint (buf[0], buf[1]);
	ImageDesc->Left= LM_to_uint (buf[2], buf[3]);
	ImageDesc->Width = LM_to_uint (buf[4], buf[5]);
	ImageDesc->Height = LM_to_uint (buf[6], buf[7]);
	ImageDesc->haveColorMap = BitSet (buf[8], LOCALCOLORMAP);

	ImageDesc->bitPixel = 1 << ((buf[8] & 0x07) + 1);

    ImageDesc->interlace = BitSet(buf[8], INTERLACE);

	if (ImageDesc->haveColorMap)
	{
		if (ReadColorMap(src, ImageDesc->bitPixel, ImageDesc->ColorMap) < 0) 
		{
#ifdef _DEBUG
			fprintf (stderr, "load_gif: bad local colormap\n");
#endif
			return -1;
		}
	} 
	else 
	{
		memcpy (ImageDesc->ColorMap, GifScreen->ColorMap, MAXCOLORMAPSIZE*3);
	}

	return 0;
}

static int ReadImage (FILE* src, MYBITMAP* bmp, IMAGEDESC* ImageDesc, GIFSCREEN* GifScreen, int ignore)
{

    unsigned char c;
    int v;
    int xpos = 0, ypos = 0, pass = 0;

    /*
     *        initialize the compression routines
     */
    if (!ReadOK(src, &c, 1)) 
	{
        fprintf (stderr,"load_gif: eof on image data\n");
        return -1;
    }
    if (LWZReadByte(src, TRUE, c) < 0) 
	{
        fprintf (stderr,"load_gif: error reading image\n");
        return -1;
    }
    /*
     *        if this is an "uninteresting picture" ignore it.
     */
    if (ignore) 
	{
        while (LWZReadByte(src, FALSE, c) >= 0);
        return -0;
    }
    /*image = imagenewcmap(len, height, cmapsize);*/

    bmp->w = ImageDesc->Width;
    bmp->h = ImageDesc->Height;

    bmp->flags = MYBMP_FLOW_DOWN;
    if (GifScreen->transparent > 0) 
	{
        bmp->flags |= MYBMP_TRANSPARENT;
        bmp->transparent = GifScreen->transparent;
    }
    bmp->frames = 1;
    bmp->depth = 8;
    bmpComputePitch (bmp->depth, bmp->w, &bmp->pitch, TRUE);
    bmp->bits = malloc (bmp->h * bmp->pitch);

    if(!bmp->bits)
        return -1;

    while ((v = LWZReadByte(src, FALSE, c)) >= 0) 
	{
#if 0
		int index = (ypos) * bmp->pitch + (xpos)*3;
		bmp->bits[index + 0 ] = ImageDesc->ColorMap[CM_RED][v]; 
		bmp->bits[index + 1 ] = ImageDesc->ColorMap[CM_GREEN][v];
		bmp->bits[index + 2 ] = ImageDesc->ColorMap[CM_BLUE][v];
#else		
    	 bmp->bits[ypos * bmp->pitch + xpos] = v;
#endif
        ++xpos;
        if (xpos == ImageDesc->Width) 
		{
            xpos = 0;
            if (ImageDesc->interlace) 
			{
                switch (pass) 
				{
                case 0:
                case 1:
                    ypos += 8;
                    break;
                case 2:
                    ypos += 4;
                    break;
                case 3:
                    ypos += 2;
                    break;
                }

                if (ypos >= ImageDesc->Height) 
				{
                    ++pass;
                    switch (pass) 
					{
                    case 1:
                        ypos = 4;
                        break;
                    case 2:
                        ypos = 2;
                        break;
                    case 3:
                        ypos = 1;
                        break;
                    default:
                        goto fini;
                    }
                }
            } 
			else
			{
                ++ypos;
            }
        }
        if (ypos >= ImageDesc->Height)
            break;
    }

fini:
    return 0;
}


int ReadGIF(FILE *src, GIFBITMAP* gifbmp, HDC hdc)
{
    unsigned char c;
    int ok = 0;
	MYBITMAP mybmp;
	PBITMAP pbmp;
	GIFSCREEN GifScreen;
	IMAGEDESC ImageDesc;
	GIFBITMAPELEMENT* pgifel;

	if ( ReadGIFGlobal ( src, &GifScreen) < 0 ) 
	{
		return -1;
	}

    if ( (ok = ReadOK (src, &c, 1)) == 0) {
#ifdef _debug
        fprintf (stderr, "load_gif: eof on image data\n");
#endif
        return -1;
    }

	while ( c != ';' && ok>0 )
	{
		switch (c) 
		{
		case '!':
    			if ( (ok = ReadOK (src, &c, 1)) == 0) 
				{
#ifdef _debug
       				 fprintf (stderr, "load_gif: eof on image data\n");
#endif
      				  return -1;
    			}
			DoExtension(src, c, &GifScreen);
			break;
		case ',':
			gifbmp->count ++ ;
			if (ReadImageDesc ( src, &ImageDesc, &GifScreen) < 0) 
			{
				return -1;
			} 
			else 
			{
				if (ReadImage ( src, &mybmp, &ImageDesc, &GifScreen, 0 ) < 0)
					return -1;
			}

			pgifel = (GIFBITMAPELEMENT*) malloc (sizeof (GIFBITMAPELEMENT));
			if (!pgifel)
				return -1;
			else 
			{
				pgifel->prev = pgifel->next = NULL;
				pgifel->top = ImageDesc.Top;
				pgifel->left = ImageDesc.Left;
				#if 0
				pgifel->desc.Left = ImageDesc.Left;
				pgifel->desc.Top = ImageDesc.Top;
				pgifel->desc.interlace = ImageDesc.interlace;
				pgifel->desc.bitPixel = ImageDesc.bitPixel;
				pgifel->desc.grayScale = ImageDesc.grayScale;
				pgifel->desc.haveColorMap = ImageDesc.haveColorMap;
				pgifel->desc.Height = ImageDesc.Height;
				pgifel->desc.Width = ImageDesc.Width;
				pgifel->desc.Left =ImageDesc.;
				#else
				memcpy((void *)&(pgifel->desc), (void *)&ImageDesc, sizeof(IMAGEDESC));
				fprintf(stderr, "_______ReadGIF desc'left=%d \n", pgifel->desc.Left);
				fprintf(stderr, "_______ReadGIF desc'Top=%d \n", pgifel->desc.Top);
				fprintf(stderr, "_______ReadGIF desc'Height=%d \n", pgifel->desc.Height);
				fprintf(stderr, "_______ReadGIF desc'Width=%d \n", pgifel->desc.Width);
				fprintf(stderr, "_______ReadGIF desc'interlace=%d \n", pgifel->desc.interlace);
				fprintf(stderr, "_______ReadGIF desc'bitPixel=%d \n", pgifel->desc.bitPixel);
				fprintf(stderr, "_______ReadGIF desc'haveColorMap=%d \n", pgifel->desc.haveColorMap);
				#endif
				pbmp = &(pgifel->Bitmap);
#ifdef _USE_NEWGAL
                if (ExpandMyBitmap (hdc, pbmp, &mybmp, ImageDesc.ColorMap, 0) < 0) {
#else
                if (ExpandMyBitmap (hdc, &mybmp, ImageDesc.ColorMap, pbmp) < 0) {
#endif
                    free (mybmp.bits);
					goto error;
                }
                free (mybmp.bits);
				
				if (gifbmp->first == NULL)
				{
					gifbmp->first = gifbmp->current = pgifel;
				} 
				else 
				{
					pgifel->prev = gifbmp->current;
					gifbmp->current->next = pgifel;
					gifbmp->current = gifbmp->current->next;
				}
			}
			break;
		default:
			break;
		}

		ok = ReadOK (src, &c, 1);
	
	}
	gifbmp->delaytime = GifScreen.delayTime;
	return 0;

error:
    CleanGIF (gifbmp);
    return -1;
}

void InitGIF (GIFBITMAP* gifbmp)
{
	gifbmp->first = gifbmp->current = NULL;
	
	return;
}

void CleanGIF (GIFBITMAP* gifbmp)
{
	GIFBITMAPELEMENT *tmpel, *pel;
		
	pel = gifbmp->first;
	while (pel) 
	{
		tmpel= pel->next;
		if (pel->Bitmap.bmBits)
			free (pel->Bitmap.bmBits);
		free (pel);

		pel = tmpel;
	}

	return;
}

void RewindGIF (GIFBITMAP* gifbmp)
{
	gifbmp->current = gifbmp->first;
}

PBITMAP GetCurrentGIFBmp (GIFBITMAP* gifbmp)
{
	if(gifbmp->current)
		return &(gifbmp->current->Bitmap);
	else
		return 0;
}

PBITMAP GetNextGIFBmp (GIFBITMAP* gifbmp)
{
	gifbmp->current = gifbmp->current->next;
	return GetCurrentGIFBmp (gifbmp);
}

PGIFBITMAPELEMENT GetCurrentGIFItem(GIFBITMAP* gifbmp)
{
	if (gifbmp->current)
		return gifbmp->current;
	else
		return NULL;
}

PGIFBITMAPELEMENT GetNextGIFItem(GIFBITMAP* gifbmp)
{
	gifbmp->current = gifbmp->current->next;
	
	if (gifbmp->current)
		return gifbmp->current;
	else
		return NULL;
}