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
 126   jpeg_stdio_src(&cinfo,f);
 127   jpeg_read_header(&cinfo, TRUE);
 128   jpeg_start_decompress(&cinfo);
 129
 130   out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
 131   scanline = (U8*)malloc(4*cinfo.output_width);
 132
 133   if (scanline)
 134   { int y;
 135     U8 * js = scanline;
 136     for (y=0;y<cinfo.output_height;y++)
 137     { jpeg_read_scanlines(&cinfo,&js,1);
 138       swf_SetJPEGBitsLines(out,(U8**)&js,1);
 139     }
 140   }
 141
 142   swf_SetJPEGBitsFinish(out);
 143   jpeg_finish_decompress(&cinfo);
 144   fclose(f);
 145
 146   return 0;
 147 }
 148
 149 #endif // _JPEGLIB_INCLUDED_
 150
 151 // Lossless compression texture based on zlib
 152
 153 #ifdef _ZLIB_INCLUDED_
 154
 155 int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,U8 * data,boolean finish)
 156 { while (1)
 157   { int status = deflate(zs,Z_SYNC_FLUSH);
 158
 159     if (zs->avail_out == 0)
 160     { swf_SetBlock(t,data,zs->next_out-data);
 161       zs->next_out = data;
 162       zs->avail_out = OUTBUFFER_SIZE;
 163     }
 164
 165     if (zs->avail_in==0)
 166     { if (finish) deflate(zs,Z_FINISH);
 167       break;
 168     }
 169
 170     if (status!=Z_OK)
 171     {
 172 #ifdef DEBUG_RFXSWF
 173       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 174 #endif
 175       return status;
 176     }
 177   }
 178   return 0;
 179 }
 180
 181 int swf_SetLosslessBits(TAG * t,U16 width,U16 height,void * bitmap,U8 bitmap_flags)
 182 { int res = 0;
 183   int bps;
 184   U8 * data;
 185
 186   switch (bitmap_flags)
 187   { case BMF_8BIT:
 188       return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 189     case BMF_16BIT:
 190       bps = BYTES_PER_SCANLINE(sizeof(U16)*width);
 191       break;
 192     case BMF_32BIT:
 193       bps = width*4;
 194       break;
 195     default:
 196       return -1;
 197   }
 198
 199   swf_SetU8(t,bitmap_flags);
 200   swf_SetU16(t,width);
 201   swf_SetU16(t,height);
 202
 203   if (data=malloc(OUTBUFFER_SIZE))
 204   { z_stream zs;
 205
 206     memset(&zs,0x00,sizeof(z_stream));
 207     zs.zalloc = Z_NULL;
 208     zs.zfree  = Z_NULL;
 209
 210     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 211     { zs.avail_in         = bps*height;
 212       zs.next_in          = bitmap;
 213       zs.next_out         = data;
 214       zs.avail_out        = OUTBUFFER_SIZE;
 215
 216       if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
 217       if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
 218
 219       deflateEnd(&zs);
 220
 221
 222     } else res = -3; // zlib error
 223     free(data);
 224   } else res = -2; // memory error
 225
 226   return res;
 227 }
 228
 229 int swf_SetLosslessBitsIndexed(TAG * t,U16 width,U16 height,U8 * bitmap,RGBA * palette,U16 ncolors)
 230 { RGBA * pal = palette;
 231   int bps = BYTES_PER_SCANLINE(width);
 232   U8 * data;
 233   int res = 0;
 234
 235   if (!pal)     // create default palette for grayscale images
 236   { int i;
 237     pal = malloc(256*sizeof(RGBA));
 238     for (i=0;i<256;i++) { pal[i].r = pal[i].g = pal[i].b = i; pal[i].a = 0xff;}
 239     ncolors = 256;
 240   }
 241
 242   if ((ncolors<2)||(ncolors>256)||(!t)) return -1; // parameter error
 243
 244   swf_SetU8(t,BMF_8BIT);
 245   swf_SetU16(t,width);
 246   swf_SetU16(t,height);
 247   swf_SetU8(t,ncolors-1); // number of pal entries
 248
 249   if (data=malloc(OUTBUFFER_SIZE))
 250   { z_stream zs;
 251
 252     memset(&zs,0x00,sizeof(z_stream));
 253     zs.zalloc = Z_NULL;
 254     zs.zfree  = Z_NULL;
 255
 256     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 257     { U8 * zpal;                    // compress palette
 258       if (zpal = malloc(ncolors*4))
 259       { U8 * pp = zpal;
 260         int i;
 261
 262     /* be careful with ST_DEFINEBITSLOSSLESS2, because
 263        the Flash player produces great bugs if you use too many
 264        alpha colors in your palette. The only sensible result that
 265        can be archeived is setting one color to r=0,b=0,g=0,a=0 to
 266        make transparent parts in sprites. That's the cause why alpha
 267        handling is implemented in lossless routines of rfxswf.
 268
 269        Indeed: I haven't understood yet how flash player handles
 270        alpha values different from 0 and 0xff in lossless bitmaps...
 271     */
 272
 273         if (swf_GetTagID(t)==ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
 274         { for (i=0;i<ncolors;i++)
 275           { pp[0] = pal[i].r;
 276             pp[1] = pal[i].g;
 277             pp[2] = pal[i].b;
 278             pp[3] = pal[i].a;
 279             pp+=4;
 280           }
 281           zs.avail_in = 4*ncolors;
 282         }
 283         else
 284         { for (i=0;i<ncolors;i++)         // pack RGBA structures to RGB
 285           { pp[0] = pal[i].r;
 286             pp[1] = pal[i].g;
 287             pp[2] = pal[i].b;
 288             pp+=3;
 289           }
 290           zs.avail_in         = 3*ncolors;
 291         }
 292
 293         zs.next_in          = zpal;
 294         zs.next_out         = data;
 295         zs.avail_out        = OUTBUFFER_SIZE;
 296
 297         if (RFXSWF_deflate_wraper(t,&zs,data,FALSE)<0) res = -3;
 298
 299                                     // compress bitmap
 300         zs.next_in = bitmap;
 301         zs.avail_in = (bps*height*sizeof(U8));
 302
 303         if (RFXSWF_deflate_wraper(t,&zs,data,TRUE)<0) res = -3;
 304
 305         deflateEnd(&zs);
 306
 307         if (zs.next_out>data) swf_SetBlock(t,data,zs.next_out-data);
 308
 309         free(zpal);
 310       } else res = -2; // memory error
 311     } else res = -3; // zlib error
 312     free(data);
 313   } else res = -2;
 314
 315   if (!palette) free(pal);
 316
 317   return res;
 318 }
 319
 320 int swf_SetLosslessBitsGrayscale(TAG * t,U16 width,U16 height,U8 * bitmap)
 321 { return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 322 }
 323
 324
 325 #endif // _ZLIB_INCLUDED_
 326
 327 #undef OUTBUFFER_SIZE
 328
 329