summaryrefslogtreecommitdiffstats
path: root/tools/gifconv/hdf2gif.c
blob: 9b5eebcb1c85a60d4af570ec1db1712bba14aaff (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
/*
 * Copyright (C) 2001 National Center for Supercomputing Applications
 *                    All rights reserved.
 */

/*
 * NOTES:
 * 04/01 - 04/10: been working on it a lot. I think it does gif89 images just
 *                fine with palettes. So that's cool. Putting in multiple
 *                images and animation support right now
 * 03/29: For some reason I can write .GIF files which IE will open and see
 *        but kodak imaging does not like. I'm sure its a problem with the GIF
 *        file, I can't figure out what.
 * 03/17: Explicitely deallocate the GIFTOMEM* struct in the main loop.
 *        Check for both success and failure conditions
 */

#include <stdio.h>

#include "gif.h"

#define MAX_FILE_LEN            256
#define MAX_NUMBER_IMAGES       50

extern int hdfWriteGIF(FILE *fp, BYTE *pic, int ptype, int w, int h,
                       BYTE *rmap, BYTE *gmap, BYTE *bmap, BYTE *pc2ncmap,
                       int numcols, int colorstyle, int BitsPerPixel);
int EndianOrder;

#ifdef NOT_USED
static void
PutByte(BYTE b , FILE *fpGif)
{
    if (fputc(b , fpGif) == EOF) {
        printf("File Writing Error, cannot continue");
        exit(-1);
    }
}
#endif /* NOT_USED */

static void
putword(int w, FILE *fp)
{
    /* writes a 16-bit integer in GIF order (LSB first) */
    fputc(w &0xff, fp);
    fputc((w>>8)&0xff,fp);
}

static void
usage(void)
{
    printf("Usage: h52gif <h5_file> <gif_file> -i <h5_image> [-p <h5_palette>]\n");
    printf("h52gif expects *at least* one h5_image.\n");
    printf("You may repeat -i <h5_image> [-p <h5_palette>] at most 50 times\n");
    printf("(maximum of 50 images).\n");
}

int main(int argc , char **argv)
{
    FILE *fpGif;
    hsize_t dim_sizes[2];
    BYTE *Image;

    /* compression structs */
    CHAR *HDFName = NULL;
    CHAR *GIFName = NULL;

    /* reference variables */
    int has_local_palette;  /* treated as a flag */
    int loop_times;         /* number of times to loop, treat it as yes/no */

    BYTE* b;

    BYTE  GlobalPalette[256][3];
    BYTE  Red[256];
    BYTE  Green[256];
    BYTE  Blue[256];

    int   RWidth, RHeight;
#ifdef UNUSED
    int   LeftOfs, TopOfs;
    int   CountDown;
    int   curx , cury;
    int	  w,h;
#endif /* UNUSED */
    int   ColorMapSize, InitCodeSize, Background, BitsPerPixel;
    int   j,nc;
    int	  i;
    int   numcols = 256;
    int   time_out = 0;		/* time between two images in the animation */
    int   n_images , idx;

    BYTE pc2nc[256] , r1[256] , g1[256] , b1[256];

    /* initial stuff */
    int number_of_images = 0;
    int arg_index = 2;
    int bool_is_image = 0; /* 0 = false , 1 = true */
    int bool_is_palette = 0;
    CHAR* image_name_arr[MAX_NUMBER_IMAGES];
    CHAR* pal_name_arr[MAX_NUMBER_IMAGES];

    if (argc < 5) {
        /* they didn't supply at least one image -- bail */
        usage();
        return 0;
    }

    memset(image_name_arr , NULL , MAX_NUMBER_IMAGES);
    memset(pal_name_arr , NULL , MAX_NUMBER_IMAGES);

    HDFName = (CHAR *)malloc (strlen(argv[1]) + 1);
    GIFName = (CHAR *)malloc (strlen(argv[2]) + 1);

    if (strlen(argv[1] + 1) > MAX_FILE_LEN || strlen(argv[2] + 1) > MAX_FILE_LEN) {
        /* supplied file names are too long. bail. */
        usage();
        printf("Supplied filenames exceed maximum length of 256 bytes\n");
    }

    strcpy(HDFName , argv[1]);
    strcpy(GIFName , argv[2]);

    /* get the options */
    while (arg_index++ < argc - 1 && number_of_images < MAX_NUMBER_IMAGES) {
        if (!strcmp(argv[arg_index] , "-i")) {
            bool_is_image = 1;
            continue;
        }

        if (!strcmp(argv[arg_index] , "-p")) {
            bool_is_palette = 1;
            continue;
        }

        if (!strcmp(argv[arg_index] , "-a")) {
            time_out = 10;
            continue;
        }

        if (bool_is_image) {
            /* this is an image */
            /* allocate space to store the image name */
            image_name_arr[number_of_images] = (CHAR*) malloc(strlen(argv[arg_index] + 1));
            strcpy(image_name_arr[number_of_images] , argv[arg_index]);

            /* make the palette array for this NULL */
            pal_name_arr[number_of_images] = NULL;
            number_of_images++;
            bool_is_image = 0;
            continue;
        }

        if (bool_is_palette) {
            /* this is a palette */
            /* allocate space to store the pal name */
            /* the palette was probably allocated for a previous image */
            pal_name_arr[number_of_images-1] = (CHAR*) malloc(strlen(argv[arg_index] + 1));
            strcpy(pal_name_arr[number_of_images - 1], argv[arg_index]);
            bool_is_palette = 0;
            continue;
        }

        /* oops. This was not meant to happen */
        usage();

#if 0
        while (number_of_images--) {
            cleanup(image_name_arr[number_of_images]);
            cleanup(pal_name_arr[number_of_images]);
        }
#endif  /* 0 */

        return -1;
    }
            
    /* we shall always have a palette - read hdf will see to that */
    has_local_palette = true;

    /* Do Endian Order testing and set Endian Order */
    idx = 0x0001;
    b = (BYTE *) &idx;
    EndianOrder = (b[0] ? 1:0);
    
    if (!(fpGif = fopen(GIFName , "wb"))) {
        printf("Error opening gif file for output. Aborting.\n");
        return -1;
    }
    
    /* hardwire n_images to 1 for now. */
    n_images = number_of_images;

    Background = 0;
    for (idx = 0 ; idx < n_images ; idx++) {
        /* try to read the image and the palette */

        /*
         * Lots of funky stuff to support multiple images has been taken off.
         * Just in case you're extending code, here's what you need to do in
         * short: figure out if there is a global palette or not, if there is
         * one store that one only.  If they are all local or a combination of
         * local and global palettes, you will have to write the global
         * palette out and then independantly write the smaller local palettes
         */
        if (ReadHDF(&Image, GlobalPalette, dim_sizes, HDFName,
                    image_name_arr[idx], pal_name_arr[idx]) < 0) {
            fprintf(stderr , "Unable to read HDF file\n");
            return -1;
        }

        RWidth  = dim_sizes[1];
        RHeight = dim_sizes[0];
#ifdef UNUSED
        w = dim_sizes[1];
        h = dim_sizes[0];

        LeftOfs = TopOfs = 0;
#endif /* UNUSED */


        /*
         * If the first image does not have a palette, I make my own global
         * color table Obviously this is not the best thing to do, better
         * steps would be:
         *
         *   1. Check for either a global palette or a global attribute called
         *      palette
         *   2. Check for palettes in any of the other images.
         */
        if (!has_local_palette) {
            for (i = 0 ; i < 256 ; i++) {
                Red[i] = 255 - i;
                Green[i] = 255 - i;
                Blue[i] = 255 - i;
            }
        } else {
            for (i = 0 ; i < 256 ; i++){
                Red[i] = GlobalPalette[i][0];
                Green[i] = GlobalPalette[i][1];
                Blue[i] = GlobalPalette[i][2];
            }
        }
        
        for (i = 0; i < 256; i++) {
            pc2nc[i] = r1[i] = g1[i] = b1[i] = 0;
        }

        /* compute number of unique colors */
        nc = 0;

        for (i = 0; i < numcols; i++) {
            /* see if color #i is already used */
            for (j = 0; j < i; j++) {
                if (Red[i] == Red[j] && Green[i] == Green[j] && Blue[i] == Blue[j])
                    break;
            }

            if (j==i) {
                /* wasn't found */
                pc2nc[i] = nc;
                r1[nc] = Red[i];
                g1[nc] = Green[i];
                b1[nc] = Blue[i];
                nc++;
            } else {
                pc2nc[i] = pc2nc[j];
            }
        }

        /* figure out 'BitsPerPixel' */
        for (i = 1; i < 8; i++) {
            if ((1<<i) >= nc)
                break;
        }

        BitsPerPixel = i;
        ColorMapSize = 1 << BitsPerPixel;

#ifdef UNUSED
        CountDown = w * h;  /* # of pixels we'll be doing */
#endif /* UNUSED */
        
        if (BitsPerPixel <= 1)
            InitCodeSize = 2;
        else
            InitCodeSize = BitsPerPixel;

#ifdef UNUSED
        curx = cury = 0;
#endif /* UNUSED */

        if (!fpGif) {
            fprintf(stderr,  "WriteGIF: file not open for writing\n" );
            return (1);
        }

        /*
         * If it is the first image we do all the header stuff that isn't
         * required for the rest of the images. 
         */
        if (idx == 0) {
            /* Write out the GIF header and logical screen descriptor */
            if (n_images > 1) {
                fwrite("GIF89a", 1, 6, fpGif);  /* the GIF magic number */
                loop_times = 0;
            } else {
                fwrite("GIF87a", 1, 6, fpGif);  /* the GIF magic number */
                loop_times = 1;
            }

            putword(RWidth, fpGif);             /* screen descriptor */
            putword(RHeight, fpGif);

            i = 0x00;                   /* No, there is no color map */
            i |= (8-1)<<4;              /* OR in the color resolution (hardwired 8) */
            i |= (BitsPerPixel - 1);    /* OR in the # of bits per pixel */
            fputc(i,fpGif);

            fputc(Background,fpGif);    /* background color */
            fputc(0, fpGif);            /* future expansion byte */

            /*
             * If loop_times is 0 , put in the application extension to make
             * the gif anime loop indefinitely
             */
            if (time_out > 0) {
                fputc(0x21 , fpGif);
                fputc(0xFF , fpGif);
                fputc(11 , fpGif);
                fwrite("NETSCAPE2.0" , 1 , 11 , fpGif);
                fputc(3 , fpGif);
                fputc(1 , fpGif);
                fputc(0 , fpGif);
                fputc(0 , fpGif);
                fputc(0 , fpGif);
            }
        }

        if (n_images > 1) {
            /* write a graphic control block */
            fputc(0x21 , fpGif);
            fputc(0xF9 , fpGif);
            fputc(4 , fpGif);
            fputc(4 , fpGif);
            putword(time_out , fpGif);
            fputc(255, fpGif);
            fputc(0 , fpGif);
        }

        /*
         * Put Image Descriptor
         * Hardwiring Left Offset and Top Offset to 0x00
         */
        fputc(0x2c , fpGif);
        putword(0x00 , fpGif);
        putword(0x00  , fpGif);
        putword(RWidth   , fpGif);
        putword(RHeight  , fpGif);

        /* since we always have a local color palette ... */
        fputc((0x80 | (BitsPerPixel - 1)) , fpGif);

        for (i = 0; i < ColorMapSize; i++) {
            /* write out Global colormap */
            fputc(r1[i], fpGif);
            fputc(g1[i], fpGif);
            fputc(b1[i], fpGif);
        }

        fputc(InitCodeSize , fpGif);

        i = hdfWriteGIF(fpGif , Image , 0 , (int)dim_sizes[0] ,
                        (int)dim_sizes[1] , r1, g1 , b1 , pc2nc , 256 , 8 ,
                        BitsPerPixel);
        fputc(0x00, fpGif);		
        free(Image);
    }

    if (fputc(';',fpGif) == EOF) {
        /* Write GIF file terminator */
        fprintf(stderr , "Error!");
        return -1;
    }

    fclose(fpGif);

#if 0
    while(number_of_images--) {
        if (image_name_arr[number_of_images])
            free(image_name_arr[number_of_images]);
        if (pal_name_arr[number_of_images])
            free(pal_name_arr[number_of_images]);
    }
#endif  /* 0 */

    return 0;
}