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 static void RFXSWF_init_destination(j_compress_ptr cinfo)
  39 { JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
  40   dmgr->buffer = (JOCTET*)rfx_alloc(OUTBUFFER_SIZE);
  41   dmgr->mgr.next_output_byte = dmgr->buffer;
  42   dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
  43 }
  44
  45 static 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 static 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   rfx_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 *)rfx_calloc(sizeof(JPEGDESTMGR));
  67
  68   jpeg->cinfo.err = jpeg_std_error(&jpeg->jerr);
  69
  70   jpeg_create_compress(&jpeg->cinfo);
  71
  72   jpeg->mgr.init_destination = RFXSWF_init_destination;
  73   jpeg->mgr.empty_output_buffer = RFXSWF_empty_output_buffer;
  74   jpeg->mgr.term_destination = RFXSWF_term_destination;
  75
  76   jpeg->t = t;
  77
  78   jpeg->cinfo.dest = (struct jpeg_destination_mgr *)jpeg;
  79
  80   // init compression
  81
  82   jpeg->cinfo.image_width  = width;
  83   jpeg->cinfo.image_height = height;
  84   jpeg->cinfo.input_components = 3;
  85   jpeg->cinfo.in_color_space = JCS_RGB;
  86
  87   jpeg_set_defaults(&jpeg->cinfo);
  88   jpeg_set_quality(&jpeg->cinfo,quality,TRUE);
  89
  90   // write tables to SWF
  91
  92   jpeg_write_tables(&jpeg->cinfo);
  93
  94   // compess image to SWF
  95
  96   jpeg_suppress_tables(&jpeg->cinfo, TRUE);
  97   jpeg_start_compress(&jpeg->cinfo, FALSE);
  98
  99   return (JPEGBITS *)jpeg;
 100 }
 101
 102 int swf_SetJPEGBitsLines(JPEGBITS * jpegbits,U8 ** data,int n)
 103 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
 104   if (!jpeg) return -1;
 105   jpeg_write_scanlines(&jpeg->cinfo,data,n);
 106   return 0;
 107 }
 108
 109 int swf_SetJPEGBitsLine(JPEGBITS * jpegbits,U8 * data)
 110 { return swf_SetJPEGBitsLines(jpegbits,&data,1);
 111 }
 112
 113 int swf_SetJPEGBitsFinish(JPEGBITS * jpegbits)
 114 { JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
 115   if (!jpeg) return -1;
 116   jpeg_finish_compress(&jpeg->cinfo);
 117   rfx_free(jpeg);
 118   return 0;
 119 }
 120
 121 void swf_SetJPEGBits2(TAG * tag,U16 width,U16 height,RGBA* bitmap, int quality)
 122 {
 123   JPEGBITS* jpeg;
 124   int y;
 125   jpeg = swf_SetJPEGBitsStart(tag,width,height,quality);
 126   for (y=0;y<height;y++)
 127   { U8 scanline[3*width];
 128     int x,p = 0;
 129     for (x=0;x<width;x++)
 130     { scanline[p++] = bitmap[width*y+x].r;
 131       scanline[p++] = bitmap[width*y+x].g;
 132       scanline[p++] = bitmap[width*y+x].b;
 133     }
 134     swf_SetJPEGBitsLine(jpeg,scanline);
 135   }
 136   swf_SetJPEGBitsFinish(jpeg);
 137 }
 138
 139 void swf_GetJPEGSize(char * fname, int*width, int*height)
 140 { struct jpeg_decompress_struct cinfo;
 141   struct jpeg_error_mgr jerr;
 142   FILE * fi;
 143   *width = 0;
 144   *height = 0;
 145   cinfo.err = jpeg_std_error(&jerr);
 146   jpeg_create_decompress(&cinfo);
 147   if ((fi=fopen(fname,"rb"))==NULL) {
 148       fprintf(stderr, "rfxswf: file open error\n");
 149       return;
 150   }
 151   jpeg_stdio_src(&cinfo, fi);
 152   jpeg_read_header(&cinfo, TRUE);
 153   *width = cinfo.image_width;
 154   *height = cinfo.image_height;
 155   jpeg_destroy_decompress(&cinfo);
 156   fclose(fi);
 157 }
 158
 159 int swf_SetJPEGBits(TAG * t,char * fname,int quality)
 160 { struct jpeg_decompress_struct cinfo;
 161   struct jpeg_error_mgr jerr;
 162   JPEGBITS * out;
 163   FILE * f;
 164   U8 * scanline;
 165
 166   cinfo.err = jpeg_std_error(&jerr);
 167   jpeg_create_decompress(&cinfo);
 168
 169   if ((f=fopen(fname,"rb"))==NULL) {
 170       fprintf(stderr, "rfxswf: file open error\n");
 171       return -1;
 172   }
 173
 174   jpeg_stdio_src(&cinfo,f);
 175   jpeg_read_header(&cinfo, TRUE);
 176   jpeg_start_decompress(&cinfo);
 177
 178   out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
 179   scanline = (U8*)rfx_alloc(4*cinfo.output_width);
 180
 181   if (scanline)
 182   { int y;
 183     U8 * js = scanline;
 184     if(cinfo.out_color_space == JCS_GRAYSCALE) {
 185         for (y=0;y<cinfo.output_height;y++)
 186         { int x;
 187           jpeg_read_scanlines(&cinfo,&js,1);
 188           for(x=cinfo.output_width-1;x>=0;x--) {
 189               js[x*3] = js[x*3+1] = js[x*3+2] = js[x];
 190           }
 191           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 192         }
 193     }
 194     else if(cinfo.out_color_space == JCS_RGB)
 195     {
 196         for (y=0;y<cinfo.output_height;y++)
 197         { jpeg_read_scanlines(&cinfo,&js,1);
 198           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 199         }
 200     }
 201     else if(cinfo.out_color_space == JCS_YCCK)
 202     {
 203         //FIXME
 204         fprintf(stderr, "Error: Can't convert YCCK to RGB.\n");
 205         return -1;
 206     }
 207     else if(cinfo.out_color_space == JCS_YCbCr)
 208     {
 209         for (y=0;y<cinfo.output_height;y++) {
 210           int x;
 211           for(x=0;x<cinfo.output_width;x++) {
 212               int y = js[x*3+0];
 213               int u = js[x*3+1];
 214               int v = js[x*3+1];
 215               js[x*3+0] = y + ((360*(v-128))>>8);
 216               js[x*3+1] = y - ((88*(u-128)+183*(v-128))>>8);
 217               js[x*3+2] = y + ((455 * (u-128))>>8);
 218           }
 219         }
 220     }
 221     else if(cinfo.out_color_space == JCS_CMYK)
 222     {
 223         for (y=0;y<cinfo.output_height;y++)
 224         { int x;
 225           jpeg_read_scanlines(&cinfo,&js,1);
 226           /* This routine seems to work for now-
 227              It's a mixture of 3 different
 228              CMYK->RGB conversion routines I found in the
 229              web. (which all produced garbage)
 230              I'm happily accepting suggestions. (mk)*/
 231           for(x=0;x<cinfo.output_width;x++) {
 232                 int white = 255 - js[x*4+3];
 233                 js[x*3+0] = white - ((js[x*4]*white)>>8);
 234                 js[x*3+1] = white - ((js[x*4+1]*white)>>8);
 235                 js[x*3+2] = white - ((js[x*4+2]*white)>>8);
 236           }
 237           swf_SetJPEGBitsLines(out,(U8**)&js,1);
 238         }
 239     }
 240   }
 241
 242   swf_SetJPEGBitsFinish(out);
 243   jpeg_finish_decompress(&cinfo);
 244   fclose(f);
 245
 246   return 0;
 247 }
 248
 249 /*  jpeg_source_mgr functions */
 250 static void tag_init_source(struct jpeg_decompress_struct *cinfo)
 251 {
 252     TAG*tag = (TAG*)cinfo->client_data;
 253     swf_SetTagPos(tag, 2);
 254     cinfo->src->bytes_in_buffer = 0;
 255 }
 256 static boolean tag_fill_input_buffer(struct jpeg_decompress_struct *cinfo)
 257 {
 258     TAG*tag = (TAG*)cinfo->client_data;
 259     if(tag->data[tag->pos+0] == 0xff &&
 260        tag->data[tag->pos+1] == 0xd9 &&
 261        tag->data[tag->pos+2] == 0xff &&
 262        tag->data[tag->pos+3] == 0xd8) {
 263         tag->pos += 4;
 264     }
 265     if(tag->pos >= tag->len) {
 266         cinfo->src->next_input_byte = 0;
 267         cinfo->src->bytes_in_buffer = 0;
 268         return 0;
 269     }
 270     cinfo->src->next_input_byte = &tag->data[tag->pos];
 271     cinfo->src->bytes_in_buffer = 1;//tag->len - tag->pos;
 272     tag->pos += 1;
 273     return 1;
 274 }
 275 static void tag_skip_input_data(struct jpeg_decompress_struct *cinfo, long count)
 276 {
 277     TAG*tag = (TAG*)cinfo->client_data;
 278     cinfo->src->next_input_byte = 0;
 279     cinfo->src->bytes_in_buffer = 0;
 280     tag->pos += count;
 281 }
 282 static boolean tag_resync_to_restart(struct jpeg_decompress_struct *cinfo, int desired)
 283 {
 284     return jpeg_resync_to_restart(cinfo, desired);
 285 }
 286 static void tag_term_source(struct jpeg_decompress_struct *cinfo)
 287 {
 288     TAG*tag = (TAG*)cinfo->client_data;
 289 }
 290 RGBA* swf_JPEG2TagToImage(TAG*tag, int*width, int*height)
 291 {
 292     struct jpeg_decompress_struct cinfo;
 293     struct jpeg_error_mgr jerr;
 294     struct jpeg_source_mgr mgr;
 295     RGBA * dest;
 296     *width = 0;
 297     *height = 0;
 298
 299     if(tag->id == ST_DEFINEBITSJPEG) {
 300         fprintf(stderr, "rfxswf: extracting from definebitsjpeg not yet supported");
 301         return 0;
 302     }
 303     if(tag->id == ST_DEFINEBITSJPEG3) {
 304         fprintf(stderr, "rfxswf: extracting from definebitsjpeg3 not yet supported");
 305         return 0;
 306     }
 307
 308     cinfo.err = jpeg_std_error(&jerr);
 309     jpeg_create_decompress(&cinfo);
 310
 311     cinfo.client_data = (void*)tag;
 312     cinfo.src = &mgr;
 313     cinfo.src->init_source = tag_init_source;
 314     cinfo.src->fill_input_buffer = tag_fill_input_buffer;
 315     cinfo.src->skip_input_data = tag_skip_input_data;
 316     cinfo.src->resync_to_restart = jpeg_resync_to_restart;
 317     cinfo.src->term_source = tag_term_source;
 318     cinfo.out_color_space = JCS_RGB;
 319
 320     jpeg_read_header(&cinfo, TRUE);
 321     *width = cinfo.image_width;
 322     *height = cinfo.image_height;
 323     dest = rfx_alloc(sizeof(RGBA)*cinfo.image_width*cinfo.image_height);
 324
 325     jpeg_start_decompress(&cinfo);
 326     int y;
 327     for (y=0;y<cinfo.output_height;y++) {
 328         RGBA* line = &dest[y*cinfo.image_width];
 329         U8* to = (U8*)line;
 330         int x;
 331         jpeg_read_scanlines(&cinfo,&to,1);
 332         for(x=cinfo.output_width-1;x>=0;--x) {
 333             int r = to[x*3+0];
 334             int g = to[x*3+1];
 335             int b = to[x*3+2];
 336             line[x].r = r;
 337             line[x].g = g;
 338             line[x].b = b;
 339             line[x].a = 255;
 340         }
 341     }
 342
 343     jpeg_finish_decompress(&cinfo);
 344
 345     jpeg_destroy_decompress(&cinfo);
 346     return dest;
 347 }
 348
 349
 350 #endif // HAVE_JPEGLIB
 351
 352 // Lossless compression texture based on zlib
 353
 354 #ifdef HAVE_ZLIB
 355
 356 int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,boolean finish)
 357 {
 358   U8*data=rfx_alloc(OUTBUFFER_SIZE);
 359   zs->next_out = data;
 360   zs->avail_out = OUTBUFFER_SIZE;
 361   while (1)
 362   { int status = deflate(zs,Z_NO_FLUSH);
 363
 364     if (status!=Z_OK)
 365     {
 366 #ifdef DEBUG_RFXSWF
 367       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 368 #endif
 369       rfx_free(data);
 370       return status;
 371     }
 372
 373     if (zs->next_out!=data)
 374     { swf_SetBlock(t,data,zs->next_out - data);
 375       zs->next_out = data;
 376       zs->avail_out = OUTBUFFER_SIZE;
 377     }
 378
 379     if (zs->avail_in==0)
 380       break;
 381   }
 382
 383   if(!finish) {
 384       rfx_free(data);
 385       return 0;
 386   }
 387
 388   while(1) {
 389     int status = deflate(zs,Z_FINISH);
 390     if (status!=Z_OK && status!=Z_STREAM_END)
 391     {
 392 #ifdef DEBUG_RFXSWF
 393       fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
 394 #endif
 395       rfx_free(data);
 396       return status;
 397     }
 398
 399     if (zs->next_out!=data)
 400     {
 401       swf_SetBlock(t,data,zs->next_out - data);
 402       zs->next_out = data;
 403       zs->avail_out = OUTBUFFER_SIZE;
 404     }
 405
 406     if(status == Z_STREAM_END)
 407         break;
 408   }
 409   rfx_free(data);
 410   return 0;
 411 }
 412
 413
 414 int swf_SetLosslessBits(TAG * t,U16 width,U16 height,void * bitmap,U8 bitmap_flags)
 415 { int res = 0;
 416   int bps;
 417
 418   switch (bitmap_flags)
 419   { case BMF_8BIT:
 420       return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 421     case BMF_16BIT:
 422       bps = BYTES_PER_SCANLINE(sizeof(U16)*width);
 423       break;
 424     case BMF_32BIT:
 425       bps = width*4;
 426       break;
 427     default:
 428       fprintf(stderr, "rfxswf: unknown bitmap type %d\n", bitmap_flags);
 429       return -1;
 430   }
 431
 432   swf_SetU8(t,bitmap_flags);
 433   swf_SetU16(t,width);
 434   swf_SetU16(t,height);
 435
 436   { z_stream zs;
 437
 438     memset(&zs,0x00,sizeof(z_stream));
 439     zs.zalloc = Z_NULL;
 440     zs.zfree  = Z_NULL;
 441
 442     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 443     { zs.avail_in         = bps*height;
 444       zs.next_in          = bitmap;
 445
 446       if (RFXSWF_deflate_wraper(t,&zs,TRUE)<0) res = -3;
 447       deflateEnd(&zs);
 448
 449     } else res = -3; // zlib error
 450   }
 451   return res;
 452 }
 453
 454 int swf_SetLosslessBitsIndexed(TAG * t,U16 width,U16 height,U8 * bitmap,RGBA * palette,U16 ncolors)
 455 { RGBA * pal = palette;
 456   int bps = BYTES_PER_SCANLINE(width);
 457   int res = 0;
 458
 459   if (!pal)     // create default palette for grayscale images
 460   { int i;
 461     pal = rfx_alloc(256*sizeof(RGBA));
 462     for (i=0;i<256;i++) { pal[i].r = pal[i].g = pal[i].b = i; pal[i].a = 0xff;}
 463     ncolors = 256;
 464   }
 465
 466   if ((ncolors<2)||(ncolors>256)||(!t)) {
 467       fprintf(stderr, "rfxswf: unsupported number of colors: %d\n", ncolors);
 468       return -1; // parameter error
 469   }
 470
 471   swf_SetU8(t,BMF_8BIT);
 472   swf_SetU16(t,width);
 473   swf_SetU16(t,height);
 474   swf_SetU8(t,ncolors-1); // number of pal entries
 475
 476   { z_stream zs;
 477
 478     memset(&zs,0x00,sizeof(z_stream));
 479     zs.zalloc = Z_NULL;
 480     zs.zfree  = Z_NULL;
 481
 482     if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
 483     { U8 * zpal;                    // compress palette
 484       if ((zpal = rfx_alloc(ncolors*4)))
 485       { U8 * pp = zpal;
 486         int i;
 487
 488     /* be careful with ST_DEFINEBITSLOSSLESS2, because
 489        the Flash player produces great bugs if you use too many
 490        alpha colors in your palette. The only sensible result that
 491        can be archeived is setting one color to r=0,b=0,g=0,a=0 to
 492        make transparent parts in sprites. That's the cause why alpha
 493        handling is implemented in lossless routines of rfxswf.
 494
 495        Indeed: I haven't understood yet how flash player handles
 496        alpha values different from 0 and 0xff in lossless bitmaps...
 497     */
 498
 499         if (swf_GetTagID(t)==ST_DEFINEBITSLOSSLESS2)  // have alpha channel?
 500         { for (i=0;i<ncolors;i++)
 501           { pp[0] = pal[i].r;
 502             pp[1] = pal[i].g;
 503             pp[2] = pal[i].b;
 504             pp[3] = pal[i].a;
 505             pp+=4;
 506           }
 507           zs.avail_in = 4*ncolors;
 508         }
 509         else
 510         { for (i=0;i<ncolors;i++)         // pack RGBA structures to RGB
 511           { pp[0] = pal[i].r;
 512             pp[1] = pal[i].g;
 513             pp[2] = pal[i].b;
 514             pp+=3;
 515           }
 516           zs.avail_in         = 3*ncolors;
 517         }
 518
 519         zs.next_in          = zpal;
 520
 521         if (RFXSWF_deflate_wraper(t,&zs,FALSE)<0) res = -3;
 522
 523                                     // compress bitmap
 524         zs.next_in = bitmap;
 525         zs.avail_in = (bps*height*sizeof(U8));
 526
 527         if (RFXSWF_deflate_wraper(t,&zs,TRUE)<0) res = -3;
 528
 529         deflateEnd(&zs);
 530
 531         rfx_free(zpal);
 532       } else res = -2; // memory error
 533     } else res = -3; // zlib error
 534   }
 535
 536   if (!palette) rfx_free(pal);
 537
 538   return res;
 539 }
 540
 541 int swf_SetLosslessBitsGrayscale(TAG * t,U16 width,U16 height,U8 * bitmap)
 542 { return swf_SetLosslessBitsIndexed(t,width,height,bitmap,NULL,256);
 543 }
 544
 545 RGBA* swf_DefineLosslessBitsTagToImage(TAG*tag, int*dwidth, int*dheight)
 546 {
 547     int id,format,height, width, pos;
 548     U32 datalen, datalen2;
 549     int error;
 550     int bpp=1;
 551     int cols=0;
 552     int pos2=0;
 553     char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
 554     int t,x,y;
 555     RGBA*palette = 0;
 556     U8*data,*data2;
 557     RGBA*dest;
 558     if(tag->id != ST_DEFINEBITSLOSSLESS &&
 559        tag->id != ST_DEFINEBITSLOSSLESS2) {
 560         fprintf(stderr, "rfxswf: Object %d is not a PNG picture!\n",GET16(tag->data));
 561         return 0;
 562     }
 563     swf_SetTagPos(tag, 0);
 564     id =swf_GetU16(tag);
 565     format = swf_GetU8(tag);
 566     if(format == 3) bpp = 8;
 567     if(format == 4) bpp = 16;
 568     if(format == 5) bpp = 32;
 569     if(format!=3 && format!=5) {
 570         if(format==4)
 571             fprintf(stderr, "rfxswf: Can't handle 16-bit palette images yet (image %d)\n",id);
 572         else
 573             fprintf(stderr, "rfxswf: Unknown image type %d in image %d\n", format, id);
 574         return 0;
 575     }
 576     *dwidth = width = swf_GetU16(tag);
 577     *dheight = height = swf_GetU16(tag);
 578
 579     dest = rfx_alloc(sizeof(RGBA)*width*height);
 580
 581     if(format == 3) cols = swf_GetU8(tag) + 1;
 582     else            cols = 0;
 583
 584     data = 0;
 585     datalen = (width*height*bpp/8+cols*8);
 586     do {
 587         if(data)
 588             rfx_free(data);
 589         datalen+=4096;
 590         data = rfx_alloc(datalen);
 591         error = uncompress (data, &datalen, &tag->data[tag->pos], tag->len-tag->pos);
 592     } while(error == Z_BUF_ERROR);
 593     if(error != Z_OK) {
 594         fprintf(stderr, "rfxswf: Zlib error %d (image %d)\n", error, id);
 595         return 0;
 596     }
 597     pos = 0;
 598
 599     if(cols) {
 600         palette = (RGBA*)rfx_alloc(cols*sizeof(RGBA));
 601         for(t=0;t<cols;t++) {
 602             palette[t].r = data[pos++];
 603             palette[t].g = data[pos++];
 604             palette[t].b = data[pos++];
 605             if(alpha) {
 606                 palette[t].a = data[pos++];
 607             }
 608         }
 609     }
 610
 611     for(y=0;y<height;y++) {
 612        int srcwidth = width * (bpp/8);
 613        if(bpp==32) {
 614            if(!alpha) {
 615                // 32 bit to 24 bit "conversion"
 616                for(x=0;x<width;x++) {
 617                    dest[pos2].r=data[pos+1];
 618                    dest[pos2].g=data[pos+2];
 619                    dest[pos2].b=data[pos+3];
 620                    dest[pos2].a=255;
 621                    pos2++;
 622                    pos+=4; //ignore padding byte
 623                }
 624            } else {
 625                for(x=0;x<width;x++) {
 626                    dest[pos2].r=data[pos+1];
 627                    dest[pos2].g=data[pos+2];
 628                    dest[pos2].b=data[pos+3];
 629                    dest[pos2].a=data[pos+0]; //alpha
 630                    pos2++;
 631                    pos+=4;
 632                }
 633            }
 634        } else {
 635            for(x=0;x<srcwidth;x++) {
 636                dest[pos2]=palette[data[pos++]];
 637                pos2++;
 638            }
 639        }
 640        pos+=((srcwidth+3)&~3)-srcwidth; //align
 641     }
 642     if(palette)
 643         rfx_free(palette);
 644     rfx_free(data);
 645     return dest;
 646 }
 647
 648 #endif // HAVE_ZLIB
 649
 650 #if defined(HAVE_ZLIB) && defined(HAVE_JPEGLIB)
 651 int swf_SetJPEGBits3(TAG * tag,U16 width,U16 height,RGBA* bitmap, int quality)
 652 {
 653   JPEGBITS* jpeg;
 654   int y;
 655   int pos;
 656   int res = 0;
 657   U8 * data;
 658   z_stream zs;
 659
 660   pos = tag->len;
 661   swf_SetU32(tag, 0); //placeholder
 662   jpeg = swf_SetJPEGBitsStart(tag,width,height,quality);
 663   for (y=0;y<height;y++)
 664   { U8 scanline[3*width];
 665     int x,p = 0;
 666     for (x=0;x<width;x++)
 667     { scanline[p++] = bitmap[width*y+x].r;
 668       scanline[p++] = bitmap[width*y+x].g;
 669       scanline[p++] = bitmap[width*y+x].b;
 670     }
 671     swf_SetJPEGBitsLine(jpeg,scanline);
 672   }
 673   swf_SetJPEGBitsFinish(jpeg);
 674   PUT32(&tag->data[pos], tag->len - pos - 4);
 675
 676   data=rfx_alloc(OUTBUFFER_SIZE);
 677   memset(&zs,0x00,sizeof(z_stream));
 678
 679   if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)!=Z_OK) {
 680       fprintf(stderr, "rfxswf: zlib compression failed");
 681       return -3;
 682   }
 683
 684   zs.next_out         = data;
 685   zs.avail_out        = OUTBUFFER_SIZE;
 686
 687   for (y=0;y<height;y++)
 688   { U8 scanline[width];
 689     int x,p = 0;
 690     for (x=0;x<width;x++) {
 691       scanline[p++] = bitmap[width*y+x].a;
 692     }
 693     zs.avail_in         = width;
 694     zs.next_in          = scanline;
 695
 696     while(1) {
 697         if(deflate(&zs, Z_NO_FLUSH) != Z_OK) {
 698             fprintf(stderr, "rfxswf: zlib compression failed");
 699             return -4;
 700         }
 701         if(zs.next_out != data) {
 702             swf_SetBlock(tag, data, zs.next_out - data);
 703             zs.next_out = data;
 704             zs.avail_out = OUTBUFFER_SIZE;
 705         }
 706         if(!zs.avail_in) {
 707             break;
 708         }
 709     }
 710   }
 711
 712   while(1) {
 713       int ret = deflate(&zs, Z_FINISH);
 714       if (ret != Z_OK &&
 715           ret != Z_STREAM_END)  {
 716           fprintf(stderr, "rfxswf: zlib compression failed");
 717           return -5;
 718       }
 719       if(zs.next_out != data) {
 720           swf_SetBlock(tag, data, zs.next_out - data);
 721           zs.next_out = data;
 722           zs.avail_out = OUTBUFFER_SIZE;
 723       }
 724       if (ret == Z_STREAM_END) {
 725           break;
 726       }
 727   }
 728
 729   deflateEnd(&zs);
 730   rfx_free(data);
 731   return 0;
 732 }
 733 #endif
 734
 735 RGBA* swf_ExtractImage(TAG*tag, int*dwidth, int*dheight)
 736 {
 737     RGBA*img;
 738     if(tag->id == ST_DEFINEBITSJPEG ||
 739        tag->id == ST_DEFINEBITSJPEG2 ||
 740        tag->id == ST_DEFINEBITSJPEG3) {
 741 #ifdef HAVE_JPEGLIB
 742         return swf_JPEG2TagToImage(tag, dwidth, dheight);
 743 #else
 744         fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
 745         return 0;
 746 #endif
 747     }
 748     if(tag->id == ST_DEFINEBITSLOSSLESS ||
 749        tag->id == ST_DEFINEBITSLOSSLESS2) {
 750 #ifdef HAVE_ZLIB
 751         return swf_DefineLosslessBitsTagToImage(tag, dwidth, dheight);
 752 #else
 753         fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
 754         return 0;
 755 #endif
 756     }
 757     fprintf(stderr, "rfxswf: Error: Invalid tag (%d, %s)", tag->id, swf_TagGetName(tag));
 758     return 0;
 759 }
 760
 761 #undef OUTBUFFER_SIZE
 762