fix advance values.
[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 file is distributed under the GPL, see file COPYING for details 
11
12 */
13
14 #define OUTBUFFER_SIZE 0x8000
15
16 #ifdef _JPEGLIB_INCLUDED_
17
18 typedef struct _JPEGDESTMGR
19 { struct jpeg_destination_mgr mgr;
20   TAG *  t;
21   JOCTET * buffer;
22   struct jpeg_compress_struct cinfo;
23   struct jpeg_error_mgr jerr;
24 } JPEGDESTMGR, * LPJPEGDESTMGR;
25
26 // Destination manager callbacks
27
28 void RFXSWF_init_destination(j_compress_ptr cinfo) 
29 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
30   dmgr->buffer = (JOCTET*)malloc(OUTBUFFER_SIZE);
31   dmgr->mgr.next_output_byte = dmgr->buffer;
32   dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
33 }
34
35 boolean RFXSWF_empty_output_buffer(j_compress_ptr cinfo)
36 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
37   swf_SetBlock(dmgr->t,(U8*)dmgr->buffer,OUTBUFFER_SIZE);
38   dmgr->mgr.next_output_byte = dmgr->buffer;
39   dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
40   return TRUE;
41 }
42
43 void RFXSWF_term_destination(j_compress_ptr cinfo) 
44 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
45   swf_SetBlock(dmgr->t,(U8*)dmgr->buffer,OUTBUFFER_SIZE-dmgr->mgr.free_in_buffer);
46   free(dmgr->buffer);
47   dmgr->mgr.free_in_buffer = 0;
48 }
49
50 JPEGBITS * swf_SetJPEGBitsStart(TAG * t,int width,int height,int quality)
51 {
52   JPEGDESTMGR * jpeg;
53         
54   // redirect compression lib output to local SWF Tag structure
55   
56   jpeg = (JPEGDESTMGR *)malloc(sizeof(JPEGDESTMGR));
57   if (!jpeg) return NULL;
58   
59   memset(jpeg,0x00,sizeof(JPEGDESTMGR));
60   jpeg->cinfo.err = jpeg_std_error(&jpeg->jerr);
61
62   jpeg_create_compress(&jpeg->cinfo);
63
64   jpeg->mgr.init_destination = RFXSWF_init_destination;
65   jpeg->mgr.empty_output_buffer = RFXSWF_empty_output_buffer;
66   jpeg->mgr.term_destination = RFXSWF_term_destination;
67       
68   jpeg->t = t;
69
70   jpeg->cinfo.dest = (struct jpeg_destination_mgr *)jpeg;
71
72   // init compression
73   
74   jpeg->cinfo.image_width  = width;
75   jpeg->cinfo.image_height = height;
76   jpeg->cinfo.input_components = 3;
77   jpeg->cinfo.in_color_space = JCS_RGB;
78
79   jpeg_set_defaults(&jpeg->cinfo);
80   jpeg_set_quality(&jpeg->cinfo,quality,TRUE);
81
82   // write tables to SWF
83   
84   jpeg_write_tables(&jpeg->cinfo);
85
86   // compess image to SWF
87    
88   jpeg_suppress_tables(&jpeg->cinfo, TRUE);
89   jpeg_start_compress(&jpeg->cinfo, FALSE);
90
91   return (JPEGBITS *)jpeg;
92 }
93
94 int swf_SetJPEGBitsLines(JPEGBITS * jpegbits,U8 ** data,int n)
95 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
96   if (!jpeg) return -1;
97   jpeg_write_scanlines(&jpeg->cinfo,data,n);
98   return 0;
99 }
100
101 int swf_SetJPEGBitsLine(JPEGBITS * jpegbits,U8 * data)
102 { return swf_SetJPEGBitsLines(jpegbits,&data,1);
103 }
104
105 int swf_SetJPEGBitsFinish(JPEGBITS * jpegbits)
106 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
107   if (!jpeg) return -1;
108   jpeg_finish_compress(&jpeg->cinfo);
109   free(jpeg);
110   return 0;
111 }
112
113 void swf_SetJPEGBits2(TAG * tag,U16 width,U16 height,RGBA* bitmap, int quality)
114 {
115   JPEGBITS* jpeg;
116   int y;
117   jpeg = swf_SetJPEGBitsStart(tag,width,height,quality);
118   for (y=0;y<height;y++)
119   { U8 scanline[3*width];
120     int x,p = 0;
121     for (x=0;x<width;x++) 
122     { scanline[p++] = bitmap[width*y+x].r;
123       scanline[p++] = bitmap[width*y+x].g;
124       scanline[p++] = bitmap[width*y+x].b;
125     }
126     swf_SetJPEGBitsLine(jpeg,scanline);
127   }
128   swf_SetJPEGBitsFinish(jpeg);
129 }
130
131 int swf_SetJPEGBits(TAG * t,char * fname,int quality)
132 { struct jpeg_decompress_struct cinfo;
133   struct jpeg_error_mgr jerr;
134   JPEGBITS * out;
135   FILE * f;
136   U8 * scanline;
137   
138   cinfo.err = jpeg_std_error(&jerr);
139   jpeg_create_decompress(&cinfo); 
140
141   if ((f=fopen(fname,"rb"))==NULL) return -1;
142
143   jpeg_stdio_src(&cinfo,f);
144   jpeg_read_header(&cinfo, TRUE);
145   jpeg_start_decompress(&cinfo);
146
147   out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
148   scanline = (U8*)malloc(4*cinfo.output_width);
149   
150   if (scanline) 
151   { int y;
152     U8 * js = scanline;
153     if(cinfo.out_color_space == JCS_GRAYSCALE) {
154         for (y=0;y<cinfo.output_height;y++)
155         { int x;
156           jpeg_read_scanlines(&cinfo,&js,1);
157           for(x=cinfo.output_width-1;x>=0;x--) {
158               js[x*3] = js[x*3+1] = js[x*3+2] = js[x];
159           }
160           swf_SetJPEGBitsLines(out,(U8**)&js,1);
161         }
162     }
163     else if(cinfo.out_color_space == JCS_RGB) 
164     {
165         for (y=0;y<cinfo.output_height;y++)
166         { jpeg_read_scanlines(&cinfo,&js,1);
167           swf_SetJPEGBitsLines(out,(U8**)&js,1);
168         }
169     }
170     else if(cinfo.out_color_space == JCS_YCCK) 
171     {
172         //FIXME
173         fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
174         return -1;
175     }
176     else if(cinfo.out_color_space == JCS_YCbCr) 
177     {
178         for (y=0;y<cinfo.output_height;y++) {
179           int x;
180           for(x=0;x<cinfo.output_width;x++) {
181               int y = js[x*3+0];
182               int u = js[x*3+1];
183               int v = js[x*3+1];
184               // untested:
185               js[x*3+0] = y + ((360*(v-128))>>8);
186               js[x*3+1] = y - ((88*(u-128)-183*(v-128))>>8);
187               js[x*3+2] = y + ((455 * (u-128))>>8);
188           }
189         }
190     }
191     else if(cinfo.out_color_space == JCS_CMYK) 
192     { 
193         for (y=0;y<cinfo.output_height;y++)
194         { int x;
195           jpeg_read_scanlines(&cinfo,&js,1);
196           /* This routine seems to work for now-
197              It's a mixture of 3 different
198              CMYK->RGB conversion routines I found in the
199              web. (which all produced garbage)
200              I'm happily accepting suggestions. (mk)*/
201           for(x=0;x<cinfo.output_width;x++) {
202                 int white = 255 - js[x*4+3];
203                 js[x*3+0] = white - ((js[x*4]*white)>>8);
204                 js[x*3+1] = white - ((js[x*4+1]*white)>>8);
205                 js[x*3+2] = white - ((js[x*4+2]*white)>>8);
206           }
207           swf_SetJPEGBitsLines(out,(U8**)&js,1);
208         }
209     }
210   }
211
212   swf_SetJPEGBitsFinish(out);
213   jpeg_finish_decompress(&cinfo);
214   fclose(f);
215   
216   return 0;
217 }
218
219 #endif // _JPEGLIB_INCLUDED_
220
221 // Lossless compression texture based on zlib
222
223 #ifdef _ZLIB_INCLUDED_
224
225 int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,U8 * data,boolean finish)
226 { while (1)
227   { int status = deflate(zs,Z_SYNC_FLUSH);
228
229     if (zs->avail_out == 0)
230     { swf_SetBlock(t,data,zs->next_out-data);
231       zs->next_out = data;
232       zs->avail_out = OUTBUFFER_SIZE;
233     }
234     
235     if (zs->avail_in==0)
236     { if (finish) deflate(zs,Z_FINISH);
237       break;
238     }
239
240     if (status!=Z_OK)
241     {
242 #ifdef DEBUG_RFXSWF
243       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
244 #endif
245       return status;
246     }
247   }
248   return 0;
249 }
250
251 int swf_SetLosslessBits(TAG * t,U16 width,U16 height,void * bitmap,U8 bitmap_flags)
252 { int res = 0;
253   int bps;
254   U8 * data;
255   
256   switch (bitmap_flags)
257   { case BMF_8BIT:
258       return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
259     case BMF_16BIT:
260       bps = BYTES_PER_SCANLINE(sizeof(U16)*width);
261       break;
262     case BMF_32BIT:
263       bps = width*4;
264       break;
265     default:
266       return -1;
267   }
268   
269   swf_SetU8(t,bitmap_flags);
270   swf_SetU16(t,width);
271   swf_SetU16(t,height);
272
273   if ((data=malloc(OUTBUFFER_SIZE)))
274   { z_stream zs;
275       
276     memset(&zs,0x00,sizeof(z_stream));
277     zs.zalloc = Z_NULL;
278     zs.zfree  = Z_NULL;
279
280     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
281     { zs.avail_in         = bps*height;
282       zs.next_in          = bitmap;
283       zs.next_out         = data;
284       zs.avail_out        = OUTBUFFER_SIZE;
285
286       if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
287       if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
288
289       deflateEnd(&zs);
290       
291       
292     } else res = -3; // zlib error
293     free(data);
294   } else res = -2; // memory error
295   
296   return res;
297 }
298
299 int swf_SetLosslessBitsIndexed(TAG * t,U16 width,U16 height,U8 * bitmap,RGBA * palette,U16 ncolors)
300 { RGBA * pal = palette;
301   int bps = BYTES_PER_SCANLINE(width);
302   U8 * data;
303   int res = 0;
304     
305   if (!pal)     // create default palette for grayscale images
306   { int i;
307     pal = malloc(256*sizeof(RGBA));
308     for (i=0;i<256;i++) { pal[i].r = pal[i].g = pal[i].b = i; pal[i].a = 0xff;}
309     ncolors = 256;
310   }
311   
312   if ((ncolors<2)||(ncolors>256)||(!t)) return -1; // parameter error
313
314   swf_SetU8(t,BMF_8BIT);
315   swf_SetU16(t,width);
316   swf_SetU16(t,height);
317   swf_SetU8(t,ncolors-1); // number of pal entries
318
319   if ((data=malloc(OUTBUFFER_SIZE)))
320   { z_stream zs;
321
322     memset(&zs,0x00,sizeof(z_stream));
323     zs.zalloc = Z_NULL;
324     zs.zfree  = Z_NULL;
325
326     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
327     { U8 * zpal;                    // compress palette
328       if ((zpal = malloc(ncolors*4)))
329       { U8 * pp = zpal;
330         int i;
331
332     /* be careful with ST_DEFINEBITSLOSSLESS2, because
333        the Flash player produces great bugs if you use too many
334        alpha colors in your palette. The only sensible result that
335        can be archeived is setting one color to r=0,b=0,g=0,a=0 to
336        make transparent parts in sprites. That's the cause why alpha
337        handling is implemented in lossless routines of rfxswf.
338
339        Indeed: I haven't understood yet how flash player handles
340        alpha values different from 0 and 0xff in lossless bitmaps...
341     */
342
343         if (swf_GetTagID(t)==ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
344         { for (i=0;i<ncolors;i++)         
345           { pp[0] = pal[i].r;
346             pp[1] = pal[i].g;
347             pp[2] = pal[i].b;
348             pp[3] = pal[i].a;
349             pp+=4; 
350           }
351           zs.avail_in = 4*ncolors;
352         }
353         else
354         { for (i=0;i<ncolors;i++)         // pack RGBA structures to RGB 
355           { pp[0] = pal[i].r;
356             pp[1] = pal[i].g;
357             pp[2] = pal[i].b;
358             pp+=3;
359           }
360           zs.avail_in         = 3*ncolors;
361         }
362
363         zs.next_in          = zpal;
364         zs.next_out         = data;
365         zs.avail_out        = OUTBUFFER_SIZE;
366
367         if (RFXSWF_deflate_wraper(t,&zs,data,FALSE)<0) res = -3;
368
369                                     // compress bitmap
370         zs.next_in = bitmap;
371         zs.avail_in = (bps*height*sizeof(U8));
372
373         if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
374
375         deflateEnd(&zs);
376
377         if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
378
379         free(zpal);
380       } else res = -2; // memory error
381     } else res = -3; // zlib error
382     free(data);
383   } else res = -2;
384   
385   if (!palette) free(pal);
386
387   return res;
388 }
389
390 int swf_SetLosslessBitsGrayscale(TAG * t,U16 width,U16 height,U8 * bitmap)
391 { return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
392 }
393
394
395 #endif // _ZLIB_INCLUDED_
396
397 #undef OUTBUFFER_SIZE
398
399