+RGBA *swf_DefineLosslessBitsTagToImage(TAG * tag, int *dwidth, int *dheight)
+{
+ int id, format, height, width, pos;
+ uLongf datalen, datalen2;
+ int error;
+ int bpp = 1;
+ int cols = 0;
+ int pos2 = 0;
+ char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
+ int t, x, y;
+ RGBA *palette = 0;
+ U8 *data, *data2;
+ RGBA *dest;
+ if (tag->id != ST_DEFINEBITSLOSSLESS &&
+ tag->id != ST_DEFINEBITSLOSSLESS2) {
+ fprintf(stderr, "rfxswf: Object %d is not a PNG picture!\n",
+ GET16(tag->data));
+ return 0;
+ }
+ swf_SetTagPos(tag, 0);
+ id = swf_GetU16(tag);
+ format = swf_GetU8(tag);
+ if (format == 3)
+ bpp = 8;
+ if (format == 4)
+ bpp = 16;
+ if (format == 5)
+ bpp = 32;
+ if (format != 3 && format != 5) {
+ if (format == 4)
+ fprintf(stderr,
+ "rfxswf: Can't handle 16-bit palette images yet (image %d)\n",
+ id);
+ else
+ fprintf(stderr, "rfxswf: Unknown image type %d in image %d\n",
+ format, id);
+ return 0;
+ }
+ *dwidth = width = swf_GetU16(tag);
+ *dheight = height = swf_GetU16(tag);
+
+ dest = (RGBA*)rfx_alloc(sizeof(RGBA) * width * height);
+
+ if (format == 3)
+ cols = swf_GetU8(tag) + 1;
+ else
+ cols = 0;
+
+ data = 0;
+ datalen = (width * height * bpp / 8 + cols * 8);
+ do {
+ if (data)
+ rfx_free(data);
+ datalen += 4096;
+ data = (U8*)rfx_alloc(datalen);
+ error =
+ uncompress(data, &datalen, &tag->data[tag->pos],
+ tag->len - tag->pos);
+ } while (error == Z_BUF_ERROR);
+ if (error != Z_OK) {
+ fprintf(stderr, "rfxswf: Zlib error %d (image %d)\n", error, id);
+ return 0;
+ }
+ pos = 0;
+
+ if (cols) {
+ palette = (RGBA *) rfx_alloc(cols * sizeof(RGBA));
+ for (t = 0; t < cols; t++) {
+ palette[t].r = data[pos++];
+ palette[t].g = data[pos++];
+ palette[t].b = data[pos++];
+ if (alpha) {
+ palette[t].a = data[pos++];
+ } else {
+ palette[t].a = 255;
+ }
+ }
+ }
+
+ for (y = 0; y < height; y++) {
+ int srcwidth = width * (bpp / 8);
+ if (bpp == 32) {
+ if (!alpha) {
+ // 32 bit to 24 bit "conversion"
+ for (x = 0; x < width; x++) {
+ dest[pos2].r = data[pos + 1];
+ dest[pos2].g = data[pos + 2];
+ dest[pos2].b = data[pos + 3];
+ dest[pos2].a = 255;
+ pos2++;
+ pos += 4; //ignore padding byte
+ }
+ } else {
+ for (x = 0; x < width; x++) {
+ /* remove premultiplication */
+ int alpha = data[pos+0];
+ if(alpha)
+ alpha = 0xff0000/alpha;
+ dest[pos2].r = (data[pos + 1]*alpha)>>16;
+ dest[pos2].g = (data[pos + 2]*alpha)>>16;
+ dest[pos2].b = (data[pos + 3]*alpha)>>16;
+ dest[pos2].a = data[pos + 0]; //alpha
+ pos2++;
+ pos += 4;
+ }
+ }
+ } else {
+ for (x = 0; x < srcwidth; x++) {
+ dest[pos2] = palette[data[pos++]];
+ pos2++;
+ }
+ }
+ pos += ((srcwidth + 3) & ~3) - srcwidth; //align
+ }
+ if (palette)
+ rfx_free(palette);
+ rfx_free(data);
+ return dest;
+}
+
+#endif // HAVE_ZLIB
+
+#if defined(HAVE_ZLIB) && defined(HAVE_JPEGLIB)
+
+/* expects bitmap to be non-premultiplied */
+int swf_SetJPEGBits3(TAG * tag, U16 width, U16 height, RGBA * bitmap, int quality)
+{
+ JPEGBITS *jpeg;
+ int y;
+ int pos;
+ int res = 0;
+ U8 *data;
+ z_stream zs;
+
+ pos = tag->len;
+ swf_SetU32(tag, 0); //placeholder
+ jpeg = swf_SetJPEGBitsStart(tag, width, height, quality);
+ U8 *scanline = (U8*)rfx_alloc(3 * width);
+ for (y = 0; y < height; y++) {
+ int x, p = 0;
+ for (x = 0; x < width; x++) {
+ //int ia = bitmap[width*y+x].a;
+ //if(ia) {
+ // /* remove premultiplication */
+ // ia = 0xff0000/ia;
+ //}
+ //scanline[p++] = (bitmap[width * y + x].r*ia)>>16;
+ //scanline[p++] = (bitmap[width * y + x].g*ia)>>16;
+ //scanline[p++] = (bitmap[width * y + x].b*ia)>>16;
+ scanline[p++] = bitmap[width * y + x].r;
+ scanline[p++] = bitmap[width * y + x].g;
+ scanline[p++] = bitmap[width * y + x].b;
+ }
+ swf_SetJPEGBitsLine(jpeg, scanline);
+ }
+ rfx_free(scanline);
+ swf_SetJPEGBitsFinish(jpeg);
+ PUT32(&tag->data[pos], tag->len - pos - 4);
+
+ data = (U8*)rfx_alloc(OUTBUFFER_SIZE);
+ memset(&zs, 0x00, sizeof(z_stream));
+
+ if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
+ fprintf(stderr, "rfxswf: zlib compression failed");
+ return -3;
+ }
+
+ zs.next_out = data;
+ zs.avail_out = OUTBUFFER_SIZE;
+
+ scanline = (U8*)rfx_alloc(width);
+ for (y = 0; y < height; y++) {
+ int x, p = 0;
+ for (x = 0; x < width; x++) {
+ scanline[p++] = bitmap[width * y + x].a;
+ }
+ zs.avail_in = width;
+ zs.next_in = scanline;
+
+ while (1) {
+ if (deflate(&zs, Z_NO_FLUSH) != Z_OK) {
+ fprintf(stderr, "rfxswf: zlib compression failed");
+ return -4;
+ }
+ if (zs.next_out != data) {
+ swf_SetBlock(tag, data, zs.next_out - data);
+ zs.next_out = data;
+ zs.avail_out = OUTBUFFER_SIZE;
+ }
+ if (!zs.avail_in) {
+ break;
+ }
+ }
+ }
+
+ rfx_free(scanline);
+
+ while (1) {
+ int ret = deflate(&zs, Z_FINISH);
+ if (ret != Z_OK && ret != Z_STREAM_END) {
+ fprintf(stderr, "rfxswf: zlib compression failed");
+ return -5;
+ }
+ if (zs.next_out != data) {
+ swf_SetBlock(tag, data, zs.next_out - data);
+ zs.next_out = data;
+ zs.avail_out = OUTBUFFER_SIZE;
+ }
+ if (ret == Z_STREAM_END) {
+ break;
+ }
+ }
+
+ deflateEnd(&zs);
+ rfx_free(data);
+ return 0;
+}
+
+#else
+int swf_SetJPEGBits3(TAG * tag, U16 width, U16 height, RGBA * bitmap, int quality)
+{
+ fprintf(stderr, "Error: swftools compiled without jpeglib\n");
+ return -1;
+}
+#endif
+
+
+/* expects mem to be non-premultiplied */
+TAG* swf_AddImage(TAG*tag, int bitid, RGBA*mem, int width, int height, int quality)
+{
+ TAG *tag1 = 0, *tag2 = 0;
+ int has_alpha = swf_ImageHasAlpha(mem,width,height);
+
+ /* try lossless image */
+ tag1 = swf_InsertTag(0, /*ST_DEFINEBITSLOSSLESS1/2*/0);
+ swf_SetU16(tag1, bitid);
+ swf_SetLosslessImage(tag1, mem, width, height);
+
+#if defined(HAVE_JPEGLIB)
+ /* try jpeg image */
+ if(has_alpha) {
+ tag2 = swf_InsertTag(0, ST_DEFINEBITSJPEG3);
+ swf_SetU16(tag2, bitid);
+ swf_SetJPEGBits3(tag2, width, height, mem, quality);
+ } else {
+ tag2 = swf_InsertTag(0, ST_DEFINEBITSJPEG2);
+ swf_SetU16(tag2, bitid);
+ swf_SetJPEGBits2(tag2, width, height, mem, quality);
+ }
+#endif
+
+ if(quality>100 || !tag2 || (tag1 && tag1->len < tag2->len)) {
+ /* use the zlib version- it's smaller */
+ tag1->prev = tag;
+ if(tag) tag->next = tag1;
+ tag = tag1;
+ swf_DeleteTag(0, tag2);
+ } else {
+ /* use the jpeg version- it's smaller */
+ tag2->prev = tag;
+ if(tag) tag->next = tag2;
+ tag = tag2;
+ swf_DeleteTag(0, tag1);
+ }
+ return tag;
+}
+
+RGBA *swf_ExtractImage(TAG * tag, int *dwidth, int *dheight)
+{
+ RGBA *img;
+
+ swf_SetTagPos(tag, 2); // id is 2 bytes
+
+ if (tag->id == ST_DEFINEBITSJPEG ||
+ tag->id == ST_DEFINEBITSJPEG2 || tag->id == ST_DEFINEBITSJPEG3) {
+#ifdef HAVE_JPEGLIB
+ return swf_JPEG2TagToImage(tag, dwidth, dheight);
+#else
+ fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
+ return 0;
+#endif
+ }
+ if (tag->id == ST_DEFINEBITSLOSSLESS ||
+ tag->id == ST_DEFINEBITSLOSSLESS2) {
+#ifdef HAVE_ZLIB
+ return swf_DefineLosslessBitsTagToImage(tag, dwidth, dheight);
+#else
+ fprintf(stderr, "rfxswf: Error: No JPEG library compiled in");
+ return 0;
+#endif
+ }
+ fprintf(stderr, "rfxswf: Error: Invalid tag (%d, %s)", tag->id,
+ swf_TagGetName(tag));
+ return 0;
+}