a8b3e1f1243b34f150d0d7436bf4e91acbd8daf3
[swftools.git] / lib / modules / swfbits.c
1 /* swfbits.c
2
3    Bitmap functions (needs libjpeg) 
4
5    Extension module for the rfxswf library.
6    Part of the swftools package.
7
8    Copyright (c) 2000, 2001 Rainer Böhme <rfxswf@reflex-studio.de>
9  
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
23
24 #define OUTBUFFER_SIZE 0x8000
25
26 int swf_ImageHasAlpha(RGBA*img, int width, int height)
27 {
28     int len = width*height;
29     int t;
30     int hasalpha=0;
31     for(t=0;t<len;t++) {
32         if(img[t].a >= 4 && img[t].a < 0xfc)
33             return 2;
34         if(img[t].a < 4)
35             hasalpha=1;
36     }
37     return hasalpha;
38 }
39
40 int swf_ImageGetNumberOfPaletteEntries(RGBA*img, int width, int height, RGBA*palette)
41 {
42     int len = width*height;
43     int t;
44     int palsize = 0;
45     RGBA pal[512];
46     U32*pal32=(U32*)pal;
47     int palette_overflow = 0;
48     U32 lastcol32 = 0;
49
50     if(sizeof(RGBA)!=sizeof(U32))
51         fprintf(stderr, "rfxswf: sizeof(RGBA)!=sizeof(U32))");
52
53     lastcol32 = pal32[palsize++] = *(U32*)&img[0];
54
55     for(t=1;t<len;t++) {
56         RGBA col = img[t];
57         U32 col32 = *(U32*)&img[t];
58         int i;
59         if(col32==lastcol32)
60             continue;
61         for(i=0;i<palsize;i++) {
62             if(col32 == pal32[i])
63                 break;
64         }
65         if(i==palsize) {
66             if(palsize==512) {
67                 palette_overflow = 1;
68                 break;
69             }
70             pal32[palsize++] = col32;
71         }
72         lastcol32 = col32;
73     }
74     if(palette_overflow)
75         return width*height;
76     if(palette)
77         memcpy(palette, pal, palsize*sizeof(RGBA));
78     return palsize;
79 }
80
81 #ifdef HAVE_JPEGLIB
82
83 typedef struct _JPEGDESTMGR {
84     struct jpeg_destination_mgr mgr;
85     TAG *t;
86     JOCTET *buffer;
87     struct jpeg_compress_struct cinfo;
88     struct jpeg_error_mgr jerr;
89 } JPEGDESTMGR, *LPJPEGDESTMGR;
90
91 // Destination manager callbacks
92
93 static void RFXSWF_init_destination(j_compress_ptr cinfo)
94 {
95     JPEGDESTMGR *dmgr = (JPEGDESTMGR *) cinfo->dest;
96     dmgr->buffer = (JOCTET *) rfx_alloc(OUTBUFFER_SIZE);
97     dmgr->mgr.next_output_byte = dmgr->buffer;
98     dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
99 }
100
101 static boolean RFXSWF_empty_output_buffer(j_compress_ptr cinfo)
102 {
103     JPEGDESTMGR *dmgr = (JPEGDESTMGR *) cinfo->dest;
104     swf_SetBlock(dmgr->t, (U8 *) dmgr->buffer, OUTBUFFER_SIZE);
105     dmgr->mgr.next_output_byte = dmgr->buffer;
106     dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
107     return TRUE;
108 }
109
110 static void RFXSWF_term_destination(j_compress_ptr cinfo)
111 {
112     JPEGDESTMGR *dmgr = (JPEGDESTMGR *) cinfo->dest;
113     swf_SetBlock(dmgr->t, (U8 *) dmgr->buffer,
114                  OUTBUFFER_SIZE - dmgr->mgr.free_in_buffer);
115     rfx_free(dmgr->buffer);
116     dmgr->mgr.free_in_buffer = 0;
117 }
118
119 JPEGBITS *swf_SetJPEGBitsStart(TAG * t, int width, int height, int quality)
120 {
121     JPEGDESTMGR *jpeg;
122
123     // redirect compression lib output to local SWF Tag structure
124
125     jpeg = (JPEGDESTMGR *) rfx_calloc(sizeof(JPEGDESTMGR));
126
127     jpeg->cinfo.err = jpeg_std_error(&jpeg->jerr);
128
129     jpeg_create_compress(&jpeg->cinfo);
130
131     jpeg->mgr.init_destination = RFXSWF_init_destination;
132     jpeg->mgr.empty_output_buffer = RFXSWF_empty_output_buffer;
133     jpeg->mgr.term_destination = RFXSWF_term_destination;
134
135     jpeg->t = t;
136
137     jpeg->cinfo.dest = (struct jpeg_destination_mgr *) jpeg;
138
139     // init compression
140
141     jpeg->cinfo.image_width = width;
142     jpeg->cinfo.image_height = height;
143     jpeg->cinfo.input_components = 3;
144     jpeg->cinfo.in_color_space = JCS_RGB;
145
146     jpeg_set_defaults(&jpeg->cinfo);
147     jpeg_set_quality(&jpeg->cinfo, quality, TRUE);
148
149     // write tables to SWF
150
151     jpeg_write_tables(&jpeg->cinfo);
152
153     // compess image to SWF
154
155     jpeg_suppress_tables(&jpeg->cinfo, TRUE);
156     jpeg_start_compress(&jpeg->cinfo, FALSE);
157
158     return (JPEGBITS *) jpeg;
159 }
160
161 int swf_SetJPEGBitsLines(JPEGBITS * jpegbits, U8 ** data, int n)
162 {
163     JPEGDESTMGR *jpeg = (JPEGDESTMGR *) jpegbits;
164     if (!jpeg)
165         return -1;
166     jpeg_write_scanlines(&jpeg->cinfo, data, n);
167     return 0;
168 }
169
170 int swf_SetJPEGBitsLine(JPEGBITS * jpegbits, U8 * data)
171 {
172     return swf_SetJPEGBitsLines(jpegbits, &data, 1);
173 }
174
175 int swf_SetJPEGBitsFinish(JPEGBITS * jpegbits)
176 {
177     JPEGDESTMGR *jpeg = (JPEGDESTMGR *) jpegbits;
178     if (!jpeg)
179         return -1;
180     jpeg_finish_compress(&jpeg->cinfo);
181     rfx_free(jpeg);
182     return 0;
183 }
184
185 void swf_SetJPEGBits2(TAG * tag, U16 width, U16 height, RGBA * bitmap,
186                       int quality)
187 {
188     JPEGBITS *jpeg;
189     int y;
190     jpeg = swf_SetJPEGBitsStart(tag, width, height, quality);
191     for (y = 0; y < height; y++) {
192         U8 scanline[3 * width];
193         int x, p = 0;
194         for (x = 0; x < width; x++) {
195             scanline[p++] = bitmap[width * y + x].r;
196             scanline[p++] = bitmap[width * y + x].g;
197             scanline[p++] = bitmap[width * y + x].b;
198         }
199         swf_SetJPEGBitsLine(jpeg, scanline);
200     }
201     swf_SetJPEGBitsFinish(jpeg);
202 }
203
204 void swf_GetJPEGSize(char *fname, int *width, int *height)
205 {
206     struct jpeg_decompress_struct cinfo;
207     struct jpeg_error_mgr jerr;
208     FILE *fi;
209     *width = 0;
210     *height = 0;
211     cinfo.err = jpeg_std_error(&jerr);
212     jpeg_create_decompress(&cinfo);
213     if ((fi = fopen(fname, "rb")) == NULL) {
214         fprintf(stderr, "rfxswf: file open error\n");
215         return;
216     }
217     jpeg_stdio_src(&cinfo, fi);
218     jpeg_read_header(&cinfo, TRUE);
219     *width = cinfo.image_width;
220     *height = cinfo.image_height;
221     jpeg_destroy_decompress(&cinfo);
222     fclose(fi);
223 }
224
225 int swf_SetJPEGBits(TAG * t, char *fname, int quality)
226 {
227     struct jpeg_decompress_struct cinfo;
228     struct jpeg_error_mgr jerr;
229     JPEGBITS *out;
230     FILE *f;
231     U8 *scanline;
232
233     cinfo.err = jpeg_std_error(&jerr);
234     jpeg_create_decompress(&cinfo);
235
236     if ((f = fopen(fname, "rb")) == NULL) {
237         fprintf(stderr, "rfxswf: file open error\n");
238         return -1;
239     }
240
241     jpeg_stdio_src(&cinfo, f);
242     jpeg_read_header(&cinfo, TRUE);
243     jpeg_start_decompress(&cinfo);
244
245     out =
246         swf_SetJPEGBitsStart(t, cinfo.output_width, cinfo.output_height,
247                              quality);
248     scanline = (U8 *) rfx_alloc(4 * cinfo.output_width);
249
250     if (scanline) {
251         int y;
252         U8 *js = scanline;
253         if (cinfo.out_color_space == JCS_GRAYSCALE) {
254             for (y = 0; y < cinfo.output_height; y++) {
255                 int x;
256                 jpeg_read_scanlines(&cinfo, &js, 1);
257                 for (x = cinfo.output_width - 1; x >= 0; x--) {
258                     js[x * 3] = js[x * 3 + 1] = js[x * 3 + 2] = js[x];
259                 }
260                 swf_SetJPEGBitsLines(out, (U8 **) & js, 1);
261             }
262         } else if (cinfo.out_color_space == JCS_RGB) {
263             for (y = 0; y < cinfo.output_height; y++) {
264                 jpeg_read_scanlines(&cinfo, &js, 1);
265                 swf_SetJPEGBitsLines(out, (U8 **) & js, 1);
266             }
267         } else if (cinfo.out_color_space == JCS_YCCK) {
268             //FIXME
269             fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
270             return -1;
271         } else if (cinfo.out_color_space == JCS_YCbCr) {
272             for (y = 0; y < cinfo.output_height; y++) {
273                 int x;
274                 for (x = 0; x < cinfo.output_width; x++) {
275                     int y = js[x * 3 + 0];
276                     int u = js[x * 3 + 1];
277                     int v = js[x * 3 + 1];
278                     js[x * 3 + 0] = y + ((360 * (v - 128)) >> 8);
279                     js[x * 3 + 1] =
280                         y - ((88 * (u - 128) + 183 * (v - 128)) >> 8);
281                     js[x * 3 + 2] = y + ((455 * (u - 128)) >> 8);
282                 }
283             }
284         } else if (cinfo.out_color_space == JCS_CMYK) {
285             for (y = 0; y < cinfo.output_height; y++) {
286                 int x;
287                 jpeg_read_scanlines(&cinfo, &js, 1);
288                 /* This routine seems to work for now-
289                    It's a mixture of 3 different
290                    CMYK->RGB conversion routines I found in the
291                    web. (which all produced garbage)
292                    I'm happily accepting suggestions. (mk) */
293                 for (x = 0; x < cinfo.output_width; x++) {
294                     int white = 255 - js[x * 4 + 3];
295                     js[x * 3 + 0] = white - ((js[x * 4] * white) >> 8);
296                     js[x * 3 + 1] = white - ((js[x * 4 + 1] * white) >> 8);
297                     js[x * 3 + 2] = white - ((js[x * 4 + 2] * white) >> 8);
298                 }
299                 swf_SetJPEGBitsLines(out, (U8 **) & js, 1);
300             }
301         }
302     }
303
304     swf_SetJPEGBitsFinish(out);
305     jpeg_finish_decompress(&cinfo);
306     fclose(f);
307
308     return 0;
309 }
310
311 /*  jpeg_source_mgr functions */
312 static void tag_init_source(struct jpeg_decompress_struct *cinfo)
313 {
314     TAG *tag = (TAG *) cinfo->client_data;
315     swf_SetTagPos(tag, 2);
316     cinfo->src->bytes_in_buffer = 0;
317 }
318 static boolean tag_fill_input_buffer(struct jpeg_decompress_struct *cinfo)
319 {
320     TAG *tag = (TAG *) cinfo->client_data;
321     if (tag->data[tag->pos + 0] == 0xff &&
322         tag->data[tag->pos + 1] == 0xd9 &&
323         tag->data[tag->pos + 2] == 0xff &&
324         tag->data[tag->pos + 3] == 0xd8) {
325         tag->pos += 4;
326     }
327     if (tag->pos >= tag->len) {
328         cinfo->src->next_input_byte = 0;
329         cinfo->src->bytes_in_buffer = 0;
330         return 0;
331     }
332     cinfo->src->next_input_byte = &tag->data[tag->pos];
333     cinfo->src->bytes_in_buffer = 1;    //tag->len - tag->pos;
334     tag->pos += 1;
335     return 1;
336 }
337 static void tag_skip_input_data(struct jpeg_decompress_struct *cinfo, long count)
338 {
339     TAG *tag = (TAG *) cinfo->client_data;
340     cinfo->src->next_input_byte = 0;
341     cinfo->src->bytes_in_buffer = 0;
342     tag->pos += count;
343 }
344 static boolean tag_resync_to_restart(struct jpeg_decompress_struct *cinfo, int desired)
345 {
346     return jpeg_resync_to_restart(cinfo, desired);
347 }
348 static void tag_term_source(struct jpeg_decompress_struct *cinfo)
349 {
350     TAG *tag = (TAG *) cinfo->client_data;
351 }
352 RGBA *swf_JPEG2TagToImage(TAG * tag, int *width, int *height)
353 {
354     struct jpeg_decompress_struct cinfo;
355     struct jpeg_error_mgr jerr;
356     struct jpeg_source_mgr mgr;
357     RGBA *dest;
358     int y;
359     *width = 0;
360     *height = 0;
361
362     if (tag->id == ST_DEFINEBITSJPEG) {
363         fprintf(stderr,
364                 "rfxswf: extracting from definebitsjpeg not yet supported");
365         return 0;
366     }
367     if (tag->id == ST_DEFINEBITSJPEG3) {
368         fprintf(stderr,
369                 "rfxswf: extracting from definebitsjpeg3 not yet supported");
370         return 0;
371     }
372
373     cinfo.err = jpeg_std_error(&jerr);
374     jpeg_create_decompress(&cinfo);
375
376     cinfo.client_data = (void *) tag;
377     cinfo.src = &mgr;
378     cinfo.src->init_source = tag_init_source;
379     cinfo.src->fill_input_buffer = tag_fill_input_buffer;
380     cinfo.src->skip_input_data = tag_skip_input_data;
381     cinfo.src->resync_to_restart = jpeg_resync_to_restart;
382     cinfo.src->term_source = tag_term_source;
383     cinfo.out_color_space = JCS_RGB;
384
385     jpeg_read_header(&cinfo, TRUE);
386     *width = cinfo.image_width;
387     *height = cinfo.image_height;
388     dest =
389         rfx_alloc(sizeof(RGBA) * cinfo.image_width * cinfo.image_height);
390
391     jpeg_start_decompress(&cinfo);
392     for (y = 0; y < cinfo.output_height; y++) {
393         RGBA *line = &dest[y * cinfo.image_width];
394         U8 *to = (U8 *) line;
395         int x;
396         jpeg_read_scanlines(&cinfo, &to, 1);
397         for (x = cinfo.output_width - 1; x >= 0; --x) {
398             int r = to[x * 3 + 0];
399             int g = to[x * 3 + 1];
400             int b = to[x * 3 + 2];
401             line[x].r = r;
402             line[x].g = g;
403             line[x].b = b;
404             line[x].a = 255;
405         }
406     }
407
408     jpeg_finish_decompress(&cinfo);
409
410     jpeg_destroy_decompress(&cinfo);
411     return dest;
412 }
413
414 #endif                          // HAVE_JPEGLIB
415
416 // Lossless compression texture based on zlib
417
418 #ifdef HAVE_ZLIB
419
420 int RFXSWF_deflate_wraper(TAG * t, z_stream * zs, boolean finish)
421 {
422     U8 *data = rfx_alloc(OUTBUFFER_SIZE);
423     zs->next_out = data;
424     zs->avail_out = OUTBUFFER_SIZE;
425     while (1) {
426         int status = deflate(zs, Z_NO_FLUSH);
427
428         if (status != Z_OK) {
429             fprintf(stderr, "rfxswf: zlib compression error (%i)\n", status);
430             rfx_free(data);
431             return status;
432         }
433
434         if (zs->next_out != data) {
435             swf_SetBlock(t, data, zs->next_out - data);
436             zs->next_out = data;
437             zs->avail_out = OUTBUFFER_SIZE;
438         }
439
440         if (zs->avail_in == 0)
441             break;
442     }
443
444     if (!finish) {
445         rfx_free(data);
446         return 0;
447     }
448
449     while (1) {
450         int status = deflate(zs, Z_FINISH);
451         if (status != Z_OK && status != Z_STREAM_END) {
452             fprintf(stderr, "rfxswf: zlib compression error (%i)\n", status);
453             rfx_free(data);
454             return status;
455         }
456
457         if (zs->next_out != data) {
458             swf_SetBlock(t, data, zs->next_out - data);
459             zs->next_out = data;
460             zs->avail_out = OUTBUFFER_SIZE;
461         }
462
463         if (status == Z_STREAM_END)
464             break;
465     }
466     rfx_free(data);
467     return 0;
468 }
469
470
471 int swf_SetLosslessBits(TAG * t, U16 width, U16 height, void *bitmap, U8 bitmap_flags)
472 {
473     int res = 0;
474     int bps;
475
476     switch (bitmap_flags) {
477     case BMF_8BIT:
478         return swf_SetLosslessBitsIndexed(t, width, height, bitmap, NULL, 256);
479     case BMF_16BIT:
480         bps = BYTES_PER_SCANLINE(sizeof(U16) * width);
481         break;
482     case BMF_32BIT:
483         bps = width * 4;
484         break;
485     default:
486         fprintf(stderr, "rfxswf: unknown bitmap type %d\n", bitmap_flags);
487         return -1;
488     }
489
490     swf_SetU8(t, bitmap_flags);
491     swf_SetU16(t, width);
492     swf_SetU16(t, height);
493
494     {
495         z_stream zs;
496
497         memset(&zs, 0x00, sizeof(z_stream));
498         zs.zalloc = Z_NULL;
499         zs.zfree = Z_NULL;
500
501         if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) == Z_OK) {
502             zs.avail_in = bps * height;
503             zs.next_in = bitmap;
504
505             if (RFXSWF_deflate_wraper(t, &zs, TRUE) < 0)
506                 res = -3;
507             deflateEnd(&zs);
508
509         } else
510             res = -3;           // zlib error
511     }
512     return res;
513 }
514
515 int swf_SetLosslessBitsIndexed(TAG * t, U16 width, U16 height, U8 * bitmap, RGBA * palette, U16 ncolors)
516 {
517     RGBA *pal = palette;
518     int bps = BYTES_PER_SCANLINE(width);
519     int res = 0;
520
521     if (!pal)                   // create default palette for grayscale images
522     {
523         int i;
524         pal = rfx_alloc(256 * sizeof(RGBA));
525         for (i = 0; i < 256; i++) {
526             pal[i].r = pal[i].g = pal[i].b = i;
527             pal[i].a = 0xff;
528         }
529         ncolors = 256;
530     }
531
532     if ((ncolors < 2) || (ncolors > 256) || (!t)) {
533         fprintf(stderr, "rfxswf: unsupported number of colors: %d\n",
534                 ncolors);
535         return -1;              // parameter error
536     }
537
538     swf_SetU8(t, BMF_8BIT);
539     swf_SetU16(t, width);
540     swf_SetU16(t, height);
541     swf_SetU8(t, ncolors - 1);  // number of pal entries
542
543     {
544         z_stream zs;
545
546         memset(&zs, 0x00, sizeof(z_stream));
547         zs.zalloc = Z_NULL;
548         zs.zfree = Z_NULL;
549
550         if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) == Z_OK) {
551             U8 *zpal;           // compress palette
552             if ((zpal = rfx_alloc(ncolors * 4))) {
553                 U8 *pp = zpal;
554                 int i;
555
556                 /* be careful with ST_DEFINEBITSLOSSLESS2, because
557                    the Flash player produces great bugs if you use too many
558                    alpha colors in your palette. The only sensible result that
559                    can be archeived is setting one color to r=0,b=0,g=0,a=0 to
560                    make transparent parts in sprites. That's the cause why alpha
561                    handling is implemented in lossless routines of rfxswf.
562
563                    Indeed: I haven't understood yet how flash player handles
564                    alpha values different from 0 and 0xff in lossless bitmaps...
565                  */
566
567                 if (swf_GetTagID(t) == ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
568                 {
569                     for (i = 0; i < ncolors; i++) {
570                         pp[0] = pal[i].r;
571                         pp[1] = pal[i].g;
572                         pp[2] = pal[i].b;
573                         pp[3] = pal[i].a;
574                         pp += 4;
575                     }
576                     zs.avail_in = 4 * ncolors;
577                 } else {
578                     for (i = 0; i < ncolors; i++)       // pack RGBA structures to RGB 
579                     {
580                         pp[0] = pal[i].r;
581                         pp[1] = pal[i].g;
582                         pp[2] = pal[i].b;
583                         pp += 3;
584                     }
585                     zs.avail_in = 3 * ncolors;
586                 }
587
588                 zs.next_in = zpal;
589
590                 if (RFXSWF_deflate_wraper(t, &zs, FALSE) < 0)
591                     res = -3;
592
593                 // compress bitmap
594                 zs.next_in = bitmap;
595                 zs.avail_in = (bps * height * sizeof(U8));
596
597                 if (RFXSWF_deflate_wraper(t, &zs, TRUE) < 0)
598                     res = -3;
599
600                 deflateEnd(&zs);
601
602                 rfx_free(zpal);
603             } else
604                 res = -2;       // memory error
605         } else
606             res = -3;           // zlib error
607     }
608
609     if (!palette)
610         rfx_free(pal);
611
612     return res;
613 }
614
615 int swf_SetLosslessBitsGrayscale(TAG * t, U16 width, U16 height, U8 * bitmap)
616 {
617     return swf_SetLosslessBitsIndexed(t, width, height, bitmap, NULL, 256);
618 }
619
620 void swf_SetLosslessImage(TAG*tag, RGBA*data, int width, int height)
621 {
622     int hasalpha = swf_ImageHasAlpha(data, width, height);
623     if(!hasalpha) {
624         tag->id = ST_DEFINEBITSLOSSLESS;
625     } else {
626         tag->id = ST_DEFINEBITSLOSSLESS2;
627         /* TODO: premultiply alpha? */
628     }
629     int num = swf_ImageGetNumberOfPaletteEntries(data, width, height, 0);
630     if(num>1 && num<=256) {
631         RGBA*palette = (RGBA*)malloc(sizeof(RGBA)*num);
632         swf_ImageGetNumberOfPaletteEntries(data, width, height, palette);
633         int width2 = BYTES_PER_SCANLINE(width);
634         U8*data2 = (U8*)malloc(width2*height);
635         int len = width*height;
636         int x,y;
637         int r;
638         for(y=0;y<height;y++) {
639             RGBA*src = &data[width*y];
640             U8*dest = &data2[width2*y];
641             for(x=0;x<width;x++) {
642                 RGBA col = src[x];
643                 for(r=0;r<num;r++) {
644                     if(*(U32*)&col == *(U32*)&palette[r]) {
645                         dest[x] = r;
646                         break;
647                     }
648                 }
649                 if(r==num) {
650                     fprintf(stderr, "Internal error: Couldn't find color %02x%02x%02x%02x in palette (%d entries)\n",
651                             col.r, col.g, col.b, col.a, num);
652                     dest[x] = 0;
653                 }
654             }
655         }
656         swf_SetLosslessBitsIndexed(tag, width, height, data2, palette, num);
657         free(data2);
658         free(palette);
659     } else {
660         swf_SetLosslessBits(tag, width, height, data, BMF_32BIT);
661     }
662 }
663
664 RGBA *swf_DefineLosslessBitsTagToImage(TAG * tag, int *dwidth, int *dheight)
665 {
666     int id, format, height, width, pos;
667     U32 datalen, datalen2;
668     int error;
669     int bpp = 1;
670     int cols = 0;
671     int pos2 = 0;
672     char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
673     int t, x, y;
674     RGBA *palette = 0;
675     U8 *data, *data2;
676     RGBA *dest;
677     if (tag->id != ST_DEFINEBITSLOSSLESS &&
678         tag->id != ST_DEFINEBITSLOSSLESS2) {
679         fprintf(stderr, "rfxswf: Object %d is not a PNG picture!\n",
680                 GET16(tag->data));
681         return 0;
682     }
683     swf_SetTagPos(tag, 0);
684     id = swf_GetU16(tag);
685     format = swf_GetU8(tag);
686     if (format == 3)
687         bpp = 8;
688     if (format == 4)
689         bpp = 16;
690     if (format == 5)
691         bpp = 32;
692     if (format != 3 && format != 5) {
693         if (format == 4)
694             fprintf(stderr,
695                     "rfxswf: Can't handle 16-bit palette images yet (image %d)\n",
696                     id);
697         else
698             fprintf(stderr, "rfxswf: Unknown image type %d in image %d\n",
699                     format, id);
700         return 0;
701     }
702     *dwidth = width = swf_GetU16(tag);
703     *dheight = height = swf_GetU16(tag);
704
705     dest = rfx_alloc(sizeof(RGBA) * width * height);
706
707     if (format == 3)
708         cols = swf_GetU8(tag) + 1;
709     else
710         cols = 0;
711
712     data = 0;
713     datalen = (width * height * bpp / 8 + cols * 8);
714     do {
715         if (data)
716             rfx_free(data);
717         datalen += 4096;
718         data = rfx_alloc(datalen);
719         error =
720             uncompress(data, &datalen, &tag->data[tag->pos],
721                        tag->len - tag->pos);
722     } while (error == Z_BUF_ERROR);
723     if (error != Z_OK) {
724         fprintf(stderr, "rfxswf: Zlib error %d (image %d)\n", error, id);
725         return 0;
726     }
727     pos = 0;
728
729     if (cols) {
730         palette = (RGBA *) rfx_alloc(cols * sizeof(RGBA));
731         for (t = 0; t < cols; t++) {
732             palette[t].r = data[pos++];
733             palette[t].g = data[pos++];
734             palette[t].b = data[pos++];
735             if (alpha) {
736                 palette[t].a = data[pos++];
737             }
738         }
739     }
740
741     for (y = 0; y < height; y++) {
742         int srcwidth = width * (bpp / 8);
743         if (bpp == 32) {
744             if (!alpha) {
745                 // 32 bit to 24 bit "conversion"
746                 for (x = 0; x < width; x++) {
747                     dest[pos2].r = data[pos + 1];
748                     dest[pos2].g = data[pos + 2];
749                     dest[pos2].b = data[pos + 3];
750                     dest[pos2].a = 255;
751                     pos2++;
752                     pos += 4;   //ignore padding byte
753                 }
754             } else {
755                 for (x = 0; x < width; x++) {
756                     /* TODO: un-premultiply alpha? */
757                     dest[pos2].r = data[pos + 1];
758                     dest[pos2].g = data[pos + 2];
759                     dest[pos2].b = data[pos + 3];
760                     dest[pos2].a = data[pos + 0];       //alpha
761                     pos2++;
762                     pos += 4;
763                 }
764             }
765         } else {
766             for (x = 0; x < srcwidth; x++) {
767                 dest[pos2] = palette[data[pos++]];
768                 pos2++;
769             }
770         }
771         pos += ((srcwidth + 3) & ~3) - srcwidth;        //align
772     }
773     if (palette)
774         rfx_free(palette);
775     rfx_free(data);
776     return dest;
777 }
778
779 #endif                          // HAVE_ZLIB
780
781 #if defined(HAVE_ZLIB) && defined(HAVE_JPEGLIB)
782 int swf_SetJPEGBits3(TAG * tag, U16 width, U16 height, RGBA * bitmap, int quality)
783 {
784     JPEGBITS *jpeg;
785     int y;
786     int pos;
787     int res = 0;
788     U8 *data;
789     z_stream zs;
790
791     pos = tag->len;
792     swf_SetU32(tag, 0);         //placeholder
793     jpeg = swf_SetJPEGBitsStart(tag, width, height, quality);
794     for (y = 0; y < height; y++) {
795         U8 scanline[3 * width];
796         int x, p = 0;
797         for (x = 0; x < width; x++) {
798             scanline[p++] = bitmap[width * y + x].r;
799             scanline[p++] = bitmap[width * y + x].g;
800             scanline[p++] = bitmap[width * y + x].b;
801         }
802         swf_SetJPEGBitsLine(jpeg, scanline);
803     }
804     swf_SetJPEGBitsFinish(jpeg);
805     PUT32(&tag->data[pos], tag->len - pos - 4);
806
807     data = rfx_alloc(OUTBUFFER_SIZE);
808     memset(&zs, 0x00, sizeof(z_stream));
809
810     if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
811         fprintf(stderr, "rfxswf: zlib compression failed");
812         return -3;
813     }
814
815     zs.next_out = data;
816     zs.avail_out = OUTBUFFER_SIZE;
817
818     for (y = 0; y < height; y++) {
819         U8 scanline[width];
820         int x, p = 0;
821         for (x = 0; x < width; x++) {
822             scanline[p++] = bitmap[width * y + x].a;
823         }
824         zs.avail_in = width;
825         zs.next_in = scanline;
826
827         while (1) {
828             if (deflate(&zs, Z_NO_FLUSH) != Z_OK) {
829                 fprintf(stderr, "rfxswf: zlib compression failed");
830                 return -4;
831             }
832             if (zs.next_out != data) {
833                 swf_SetBlock(tag, data, zs.next_out - data);
834                 zs.next_out = data;
835                 zs.avail_out = OUTBUFFER_SIZE;
836             }
837             if (!zs.avail_in) {
838                 break;
839             }
840         }
841     }
842
843     while (1) {
844         int ret = deflate(&zs, Z_FINISH);
845         if (ret != Z_OK && ret != Z_STREAM_END) {
846             fprintf(stderr, "rfxswf: zlib compression failed");
847             return -5;
848         }
849         if (zs.next_out != data) {
850             swf_SetBlock(tag, data, zs.next_out - data);
851             zs.next_out = data;
852             zs.avail_out = OUTBUFFER_SIZE;
853         }
854         if (ret == Z_STREAM_END) {
855             break;
856         }
857     }
858
859     deflateEnd(&zs);
860     rfx_free(data);
861     return 0;
862 }
863
864 TAG* swf_AddImage(TAG*tag, int bitid, RGBA*mem, int width, int height, int quality)
865 {
866     TAG *tag1 = 0, *tag2 = 0;
867     int has_alpha = swf_ImageHasAlpha(mem,width,height);
868
869     /* try lossless image */
870     tag1 = swf_InsertTag(0, /*ST_DEFINEBITSLOSSLESS1/2*/0);
871     swf_SetU16(tag1, bitid);
872     swf_SetLosslessImage(tag1, mem, width, height);
873
874     /* try jpeg image */
875     if(has_alpha) {
876         tag2 = swf_InsertTag(0, ST_DEFINEBITSJPEG3);
877         swf_SetU16(tag2, bitid);
878         swf_SetJPEGBits3(tag2, width, height, mem, quality);
879     } else {
880         tag2 = swf_InsertTag(0, ST_DEFINEBITSJPEG2);
881         swf_SetU16(tag2, bitid);
882         swf_SetJPEGBits2(tag2, width, height, mem, quality);
883     }
884
885     if(tag1 && tag1->len < tag2->len) {
886         /* use the zlib version- it's smaller */
887         tag1->prev = tag;
888         if(tag) tag->next = tag1;
889         tag = tag1;
890         swf_DeleteTag(tag2);
891     } else {
892         /* use the jpeg version- it's smaller */
893         tag2->prev = tag;
894         if(tag) tag->next = tag2;
895         tag = tag2;
896         swf_DeleteTag(tag1);
897     }
898     return tag;
899 }
900
901 #endif
902
903 RGBA *swf_ExtractImage(TAG * tag, int *dwidth, int *dheight)
904 {
905     RGBA *img;
906     if (tag->id == ST_DEFINEBITSJPEG ||
907         tag->id == ST_DEFINEBITSJPEG2 || tag->id == ST_DEFINEBITSJPEG3) {
908 #ifdef HAVE_JPEGLIB
909         return swf_JPEG2TagToImage(tag, dwidth, dheight);
910 #else
911         fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
912         return 0;
913 #endif
914     }
915     if (tag->id == ST_DEFINEBITSLOSSLESS ||
916         tag->id == ST_DEFINEBITSLOSSLESS2) {
917 #ifdef HAVE_ZLIB
918         return swf_DefineLosslessBitsTagToImage(tag, dwidth, dheight);
919 #else
920         fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
921         return 0;
922 #endif
923     }
924     fprintf(stderr, "rfxswf: Error: Invalid tag (%d, %s)", tag->id,
925             swf_TagGetName(tag));
926     return 0;
927 }
928
929 #undef OUTBUFFER_SIZE
930
931
932 void swf_RemoveJPEGTables(SWF * swf)
933 {
934     TAG *tag = swf->firstTag;
935     TAG *tables_tag = 0;
936     while (tag) {
937         if (tag->id == ST_JPEGTABLES) {
938             tables_tag = tag;
939         }
940         tag = tag->next;
941     }
942
943     if (!tables_tag)
944         return;
945
946     tag = swf->firstTag;
947     while (tag) {
948         if (tag->id == ST_DEFINEBITSJPEG) {
949             void *data = rfx_alloc(tag->len);
950             swf_GetBlock(tag, data, tag->len);
951             swf_ResetTag(tag, ST_DEFINEBITSJPEG2);
952             swf_SetBlock(tag, tables_tag->data, tables_tag->len);
953             swf_SetBlock(tag, data, tag->len);
954             free(data);
955         }
956         tag = tag->next;
957     }
958     if (swf->firstTag == tables_tag)
959         swf->firstTag = tables_tag->next;
960     swf_DeleteTag(tables_tag);
961 }
962
963 typedef struct scale_lookup {
964     int pos;
965     unsigned int weight;
966 } scale_lookup_t;
967
968 typedef struct rgba_int {
969     unsigned int r,g,b,a;
970 } rgba_int_t;
971
972 static int bicubic = 0;
973
974 static scale_lookup_t**make_scale_lookup(int width, int newwidth)
975 {
976     scale_lookup_t*lookupx = malloc((width>newwidth?width:newwidth)*2*sizeof(scale_lookup_t));
977     scale_lookup_t**lblockx = (scale_lookup_t**)malloc((newwidth+1)*sizeof(scale_lookup_t**));
978     double fx = ((double)width)/((double)newwidth);
979     double px = 0;
980     int x;
981     scale_lookup_t*p_x = lookupx;
982
983     if(newwidth<=width) {
984         for(x=0;x<newwidth;x++) {
985             lblockx[x] = p_x;
986             double ex = px + fx;
987             int fromx = (int)px;
988             int tox = (int)ex;
989             double rem = fromx+1-px;
990             int i = (int)(256/fx);
991             int xweight = (int)(rem*256/fx);
992             int xx;
993             int w = 0;
994             if(tox>=width) tox = width-1;
995             for(xx=fromx;xx<=tox;xx++) {
996                 if(xx==fromx && xx==tox) p_x->weight = 256;
997                 else if(xx==fromx) p_x->weight = xweight;
998                 else if(xx==tox) p_x->weight = 256-w;
999                 else p_x->weight = i;
1000                 w+=p_x->weight;
1001                 p_x->pos = xx;
1002                 p_x++;
1003             }
1004             px = ex;
1005         }
1006     } else {
1007         for(x=0;x<newwidth;x++) {
1008             lblockx[x] = p_x;
1009             int ix1 = (int)px;
1010             int ix2 = ((int)px)+1;
1011             if(ix2>=width) ix2=width-1;
1012             double r = px-ix1;
1013             if(bicubic)
1014                 r = -2*r*r*r+3*r*r;
1015             p_x[0].weight = (int)(256*(1-r));
1016             p_x[0].pos = ix1;
1017             p_x[1].weight = 256-p_x[0].weight;
1018             p_x[1].pos = ix2;
1019             p_x+=2;
1020             px += fx;
1021         }
1022     }
1023     lblockx[newwidth] = p_x;
1024     return lblockx;
1025 }
1026
1027 RGBA* swf_ImageScale(RGBA*data, int width, int height, int newwidth, int newheight)
1028 {
1029     if(newwidth<1 || newheight<1)
1030         return 0;
1031     int x,y;
1032     RGBA* newdata= (RGBA*)malloc(newwidth*newheight*sizeof(RGBA));
1033     scale_lookup_t *p, **lblockx,**lblocky;
1034     rgba_int_t*tmpline = (rgba_int_t*)malloc(width*sizeof(rgba_int_t));
1035   
1036     lblockx = make_scale_lookup(width, newwidth);
1037     lblocky = make_scale_lookup(height, newheight);
1038
1039     for(p=lblocky[0];p<lblocky[newheight];p++)
1040         p->pos*=width;
1041
1042     for(y=0;y<newheight;y++) {
1043         RGBA*destline = &newdata[y*newwidth];
1044         
1045         /* create lookup table for y */
1046         rgba_int_t*l = tmpline;
1047         scale_lookup_t*p_y;
1048         memset(tmpline, 0, width*sizeof(rgba_int_t));
1049         for(p_y=lblocky[y];p_y<lblocky[y+1];p_y++) {
1050             RGBA*line = &data[p_y->pos];
1051             scale_lookup_t*p_x;
1052             int weight = p_y->weight;
1053             for(x=0;x<width;x++) {
1054                 tmpline[x].r += line[x].r*weight;
1055                 tmpline[x].g += line[x].g*weight;
1056                 tmpline[x].b += line[x].b*weight;
1057                 tmpline[x].a += line[x].a*weight;
1058             }
1059         }
1060
1061         /* process x direction */
1062         scale_lookup_t*p_x = lblockx[0];
1063         for(x=0;x<newwidth;x++) {
1064             unsigned int r=0,g=0,b=0,a=0;
1065             scale_lookup_t*p_x_to = lblockx[x+1];
1066             do { 
1067                 rgba_int_t* col = &tmpline[p_x->pos];
1068                 unsigned int weight = p_x->weight;
1069                 r += col->r*weight;
1070                 g += col->g*weight;
1071                 b += col->b*weight;
1072                 a += col->a*weight;
1073                 p_x++;
1074             } while (p_x<p_x_to);
1075
1076             destline->r = r >> 16;
1077             destline->g = g >> 16;
1078             destline->b = b >> 16;
1079             destline->a = a >> 16;
1080            
1081             destline++;
1082         }
1083     }
1084     free(tmpline);
1085     free(*lblockx);
1086     free(lblockx);
1087     free(*lblocky);
1088     free(lblocky);
1089     return newdata;
1090 }
1091