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 #ifdef HAVE_JPEGLIB
  27
  28 typedef struct _JPEGDESTMGR
  29 { struct jpeg_destination_mgr mgr;
  30   TAG *  t;
  31   JOCTET * buffer;
  32   struct jpeg_compress_struct cinfo;
  33   struct jpeg_error_mgr jerr;
  34 } JPEGDESTMGR, * LPJPEGDESTMGR;
  35
  36 // Destination manager callbacks
  37
  38 void RFXSWF_init_destination(j_compress_ptr cinfo)
  39 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
  40   dmgr->buffer = (JOCTET*)malloc(OUTBUFFER_SIZE);
  41   dmgr->mgr.next_output_byte = dmgr->buffer;
  42   dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
  43 }
  44
  45 boolean RFXSWF_empty_output_buffer(j_compress_ptr cinfo)
  46 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
  47   swf_SetBlock(dmgr->t,(U8*)dmgr->buffer,OUTBUFFER_SIZE);
  48   dmgr->mgr.next_output_byte = dmgr->buffer;
  49   dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
  50   return TRUE;
  51 }
  52
  53 void RFXSWF_term_destination(j_compress_ptr cinfo)
  54 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
  55   swf_SetBlock(dmgr->t,(U8*)dmgr->buffer,OUTBUFFER_SIZE-dmgr->mgr.free_in_buffer);
  56   free(dmgr->buffer);
  57   dmgr->mgr.free_in_buffer = 0;
  58 }
  59
  60 JPEGBITS * swf_SetJPEGBitsStart(TAG * t,int width,int height,int quality)
  61 {
  62   JPEGDESTMGR * jpeg;
  63
  64   // redirect compression lib output to local SWF Tag structure
  65
  66   jpeg = (JPEGDESTMGR *)malloc(sizeof(JPEGDESTMGR));
  67   if (!jpeg) return NULL;
  68
  69   memset(jpeg,0x00,sizeof(JPEGDESTMGR));
  70   jpeg->cinfo.err = jpeg_std_error(&jpeg->jerr);
  71
  72   jpeg_create_compress(&jpeg->cinfo);
  73
  74   jpeg->mgr.init_destination = RFXSWF_init_destination;
  75   jpeg->mgr.empty_output_buffer = RFXSWF_empty_output_buffer;
  76   jpeg->mgr.term_destination = RFXSWF_term_destination;
  77
  78   jpeg->t = t;
  79
  80   jpeg->cinfo.dest = (struct jpeg_destination_mgr *)jpeg;
  81
  82   // init compression
  83
  84   jpeg->cinfo.image_width  = width;
  85   jpeg->cinfo.image_height = height;
  86   jpeg->cinfo.input_components = 3;
  87   jpeg->cinfo.in_color_space = JCS_RGB;
  88
  89   jpeg_set_defaults(&jpeg->cinfo);
  90   jpeg_set_quality(&jpeg->cinfo,quality,TRUE);
  91
  92   // write tables to SWF
  93
  94   jpeg_write_tables(&jpeg->cinfo);
  95
  96   // compess image to SWF
  97
  98   jpeg_suppress_tables(&jpeg->cinfo, TRUE);
  99   jpeg_start_compress(&jpeg->cinfo, FALSE);
 100
 101   return (JPEGBITS *)jpeg;
 102 }
 103
 104 int swf_SetJPEGBitsLines(JPEGBITS * jpegbits,U8 ** data,int n)
 105 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
 106   if (!jpeg) return -1;
 107   jpeg_write_scanlines(&jpeg->cinfo,data,n);
 108   return 0;
 109 }
 110
 111 int swf_SetJPEGBitsLine(JPEGBITS * jpegbits,U8 * data)
 112 { return swf_SetJPEGBitsLines(jpegbits,&data,1);
 113 }
 114
 115 int swf_SetJPEGBitsFinish(JPEGBITS * jpegbits)
 116 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
 117   if (!jpeg) return -1;
 118   jpeg_finish_compress(&jpeg->cinfo);
 119   free(jpeg);
 120   return 0;
 121 }
 122
 123 void swf_SetJPEGBits2(TAG * tag,U16 width,U16 height,RGBA* bitmap, int quality)
 124 {
 125   JPEGBITS* jpeg;
 126   int y;
 127   jpeg = swf_SetJPEGBitsStart(tag,width,height,quality);
 128   for (y=0;y<height;y++)
 129   { U8 scanline[3*width];
 130     int x,p = 0;
 131     for (x=0;x<width;x++)
 132     { scanline[p++] = bitmap[width*y+x].r;
 133       scanline[p++] = bitmap[width*y+x].g;
 134       scanline[p++] = bitmap[width*y+x].b;
 135     }
 136     swf_SetJPEGBitsLine(jpeg,scanline);
 137   }
 138   swf_SetJPEGBitsFinish(jpeg);
 139 }
 140
 141 void swf_GetJPEGSize(char * fname, int*width, int*height)
 142 { struct jpeg_decompress_struct cinfo;
 143   struct jpeg_error_mgr jerr;
 144   FILE * fi;
 145   *width = 0;
 146   *height = 0;
 147   cinfo.err = jpeg_std_error(&jerr);
 148   jpeg_create_decompress(&cinfo);
 149   if ((fi=fopen(fname,"rb"))==NULL) {
 150       fprintf(stderr, "rfxswf: file open error\n");
 151       return;
 152   }
 153   jpeg_stdio_src(&cinfo, fi);
 154   jpeg_read_header(&cinfo, TRUE);
 155   *width = cinfo.image_width;
 156   *height = cinfo.image_height;
 157   jpeg_destroy_decompress(&cinfo);
 158   fclose(fi);
 159 }
 160
 161 int swf_SetJPEGBits(TAG * t,char * fname,int quality)
 162 { struct jpeg_decompress_struct cinfo;
 163   struct jpeg_error_mgr jerr;
 164   JPEGBITS * out;
 165   FILE * f;
 166   U8 * scanline;
 167
 168   cinfo.err = jpeg_std_error(&jerr);
 169   jpeg_create_decompress(&cinfo);
 170
 171   if ((f=fopen(fname,"rb"))==NULL) {
 172       fprintf(stderr, "rfxswf: file open error\n");
 173       return -1;
 174   }
 175
 176   jpeg_stdio_src(&cinfo,f);
 177   jpeg_read_header(&cinfo, TRUE);
 178   jpeg_start_decompress(&cinfo);
 179
 180   out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
 181   scanline = (U8*)malloc(4*cinfo.output_width);
 182
 183   if (scanline)
 184   { int y;
 185     U8 * js = scanline;
 186     if(cinfo.out_color_space == JCS_GRAYSCALE) {
 187         for (y=0;y<cinfo.output_height;y++)
 188         { int x;
 189           jpeg_read_scanlines(&cinfo,&js,1);
 190           for(x=cinfo.output_width-1;x>=0;x--) {
 191               js[x*3] = js[x*3+1] = js[x*3+2] = js[x];
 192           }
 193           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 194         }
 195     }
 196     else if(cinfo.out_color_space == JCS_RGB)
 197     {
 198         for (y=0;y<cinfo.output_height;y++)
 199         { jpeg_read_scanlines(&cinfo,&js,1);
 200           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 201         }
 202     }
 203     else if(cinfo.out_color_space == JCS_YCCK)
 204     {
 205         //FIXME
 206         fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
 207         return -1;
 208     }
 209     else if(cinfo.out_color_space == JCS_YCbCr)
 210     {
 211         for (y=0;y<cinfo.output_height;y++) {
 212           int x;
 213           for(x=0;x<cinfo.output_width;x++) {
 214               int y = js[x*3+0];
 215               int u = js[x*3+1];
 216               int v = js[x*3+1];
 217               js[x*3+0] = y + ((360*(v-128))>>8);
 218               js[x*3+1] = y - ((88*(u-128)+183*(v-128))>>8);
 219               js[x*3+2] = y + ((455 * (u-128))>>8);
 220           }
 221         }
 222     }
 223     else if(cinfo.out_color_space == JCS_CMYK)
 224     {
 225         for (y=0;y<cinfo.output_height;y++)
 226         { int x;
 227           jpeg_read_scanlines(&cinfo,&js,1);
 228           /* This routine seems to work for now-
 229              It's a mixture of 3 different
 230              CMYK->RGB conversion routines I found in the
 231              web. (which all produced garbage)
 232              I'm happily accepting suggestions. (mk)*/
 233           for(x=0;x<cinfo.output_width;x++) {
 234                 int white = 255 - js[x*4+3];
 235                 js[x*3+0] = white - ((js[x*4]*white)>>8);
 236                 js[x*3+1] = white - ((js[x*4+1]*white)>>8);
 237                 js[x*3+2] = white - ((js[x*4+2]*white)>>8);
 238           }
 239           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 240         }
 241     }
 242   }
 243
 244   swf_SetJPEGBitsFinish(out);
 245   jpeg_finish_decompress(&cinfo);
 246   fclose(f);
 247
 248   return 0;
 249 }
 250
 251 #endif // HAVE_JPEGLIB
 252
 253 // Lossless compression texture based on zlib
 254
 255 #ifdef HAVE_ZLIB
 256
 257 int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,boolean finish)
 258 {
 259   U8*data=malloc(OUTBUFFER_SIZE);
 260   zs->next_out = data;
 261   zs->avail_out = OUTBUFFER_SIZE;
 262   while (1)
 263   { int status = deflate(zs,Z_NO_FLUSH);
 264
 265     if (status!=Z_OK)
 266     {
 267 #ifdef DEBUG_RFXSWF
 268       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 269 #endif
 270       free(data);
 271       return status;
 272     }
 273
 274     if (zs->next_out!=data)
 275     { swf_SetBlock(t,data,zs->next_out - data);
 276       zs->next_out = data;
 277       zs->avail_out = OUTBUFFER_SIZE;
 278     }
 279
 280     if (zs->avail_in==0)
 281       break;
 282   }
 283
 284   if(!finish) {
 285       free(data);
 286       return 0;
 287   }
 288
 289   while(1) {
 290     int status = deflate(zs,Z_FINISH);
 291     if (status!=Z_OK && status!=Z_STREAM_END)
 292     {
 293 #ifdef DEBUG_RFXSWF
 294       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 295 #endif
 296       free(data);
 297       return status;
 298     }
 299
 300     if (zs->next_out!=data)
 301     {
 302       swf_SetBlock(t,data,zs->next_out - data);
 303       zs->next_out = data;
 304       zs->avail_out = OUTBUFFER_SIZE;
 305     }
 306
 307     if(status == Z_STREAM_END)
 308         break;
 309   }
 310   free(data);
 311   return 0;
 312 }
 313
 314
 315 int swf_SetLosslessBits(TAG * t,U16 width,U16 height,void * bitmap,U8 bitmap_flags)
 316 { int res = 0;
 317   int bps;
 318
 319   switch (bitmap_flags)
 320   { case BMF_8BIT:
 321       return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 322     case BMF_16BIT:
 323       bps = BYTES_PER_SCANLINE(sizeof(U16)*width);
 324       break;
 325     case BMF_32BIT:
 326       bps = width*4;
 327       break;
 328     default:
 329       fprintf(stderr, "rfxswf: unknown bitmap type %d\n", bitmap_flags);
 330       return -1;
 331   }
 332
 333   swf_SetU8(t,bitmap_flags);
 334   swf_SetU16(t,width);
 335   swf_SetU16(t,height);
 336
 337   { z_stream zs;
 338
 339     memset(&zs,0x00,sizeof(z_stream));
 340     zs.zalloc = Z_NULL;
 341     zs.zfree  = Z_NULL;
 342
 343     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 344     { zs.avail_in         = bps*height;
 345       zs.next_in          = bitmap;
 346
 347       if (RFXSWF_deflate_wraper(t,&zs,TRUE)<0) res = -3;
 348       deflateEnd(&zs);
 349
 350     } else res = -3; // zlib error
 351   }
 352   return res;
 353 }
 354
 355 int swf_SetLosslessBitsIndexed(TAG * t,U16 width,U16 height,U8 * bitmap,RGBA * palette,U16 ncolors)
 356 { RGBA * pal = palette;
 357   int bps = BYTES_PER_SCANLINE(width);
 358   int res = 0;
 359
 360   if (!pal)     // create default palette for grayscale images
 361   { int i;
 362     pal = malloc(256*sizeof(RGBA));
 363     for (i=0;i<256;i++) { pal[i].r = pal[i].g = pal[i].b = i; pal[i].a = 0xff;}
 364     ncolors = 256;
 365   }
 366
 367   if ((ncolors<2)||(ncolors>256)||(!t)) {
 368       fprintf(stderr, "rfxswf: unsupported number of colors: %d\n", ncolors);
 369       return -1; // parameter error
 370   }
 371
 372   swf_SetU8(t,BMF_8BIT);
 373   swf_SetU16(t,width);
 374   swf_SetU16(t,height);
 375   swf_SetU8(t,ncolors-1); // number of pal entries
 376
 377   { z_stream zs;
 378
 379     memset(&zs,0x00,sizeof(z_stream));
 380     zs.zalloc = Z_NULL;
 381     zs.zfree  = Z_NULL;
 382
 383     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 384     { U8 * zpal;                    // compress palette
 385       if ((zpal = malloc(ncolors*4)))
 386       { U8 * pp = zpal;
 387         int i;
 388
 389     /* be careful with ST_DEFINEBITSLOSSLESS2, because
 390        the Flash player produces great bugs if you use too many
 391        alpha colors in your palette. The only sensible result that
 392        can be archeived is setting one color to r=0,b=0,g=0,a=0 to
 393        make transparent parts in sprites. That's the cause why alpha
 394        handling is implemented in lossless routines of rfxswf.
 395
 396        Indeed: I haven't understood yet how flash player handles
 397        alpha values different from 0 and 0xff in lossless bitmaps...
 398     */
 399
 400         if (swf_GetTagID(t)==ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
 401         { for (i=0;i<ncolors;i++)
 402           { pp[0] = pal[i].r;
 403             pp[1] = pal[i].g;
 404             pp[2] = pal[i].b;
 405             pp[3] = pal[i].a;
 406             pp+=4;
 407           }
 408           zs.avail_in = 4*ncolors;
 409         }
 410         else
 411         { for (i=0;i<ncolors;i++)         // pack RGBA structures to RGB
 412           { pp[0] = pal[i].r;
 413             pp[1] = pal[i].g;
 414             pp[2] = pal[i].b;
 415             pp+=3;
 416           }
 417           zs.avail_in         = 3*ncolors;
 418         }
 419
 420         zs.next_in          = zpal;
 421
 422         if (RFXSWF_deflate_wraper(t,&zs,FALSE)<0) res = -3;
 423
 424                                     // compress bitmap
 425         zs.next_in = bitmap;
 426         zs.avail_in = (bps*height*sizeof(U8));
 427
 428         if (RFXSWF_deflate_wraper(t,&zs,TRUE)<0) res = -3;
 429
 430         deflateEnd(&zs);
 431
 432         free(zpal);
 433       } else res = -2; // memory error
 434     } else res = -3; // zlib error
 435   }
 436
 437   if (!palette) free(pal);
 438
 439   return res;
 440 }
 441
 442 int swf_SetLosslessBitsGrayscale(TAG * t,U16 width,U16 height,U8 * bitmap)
 443 { return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 444 }
 445
 446
 447 #endif // HAVE_ZLIB
 448
 449 #if defined(HAVE_ZLIB) && defined(HAVE_JPEGLIB)
 450 int swf_SetJPEGBits3(TAG * tag,U16 width,U16 height,RGBA* bitmap, int quality)
 451 {
 452   JPEGBITS* jpeg;
 453   int y;
 454   int pos;
 455   int res = 0;
 456   U8 * data;
 457   z_stream zs;
 458
 459   pos = tag->len;
 460   swf_SetU32(tag, 0); //placeholder
 461   jpeg = swf_SetJPEGBitsStart(tag,width,height,quality);
 462   for (y=0;y<height;y++)
 463   { U8 scanline[3*width];
 464     int x,p = 0;
 465     for (x=0;x<width;x++)
 466     { scanline[p++] = bitmap[width*y+x].r;
 467       scanline[p++] = bitmap[width*y+x].g;
 468       scanline[p++] = bitmap[width*y+x].b;
 469     }
 470     swf_SetJPEGBitsLine(jpeg,scanline);
 471   }
 472   swf_SetJPEGBitsFinish(jpeg);
 473   PUT32(&tag->data[pos], tag->len - pos - 4);
 474
 475   data=malloc(OUTBUFFER_SIZE);
 476   memset(&zs,0x00,sizeof(z_stream));
 477
 478   if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)!=Z_OK) {
 479       fprintf(stderr, "rfxswf: zlib compression failed");
 480       return -3;
 481   }
 482
 483   zs.next_out         = data;
 484   zs.avail_out        = OUTBUFFER_SIZE;
 485
 486   for (y=0;y<height;y++)
 487   { U8 scanline[width];
 488     int x,p = 0;
 489     for (x=0;x<width;x++) {
 490       scanline[p++] = bitmap[width*y+x].a;
 491     }
 492     zs.avail_in         = width;
 493     zs.next_in          = scanline;
 494
 495     while(1) {
 496         if(deflate(&zs, Z_NO_FLUSH) != Z_OK) {
 497             fprintf(stderr, "rfxswf: zlib compression failed");
 498             return -4;
 499         }
 500         if(zs.next_out != data) {
 501             swf_SetBlock(tag, data, zs.next_out - data);
 502             zs.next_out = data;
 503             zs.avail_out = OUTBUFFER_SIZE;
 504         }
 505         if(!zs.avail_in) {
 506             break;
 507         }
 508     }
 509   }
 510
 511   while(1) {
 512       int ret = deflate(&zs, Z_FINISH);
 513       if (ret != Z_OK &&
 514           ret != Z_STREAM_END)  {
 515           fprintf(stderr, "rfxswf: zlib compression failed");
 516           return -5;
 517       }
 518       if(zs.next_out != data) {
 519           swf_SetBlock(tag, data, zs.next_out - data);
 520           zs.next_out = data;
 521           zs.avail_out = OUTBUFFER_SIZE;
 522       }
 523       if (ret == Z_STREAM_END) {
 524           break;
 525       }
 526   }
 527
 528   deflateEnd(&zs);
 529   free(data);
 530   return 0;
 531 }
 532 #endif
 533
 534 #undef OUTBUFFER_SIZE
 535