summaryrefslogtreecommitdiffstats
path: root/hl/tools/gif2h5/gif2mem.c
diff options
context:
space:
mode:
Diffstat (limited to 'hl/tools/gif2h5/gif2mem.c')
-rw-r--r--hl/tools/gif2h5/gif2mem.c344
1 files changed, 344 insertions, 0 deletions
diff --git a/hl/tools/gif2h5/gif2mem.c b/hl/tools/gif2h5/gif2mem.c
new file mode 100644
index 0000000..92ca8e5
--- /dev/null
+++ b/hl/tools/gif2h5/gif2mem.c
@@ -0,0 +1,344 @@
+/*
+** This file contains snippets of code from James Murray's original file
+** to display the GIF header information, but most of it has been modified to
+** suit gif2hdf
+*/
+
+
+
+/****************************************************************************\
+** Title: GIFHEAD.C **
+** Purpose: Display the data in a GIF image file. **
+** Version: 1.0 **
+** Date: March 1992 **
+** Author: James D. Murray, Anaheim, CA, USA **
+** C Compilers: Borland C++ v2.0, Microsoft C v6.00a **
+** **
+** GIFHEAD displays all real information contained within a GIF image **
+** file, including all color tables and extension block information. **
+** GIFHEAD reads both GIF 87a abd 89a-format files. **
+** **
+** Copyright (C) 1991-92 by Graphics Software Labs. All rights reserved. **
+\****************************************************************************/
+#include <stdio.h>
+#include "gif.h"
+/* #include <hdf.h> */
+
+#define VERSION "1.00"
+extern int EndianOrder;
+
+GIFTOMEM
+Gif2Mem(MemGif)
+BYTE *MemGif;
+{
+ /*
+ ** The gif structure outline for passing data to memory
+ ** is given in gif.h
+ ** These pointers are redunant, should take them out in ver. 2
+ */
+ GIFHEAD *gifHead; /* GIF Header structure */
+ GIFIMAGEDESC **gifImageDesc; /* Logical Image Descriptor struct */
+ GIFPLAINTEXT **gifPlainText; /* Plain Text Extension structure */
+ GIFAPPLICATION **gifApplication; /* Application Extension structure */
+ GIFCOMMENT **gifComment; /* Comment Extension structure */
+ GIFGRAPHICCONTROL **gifGraphicControl; /* Graphic Control Extension strct */
+
+ GIFTOMEM GifMemoryStruct;
+
+
+
+ register WORD i; /* Loop counter */
+ BYTE Identifier; /* Extension block identifier holder */
+ BYTE Label; /* Extension block label holder */
+ BYTE ImageCount; /* Count of the number of images in the file */
+ BYTE ImageArray; /* Keep the size of the array to store Images */
+ BYTE CommentCount;
+ BYTE CommentArray;
+ BYTE ApplicationCount;
+ BYTE ApplicationArray;
+ BYTE PlainTextCount;
+ BYTE PlainTextArray;
+ BYTE GCEflag;
+ BYTE aTemp;
+ BYTE j;
+
+ BYTE w; /* Two more variables needed only while testing */
+ BYTE *b; /* Endian Ordering */
+
+ /* Allocate memory for the GIF structures */
+ /* Plug the structs into GifMemoryStruct at the end */
+ /****************************************************/
+ if (!(gifHead = (GIFHEAD *)malloc(sizeof(GIFHEAD))))
+ {
+ printf("Could not allocate memory for gifHead\n");
+ exit(-1);
+ }
+
+ /*
+ ** The next three have to grow dynamically so we leave them
+ ** for now and let realloc handle it later on.
+ */
+ gifImageDesc = NULL;
+ gifPlainText = NULL;
+ gifGraphicControl = NULL;
+ gifComment = NULL;
+ gifApplication = NULL;
+
+ /******************************/
+ /* Memory allocation complete */
+
+
+ /* Carry out Endian Testing and set Endian Order */
+ w = 0x0001;
+ b = (BYTE *) &w;
+ EndianOrder = (b[0] ? 1 : 0);
+
+ /* Read the GIF image file header information */
+ ReadGifHeader(gifHead, &MemGif);
+
+ /* Check for FILE stream error */
+ /*
+ if (ferror(fpGif))
+ {
+ fputs("GIFHEAD: Error reading header information!\n", stderr);
+ exit(-3);
+ }
+ */
+
+ /*
+ ** Identify, read, and display block information.
+ */
+ ImageCount = ImageArray = 0;
+ CommentCount = CommentArray = 0;
+ ApplicationCount = ApplicationArray = 0;
+ PlainTextCount = PlainTextArray = 0;
+ GCEflag = 0;
+
+ for (;;)
+ {
+ Identifier = *MemGif++;
+
+ switch (Identifier)
+ {
+ case 0x3B: /* Trailer */
+ /* The counts are stored to make it easier while
+ ** putting stuff into the HDF file and then
+ ** deallocating space.
+ */
+ gifHead->ImageCount = ImageCount;
+ gifHead->CommentCount = CommentCount;
+ gifHead->ApplicationCount = ApplicationCount;
+ gifHead->PlainTextCount = PlainTextCount;
+
+ /* putting stuff into the gif2mem structure */
+ GifMemoryStruct.GifHeader = gifHead;
+ GifMemoryStruct.GifImageDesc = gifImageDesc;
+ GifMemoryStruct.GifPlainTextExtension = gifPlainText;
+ GifMemoryStruct.GifApplicationExtension = gifApplication;
+ GifMemoryStruct.GifCommentExtension = gifComment;
+ GifMemoryStruct.GifGraphicControlExtension = gifGraphicControl;
+
+ /* return the struct */
+ return GifMemoryStruct;
+
+
+
+ case 0x2C: /* Image Descriptor */
+ /* If there was no image descriptor before this increase image count.
+ ** If an imagedescriptor was present, reset GCEflag
+ */
+ if (GCEflag == 0)
+ ImageCount++;
+ else
+ GCEflag = 0;
+
+ if (ImageCount > ImageArray) {
+ aTemp = ImageArray;
+ ImageArray = (ImageArray << 1) + 1;
+ if (!(gifImageDesc = (GIFIMAGEDESC **)realloc(gifImageDesc , sizeof(GIFIMAGEDESC *) * ImageArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+ if (!(gifGraphicControl = (GIFGRAPHICCONTROL **)realloc(gifGraphicControl , sizeof(GIFGRAPHICCONTROL *) * ImageArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+ for (j = aTemp ; j < ImageArray ; j++) {
+ gifGraphicControl[j] = NULL;
+ gifImageDesc[j] = NULL;
+ }
+ }
+
+ if(!(gifImageDesc[ImageCount-1] = (GIFIMAGEDESC*)malloc(sizeof(GIFIMAGEDESC))))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+
+ if (ReadGifImageDesc(gifImageDesc[ImageCount-1], &MemGif) == -1)
+ fputs("Error reading Image Descriptor information\n", stderr);
+
+ /*
+ ** Decompress the Image
+ */
+ gifImageDesc[ImageCount-1]->Image = Decompress(gifImageDesc[ImageCount-1] , gifHead);
+ free(gifImageDesc[ImageCount-1]->GIFImage);
+
+ /*
+ ** Convert the local palette into an HDF compatible palette
+ ** In case the local color table is present, it is written out as the HDFPalette
+ ** If it is absent the global table is written as the HDFPalette.
+ */
+ if (!((gifImageDesc[ImageCount-1]->PackedField) & 0x80))
+ {
+ /* Check to see if the global color table exists.... */
+ if (gifHead->PackedField & 0x80) {
+ for (i=0 ; i<gifHead->TableSize ; i++)
+ {
+ gifImageDesc[ImageCount-1]->HDFPalette[i][0] = gifHead->HDFPalette[i][0];
+ gifImageDesc[ImageCount-1]->HDFPalette[i][1] = gifHead->HDFPalette[i][1];
+ gifImageDesc[ImageCount-1]->HDFPalette[i][2] = gifHead->HDFPalette[i][2];
+ }
+ }
+ gifImageDesc[ImageCount-1]->TableSize = gifHead->TableSize;
+ }
+
+ break;
+
+ case 0x21: /* Extension Block */
+ Label = *MemGif++;
+ switch (Label)
+ {
+ case 0x01: /* Plain Text Extension */
+ puts("Plain Text Extension\n");
+
+ PlainTextCount++;
+ if (PlainTextCount > PlainTextArray)
+ PlainTextArray = (PlainTextArray << 1) + 1;
+
+ if (!(gifPlainText = (GIFPLAINTEXT **)realloc(gifPlainText , sizeof(GIFPLAINTEXT *) * PlainTextArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+ if(!(gifPlainText[PlainTextCount - 1] = (GIFPLAINTEXT*)malloc(sizeof(GIFPLAINTEXT))))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+
+
+ if (ReadGifPlainText(gifPlainText[PlainTextCount - 1], &MemGif))
+ fprintf(stderr,
+ "Error reading Plain Text Extension information.\n");
+
+ break;
+
+ case 0xFE: /* Comment Extension */
+ CommentCount++;
+ if (CommentCount > CommentArray)
+ CommentArray = (CommentArray << 1) + 1;
+
+ if (!(gifComment = (GIFCOMMENT **)realloc(gifComment , sizeof(GIFCOMMENT *) * CommentArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+ if(!(gifComment[CommentCount - 1] = (GIFCOMMENT *)malloc(sizeof(GIFCOMMENT))))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+
+ if (ReadGifComment(gifComment[CommentCount - 1], &MemGif))
+ fprintf(stderr,
+ "Error reading Comment Extension information\n");
+ break;
+
+ case 0xF9: /* Graphic Control Extension */
+ if (GCEflag == 0 )
+ ImageCount++;
+
+ GCEflag = 1;
+
+ if (ImageCount > ImageArray) {
+ aTemp = ImageArray;
+ ImageArray = (ImageArray << 1) + 1;
+ if (!(gifGraphicControl = (GIFGRAPHICCONTROL **)realloc(gifGraphicControl , sizeof(GIFGRAPHICCONTROL *) * ImageArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+ if (!(gifImageDesc = (GIFIMAGEDESC **)realloc(gifImageDesc , sizeof(GIFIMAGEDESC *) * ImageArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+ for (j = aTemp ; j < ImageArray ; j++) {
+ gifGraphicControl[j] = NULL;
+ gifImageDesc[j] = NULL;
+ }
+ }
+
+ if(!(gifGraphicControl[ImageCount-1] = (GIFGRAPHICCONTROL*)malloc(sizeof(GIFGRAPHICCONTROL))))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+
+ if (ReadGifGraphicControl(gifGraphicControl[ImageCount-1], &MemGif))
+ fprintf(stderr,
+ "Error reading Graphic Control Extension information\n");
+
+ if (!*MemGif++ == 0)
+ fprintf(stderr,
+ "Error reading Graphic Control Extension\n");
+
+ break;
+
+ case 0xFF: /* Application Extension */
+ ApplicationCount++;
+ if (ApplicationCount > ApplicationArray)
+ ApplicationArray = (ApplicationArray << 1) + 1;
+
+ if (!(gifApplication = (GIFAPPLICATION **)realloc(gifApplication , sizeof(GIFAPPLICATION *) * ApplicationArray)))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+ if(!(gifApplication[ApplicationCount - 1] = (GIFAPPLICATION *)malloc(sizeof(GIFAPPLICATION))))
+ {
+ printf("Out of memory!");
+ exit(-1);
+ }
+
+
+ if (ReadGifApplication(gifApplication[ApplicationCount - 1], &MemGif))
+ fprintf(stderr,
+ "Error reading Application Extension information\n");
+ break;
+
+ default:
+
+ printf("Unknown Extension Label: 0x%02x\n", Label);
+ break;
+ }
+ break;
+ default:
+ fprintf(stderr, "Unknown Block Separator Character: 0x%02x\n",
+ Identifier);
+ }
+ }
+
+
+}
generated by cgit v0.12 at 2024-08-22 22:40:29 (GMT)