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