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 int swf_SetJPEGBits(TAG * t,char * fname,int quality)
 114 { struct jpeg_decompress_struct cinfo;
 115   struct jpeg_error_mgr jerr;
 116   JPEGBITS * out;
 117   FILE * f;
 118   U8 * scanline;
 119
 120   cinfo.err = jpeg_std_error(&jerr);
 121   jpeg_create_decompress(&cinfo);
 122
 123   if ((f=fopen(fname,"rb"))==NULL) return -1;
 124
 125   jpeg_stdio_src(&cinfo,f);
 126   jpeg_read_header(&cinfo, TRUE);
 127   jpeg_start_decompress(&cinfo);
 128
 129   out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
 130   scanline = (U8*)malloc(4*cinfo.output_width);
 131
 132   if (scanline)
 133   { int y;
 134     U8 * js = scanline;
 135     if(cinfo.out_color_space == JCS_GRAYSCALE) {
 136         for (y=0;y<cinfo.output_height;y++)
 137         { int x;
 138           jpeg_read_scanlines(&cinfo,&js,1);
 139           for(x=cinfo.output_width-1;x>=0;x--) {
 140               js[x*3] = js[x*3+1] = js[x*3+2] = js[x];
 141           }
 142           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 143         }
 144     }
 145     else if(cinfo.out_color_space == JCS_RGB)
 146     {
 147         for (y=0;y<cinfo.output_height;y++)
 148         { jpeg_read_scanlines(&cinfo,&js,1);
 149           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 150         }
 151     }
 152     else if(cinfo.out_color_space == JCS_YCCK)
 153     {
 154         //FIXME
 155         fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
 156         return -1;
 157     }
 158     else if(cinfo.out_color_space == JCS_YCbCr)
 159     {
 160         for (y=0;y<cinfo.output_height;y++) {
 161           int x;
 162           for(x=0;x<cinfo.output_width;x++) {
 163               int y = js[x*3+0];
 164               int u = js[x*3+1];
 165               int v = js[x*3+1];
 166               // untested:
 167               js[x*3+0] = y + ((360*(v-128))>>8);
 168               js[x*3+1] = y - ((88*(u-128)-183*(v-128))>>8);
 169               js[x*3+2] = y + ((455 * (u-128))>>8);
 170           }
 171         }
 172     }
 173     else if(cinfo.out_color_space == JCS_CMYK)
 174     {
 175         for (y=0;y<cinfo.output_height;y++)
 176         { int x;
 177           jpeg_read_scanlines(&cinfo,&js,1);
 178           /* This routine seems to work for now-
 179              It's a mixture of 3 different
 180              CMYK->RGB conversion routines I found in the
 181              web. (which all produced garbage)
 182              I'm happily accepting suggestions. (mk)*/
 183           for(x=0;x<cinfo.output_width;x++) {
 184                 int white = 255 - js[x*4+3];
 185                 js[x*3+0] = white - ((js[x*4]*white)>>8);
 186                 js[x*3+1] = white - ((js[x*4+1]*white)>>8);
 187                 js[x*3+2] = white - ((js[x*4+2]*white)>>8);
 188           }
 189           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 190         }
 191     }
 192   }
 193
 194   swf_SetJPEGBitsFinish(out);
 195   jpeg_finish_decompress(&cinfo);
 196   fclose(f);
 197
 198   return 0;
 199 }
 200
 201 #endif // _JPEGLIB_INCLUDED_
 202
 203 // Lossless compression texture based on zlib
 204
 205 #ifdef _ZLIB_INCLUDED_
 206
 207 int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,U8 * data,boolean finish)
 208 { while (1)
 209   { int status = deflate(zs,Z_SYNC_FLUSH);
 210
 211     if (zs->avail_out == 0)
 212     { swf_SetBlock(t,data,zs->next_out-data);
 213       zs->next_out = data;
 214       zs->avail_out = OUTBUFFER_SIZE;
 215     }
 216
 217     if (zs->avail_in==0)
 218     { if (finish) deflate(zs,Z_FINISH);
 219       break;
 220     }
 221
 222     if (status!=Z_OK)
 223     {
 224 #ifdef DEBUG_RFXSWF
 225       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 226 #endif
 227       return status;
 228     }
 229   }
 230   return 0;
 231 }
 232
 233 int swf_SetLosslessBits(TAG * t,U16 width,U16 height,void * bitmap,U8 bitmap_flags)
 234 { int res = 0;
 235   int bps;
 236   U8 * data;
 237
 238   switch (bitmap_flags)
 239   { case BMF_8BIT:
 240       return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 241     case BMF_16BIT:
 242       bps = BYTES_PER_SCANLINE(sizeof(U16)*width);
 243       break;
 244     case BMF_32BIT:
 245       bps = width*4;
 246       break;
 247     default:
 248       return -1;
 249   }
 250
 251   swf_SetU8(t,bitmap_flags);
 252   swf_SetU16(t,width);
 253   swf_SetU16(t,height);
 254
 255   if (data=malloc(OUTBUFFER_SIZE))
 256   { z_stream zs;
 257
 258     memset(&zs,0x00,sizeof(z_stream));
 259     zs.zalloc = Z_NULL;
 260     zs.zfree  = Z_NULL;
 261
 262     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 263     { zs.avail_in         = bps*height;
 264       zs.next_in          = bitmap;
 265       zs.next_out         = data;
 266       zs.avail_out        = OUTBUFFER_SIZE;
 267
 268       if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
 269       if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
 270
 271       deflateEnd(&zs);
 272
 273
 274     } else res = -3; // zlib error
 275     free(data);
 276   } else res = -2; // memory error
 277
 278   return res;
 279 }
 280
 281 int swf_SetLosslessBitsIndexed(TAG * t,U16 width,U16 height,U8 * bitmap,RGBA * palette,U16 ncolors)
 282 { RGBA * pal = palette;
 283   int bps = BYTES_PER_SCANLINE(width);
 284   U8 * data;
 285   int res = 0;
 286
 287   if (!pal)     // create default palette for grayscale images
 288   { int i;
 289     pal = malloc(256*sizeof(RGBA));
 290     for (i=0;i<256;i++) { pal[i].r = pal[i].g = pal[i].b = i; pal[i].a = 0xff;}
 291     ncolors = 256;
 292   }
 293
 294   if ((ncolors<2)||(ncolors>256)||(!t)) return -1; // parameter error
 295
 296   swf_SetU8(t,BMF_8BIT);
 297   swf_SetU16(t,width);
 298   swf_SetU16(t,height);
 299   swf_SetU8(t,ncolors-1); // number of pal entries
 300
 301   if (data=malloc(OUTBUFFER_SIZE))
 302   { z_stream zs;
 303
 304     memset(&zs,0x00,sizeof(z_stream));
 305     zs.zalloc = Z_NULL;
 306     zs.zfree  = Z_NULL;
 307
 308     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 309     { U8 * zpal;                    // compress palette
 310       if (zpal = malloc(ncolors*4))
 311       { U8 * pp = zpal;
 312         int i;
 313
 314     /* be careful with ST_DEFINEBITSLOSSLESS2, because
 315        the Flash player produces great bugs if you use too many
 316        alpha colors in your palette. The only sensible result that
 317        can be archeived is setting one color to r=0,b=0,g=0,a=0 to
 318        make transparent parts in sprites. That's the cause why alpha
 319        handling is implemented in lossless routines of rfxswf.
 320
 321        Indeed: I haven't understood yet how flash player handles
 322        alpha values different from 0 and 0xff in lossless bitmaps...
 323     */
 324
 325         if (swf_GetTagID(t)==ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
 326         { for (i=0;i<ncolors;i++)
 327           { pp[0] = pal[i].r;
 328             pp[1] = pal[i].g;
 329             pp[2] = pal[i].b;
 330             pp[3] = pal[i].a;
 331             pp+=4;
 332           }
 333           zs.avail_in = 4*ncolors;
 334         }
 335         else
 336         { for (i=0;i<ncolors;i++)         // pack RGBA structures to RGB
 337           { pp[0] = pal[i].r;
 338             pp[1] = pal[i].g;
 339             pp[2] = pal[i].b;
 340             pp+=3;
 341           }
 342           zs.avail_in         = 3*ncolors;
 343         }
 344
 345         zs.next_in          = zpal;
 346         zs.next_out         = data;
 347         zs.avail_out        = OUTBUFFER_SIZE;
 348
 349         if (RFXSWF_deflate_wraper(t,&zs,data,FALSE)<0) res = -3;
 350
 351                                     // compress bitmap
 352         zs.next_in = bitmap;
 353         zs.avail_in = (bps*height*sizeof(U8));
 354
 355         if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
 356
 357         deflateEnd(&zs);
 358
 359         if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
 360
 361         free(zpal);
 362       } else res = -2; // memory error
 363     } else res = -3; // zlib error
 364     free(data);
 365   } else res = -2;
 366
 367   if (!palette) free(pal);
 368
 369   return res;
 370 }
 371
 372 int swf_SetLosslessBitsGrayscale(TAG * t,U16 width,U16 height,U8 * bitmap)
 373 { return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 374 }
 375
 376
 377 #endif // _ZLIB_INCLUDED_
 378
 379 #undef OUTBUFFER_SIZE
 380
 381