along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include "../../config.h"
+#ifdef HAVE_ZLIB
+#include <zconf.h>
+#include <zlib.h>
+#endif
+#include <fcntl.h>
+#include <ctype.h>
+
+#ifdef HAVE_JPEGLIB
+#define HAVE_BOOLEAN
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <jpeglib.h>
+#ifdef __cplusplus
+}
+#endif
+#endif // HAVE_JPEGLIB
+
+#include "../rfxswf.h"
+
#define OUTBUFFER_SIZE 0x8000
int swf_ImageHasAlpha(RGBA*img, int width, int height)
int palette_overflow = 0;
U32 lastcol32 = 0;
- pal = malloc(65536*sizeof(U32));
+ pal = (U32*)malloc(65536*sizeof(U32));
memset(size, 0, sizeof(size));
if (!jpeg)
return -1;
jpeg_finish_compress(&jpeg->cinfo);
+ jpeg_destroy_compress(&jpeg->cinfo);
rfx_free(jpeg);
return 0;
}
-void swf_SetJPEGBits2(TAG * tag, U16 width, U16 height, RGBA * bitmap,
- int quality)
+#if defined(HAVE_JPEGLIB)
+void swf_SetJPEGBits2(TAG * tag, U16 width, U16 height, RGBA * bitmap, int quality)
{
JPEGBITS *jpeg;
int y;
jpeg = swf_SetJPEGBitsStart(tag, width, height, quality);
+ U8 *scanline = (U8*)rfx_alloc(3 * width);
for (y = 0; y < height; y++) {
- U8 scanline[3 * width];
int x, p = 0;
for (x = 0; x < width; x++) {
scanline[p++] = bitmap[width * y + x].r;
}
swf_SetJPEGBitsLine(jpeg, scanline);
}
+ rfx_free(scanline);
swf_SetJPEGBitsFinish(jpeg);
}
+#else
+void swf_SetJPEGBits2(TAG * tag, U16 width, U16 height, RGBA * bitmap, int quality)
+{
+ fprintf(stderr, "Error: swftools compiled without jpeglib\n");
+ return -1;
+}
+#endif
-void swf_GetJPEGSize(char *fname, int *width, int *height)
+void swf_GetJPEGSize(const char *fname, int *width, int *height)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
fclose(fi);
}
-int swf_SetJPEGBits(TAG * t, char *fname, int quality)
+int swf_SetJPEGBits(TAG * t, const char *fname, int quality)
{
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
perror(buf);
return;
}
- data2 = rfx_calloc(width*3);
+ data2 = (unsigned char *)rfx_calloc(width*3);
memset(&cinfo, 0, sizeof(cinfo));
memset(&jerr, 0, sizeof(jerr));
jpeg_read_header(&cinfo, TRUE);
*width = cinfo.image_width;
*height = cinfo.image_height;
- dest =
+ dest = (RGBA*)
rfx_alloc(sizeof(RGBA) * cinfo.image_width * cinfo.image_height);
jpeg_start_decompress(&cinfo);
int RFXSWF_deflate_wraper(TAG * t, z_stream * zs, boolean finish)
{
- U8 *data = rfx_alloc(OUTBUFFER_SIZE);
+ U8 *data = (U8*)rfx_alloc(OUTBUFFER_SIZE);
zs->next_out = data;
zs->avail_out = OUTBUFFER_SIZE;
while (1) {
switch (bitmap_flags) {
case BMF_8BIT:
- return swf_SetLosslessBitsIndexed(t, width, height, bitmap, NULL, 256);
+ return swf_SetLosslessBitsIndexed(t, width, height, (U8*)bitmap, NULL, 256);
case BMF_16BIT:
bps = BYTES_PER_SCANLINE(sizeof(U16) * width);
break;
if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) == Z_OK) {
zs.avail_in = bps * height;
- zs.next_in = bitmap;
+ zs.next_in = (Bytef *)bitmap;
if (RFXSWF_deflate_wraper(t, &zs, TRUE) < 0)
res = -3;
if (!pal) // create default palette for grayscale images
{
int i;
- pal = rfx_alloc(256 * sizeof(RGBA));
+ pal = (RGBA*)rfx_alloc(256 * sizeof(RGBA));
for (i = 0; i < 256; i++) {
pal[i].r = pal[i].g = pal[i].b = i;
pal[i].a = 0xff;
if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) == Z_OK) {
U8 *zpal; // compress palette
- if ((zpal = rfx_alloc(ncolors * 4))) {
+ if ((zpal = (U8*)rfx_alloc(ncolors * 4))) {
U8 *pp = zpal;
int i;
*dwidth = width = swf_GetU16(tag);
*dheight = height = swf_GetU16(tag);
- dest = rfx_alloc(sizeof(RGBA) * width * height);
+ dest = (RGBA*)rfx_alloc(sizeof(RGBA) * width * height);
if (format == 3)
cols = swf_GetU8(tag) + 1;
if (data)
rfx_free(data);
datalen += 4096;
- data = rfx_alloc(datalen);
+ data = (U8*)rfx_alloc(datalen);
error =
uncompress(data, &datalen, &tag->data[tag->pos],
tag->len - tag->pos);
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++) {
- U8 scanline[3 * width];
int x, p = 0;
for (x = 0; x < width; x++) {
//int ia = bitmap[width*y+x].a;
}
swf_SetJPEGBitsLine(jpeg, scanline);
}
+ rfx_free(scanline);
swf_SetJPEGBitsFinish(jpeg);
PUT32(&tag->data[pos], tag->len - pos - 4);
- data = rfx_alloc(OUTBUFFER_SIZE);
+ data = (U8*)rfx_alloc(OUTBUFFER_SIZE);
memset(&zs, 0x00, sizeof(z_stream));
if (deflateInit(&zs, Z_DEFAULT_COMPRESSION) != Z_OK) {
zs.next_out = data;
zs.avail_out = OUTBUFFER_SIZE;
+ scanline = (U8*)rfx_alloc(width);
for (y = 0; y < height; y++) {
- U8 scanline[width];
int x, p = 0;
for (x = 0; x < width; x++) {
scanline[p++] = bitmap[width * y + x].a;
}
}
+ rfx_free(scanline);
+
while (1) {
int ret = deflate(&zs, Z_FINISH);
if (ret != Z_OK && ret != Z_STREAM_END) {
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)
{
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_SetJPEGBits2(tag2, width, height, mem, quality);
}
+#endif
- if(quality>100 || (tag1 && tag1->len < tag2->len)) {
+ 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(tag2);
+ swf_DeleteTag(0, tag2);
} else {
/* use the jpeg version- it's smaller */
tag2->prev = tag;
if(tag) tag->next = tag2;
tag = tag2;
- swf_DeleteTag(tag1);
+ swf_DeleteTag(0, tag1);
}
return tag;
}
-#endif
-
RGBA *swf_ExtractImage(TAG * tag, int *dwidth, int *dheight)
{
RGBA *img;
if (tag->id == ST_DEFINEBITSJPEG) {
int len = tag->len;
void *data = rfx_alloc(len);
- swf_GetBlock(tag, data, tag->len);
+ swf_GetBlock(tag, (U8*)data, tag->len);
swf_ResetTag(tag, ST_DEFINEBITSJPEG2);
swf_SetBlock(tag, &((U8*)data)[0], 2); //id
swf_SetBlock(tag, tables_tag->data, tables_tag->len);
}
if (swf->firstTag == tables_tag)
swf->firstTag = tables_tag->next;
- swf_DeleteTag(tables_tag);
+ swf_DeleteTag(swf, tables_tag);
}
typedef struct scale_lookup {
static scale_lookup_t**make_scale_lookup(int width, int newwidth)
{
- scale_lookup_t*lookupx = malloc((width>newwidth?width:newwidth)*2*sizeof(scale_lookup_t));
+ scale_lookup_t*lookupx = (scale_lookup_t*)malloc((width>newwidth?width:newwidth)*2*sizeof(scale_lookup_t));
scale_lookup_t**lblockx = (scale_lookup_t**)malloc((newwidth+1)*sizeof(scale_lookup_t**));
double fx = ((double)width)/((double)newwidth);
double px = 0;