static void RFXSWF_init_destination(j_compress_ptr cinfo)
{ JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
- dmgr->buffer = (JOCTET*)malloc(OUTBUFFER_SIZE);
+ dmgr->buffer = (JOCTET*)rfx_alloc(OUTBUFFER_SIZE);
dmgr->mgr.next_output_byte = dmgr->buffer;
dmgr->mgr.free_in_buffer = OUTBUFFER_SIZE;
}
static void RFXSWF_term_destination(j_compress_ptr cinfo)
{ JPEGDESTMGR * dmgr = (JPEGDESTMGR *)cinfo->dest;
swf_SetBlock(dmgr->t,(U8*)dmgr->buffer,OUTBUFFER_SIZE-dmgr->mgr.free_in_buffer);
- free(dmgr->buffer);
+ rfx_free(dmgr->buffer);
dmgr->mgr.free_in_buffer = 0;
}
// redirect compression lib output to local SWF Tag structure
- jpeg = (JPEGDESTMGR *)malloc(sizeof(JPEGDESTMGR));
- if (!jpeg) return NULL;
+ jpeg = (JPEGDESTMGR *)rfx_calloc(sizeof(JPEGDESTMGR));
- memset(jpeg,0x00,sizeof(JPEGDESTMGR));
jpeg->cinfo.err = jpeg_std_error(&jpeg->jerr);
jpeg_create_compress(&jpeg->cinfo);
{ JPEGDESTMGR * jpeg = (JPEGDESTMGR *)jpegbits;
if (!jpeg) return -1;
jpeg_finish_compress(&jpeg->cinfo);
- free(jpeg);
+ rfx_free(jpeg);
return 0;
}
jpeg_start_decompress(&cinfo);
out = swf_SetJPEGBitsStart(t,cinfo.output_width,cinfo.output_height,quality);
- scanline = (U8*)malloc(4*cinfo.output_width);
+ scanline = (U8*)rfx_alloc(4*cinfo.output_width);
if (scanline)
{ int y;
struct jpeg_error_mgr jerr;
struct jpeg_source_mgr mgr;
RGBA * dest;
+ int y;
*width = 0;
*height = 0;
jpeg_read_header(&cinfo, TRUE);
*width = cinfo.image_width;
*height = cinfo.image_height;
- dest = malloc(sizeof(RGBA)*cinfo.image_width*cinfo.image_height);
+ dest = rfx_alloc(sizeof(RGBA)*cinfo.image_width*cinfo.image_height);
jpeg_start_decompress(&cinfo);
- int y;
for (y=0;y<cinfo.output_height;y++) {
RGBA* line = &dest[y*cinfo.image_width];
U8* to = (U8*)line;
int RFXSWF_deflate_wraper(TAG * t,z_stream * zs,boolean finish)
{
- U8*data=malloc(OUTBUFFER_SIZE);
+ U8*data=rfx_alloc(OUTBUFFER_SIZE);
zs->next_out = data;
zs->avail_out = OUTBUFFER_SIZE;
while (1)
#ifdef DEBUG_RFXSWF
fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
#endif
- free(data);
+ rfx_free(data);
return status;
}
}
if(!finish) {
- free(data);
+ rfx_free(data);
return 0;
}
#ifdef DEBUG_RFXSWF
fprintf(stderr,"rfxswf: zlib compression error (%i)\n",status);
#endif
- free(data);
+ rfx_free(data);
return status;
}
if(status == Z_STREAM_END)
break;
}
- free(data);
+ rfx_free(data);
return 0;
}
if (!pal) // create default palette for grayscale images
{ int i;
- pal = malloc(256*sizeof(RGBA));
+ pal = 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;}
ncolors = 256;
}
if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)==Z_OK)
{ U8 * zpal; // compress palette
- if ((zpal = malloc(ncolors*4)))
+ if ((zpal = rfx_alloc(ncolors*4)))
{ U8 * pp = zpal;
int i;
deflateEnd(&zs);
- free(zpal);
+ rfx_free(zpal);
} else res = -2; // memory error
} else res = -3; // zlib error
}
- if (!palette) free(pal);
+ if (!palette) rfx_free(pal);
return res;
}
int pos2=0;
char alpha = tag->id == ST_DEFINEBITSLOSSLESS2;
int t,x,y;
- RGBA*palette;
+ RGBA*palette = 0;
U8*data,*data2;
RGBA*dest;
if(tag->id != ST_DEFINEBITSLOSSLESS &&
*dwidth = width = swf_GetU16(tag);
*dheight = height = swf_GetU16(tag);
- dest = malloc(sizeof(RGBA)*width*height);
+ dest = rfx_alloc(sizeof(RGBA)*width*height);
if(format == 3) cols = swf_GetU8(tag) + 1;
else cols = 0;
datalen = (width*height*bpp/8+cols*8);
do {
if(data)
- free(data);
+ rfx_free(data);
datalen+=4096;
- data = malloc(datalen);
+ data = rfx_alloc(datalen);
error = uncompress (data, &datalen, &tag->data[tag->pos], tag->len-tag->pos);
} while(error == Z_BUF_ERROR);
if(error != Z_OK) {
return 0;
}
pos = 0;
-
- palette = (RGBA*)malloc(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++];
- }
+
+ 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++];
+ }
+ }
}
for(y=0;y<height;y++) {
pos+=((srcwidth+3)&~3)-srcwidth; //align
}
if(palette)
- free(palette);
- free(data);
+ rfx_free(palette);
+ rfx_free(data);
return dest;
}
swf_SetJPEGBitsFinish(jpeg);
PUT32(&tag->data[pos], tag->len - pos - 4);
- data=malloc(OUTBUFFER_SIZE);
+ data=rfx_alloc(OUTBUFFER_SIZE);
memset(&zs,0x00,sizeof(z_stream));
if (deflateInit(&zs,Z_DEFAULT_COMPRESSION)!=Z_OK) {
}
deflateEnd(&zs);
- free(data);
+ rfx_free(data);
return 0;
}
#endif
static void add_line(RENDERBUF*buf, double x1, double y1, double x2, double y2, renderpoint_t*p)
{
renderbuf_internal*i = (renderbuf_internal*)buf->internal;
+ double diffx, diffy;
+ double ny1, ny2, stepx;
/* if(DEBUG&4) {
int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
printf(" l[%d - %.2f/%.2f -> %.2f/%.2f]", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
x2 = x2/20.0;
if(y2 < y1) {
- double x = x1;x1 = x2;x2=x;
- double y = y1;y1 = y2;y2=y;
+ double x;
+ double y;
+ x = x1;x1 = x2;x2=x;
+ y = y1;y1 = y2;y2=y;
}
- double diffx = x2 - x1;
- double diffy = y2 - y1;
+ diffx = x2 - x1;
+ diffy = y2 - y1;
- double ny1 = (int)(y1)+CUT;
- double ny2 = (int)(y2)+CUT;
+ ny1 = (int)(y1)+CUT;
+ ny2 = (int)(y2)+CUT;
if(ny1 < y1) {
ny1 = (int)(y1) + 1.0 + CUT;
if(ny1 > ny2)
return;
- double stepx = diffx/diffy;
+ stepx = diffx/diffy;
x1 = x1 + (ny1-y1)*stepx;
x2 = x2 + (ny2-y2)*stepx;
- int posy=(int)ny1;
- int endy=(int)ny2;
- double posx=0;
- double startx = x1;
-
- while(posy<=endy) {
- float xx = (float)(startx + posx);
- add_pixel(buf, xx ,posy, p);
- posx+=stepx;
- posy++;
+ {
+ int posy=(int)ny1;
+ int endy=(int)ny2;
+ double posx=0;
+ double startx = x1;
+
+ while(posy<=endy) {
+ float xx = (float)(startx + posx);
+ add_pixel(buf, xx ,posy, p);
+ posx+=stepx;
+ posy++;
+ }
}
}
#define PI 3.14159265358979
if(line->type == moveTo) {
} else if(line->type == lineTo) {
if(DEBUG&4) {
+ int l;
x1 = x;
y1 = y;
x2 = line->x;
y2 = line->y;
- int l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
+ l = sqrt((x2-x1)*(x2-x1) + (y2-y1)*(y2-y1));
printf("%d - %.2f/%.2f -> %.2f/%.2f ", l, x1/20.0, y1/20.0, x2/20.0, y2/20.0);
}
if(DEBUG&4) printf("\n");
} else if(line->type == splineTo) {
+ int c,t,y,parts,qparts;
+ double xx,yy;
transform_point(&mat, x, y, &x1, &y1);
transform_point(&mat, line->sx, line->sy, &x2, &y2);
transform_point(&mat, line->x, line->y, &x3, &y3);
- int c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
- int parts,qparts;
- int t;
- double xx=x1,yy=y1;
+ c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
+ xx=x1;
+ yy=y1;
parts = (int)(sqrt(c)/3);
if(!parts) parts = 1;
}
do {
+ RGBA col;
int xx = (int)(( (x - rx) * m22 - (y - ry) * m21)*det);
int yy = (int)((- (x - rx) * m12 + (y - ry) * m11)*det);
+ int ainv;
if(clip) {
if(xx<0) xx=0;
yy %= b->height;
}
- RGBA col = b->data[yy*b->width+xx];
- int ainv = 255-col.a;
+ col = b->data[yy*b->width+xx];
+ ainv = 255-col.a;
line[x].r = ((line[x].r*ainv)>>8)+col.r;
line[x].g = ((line[x].g*ainv)>>8)+col.g;
static void fill(RENDERBUF*dest, RGBA*line, int y, int x1, int x2, state_t*state)
{
renderbuf_internal*i = (renderbuf_internal*)dest->internal;
+ U32 clipdepth;
layer_t*l = state->layers;
if(x1>=x2) //zero width? nothing to do.
return;
- U32 clipdepth = 0;
+ clipdepth = 0;
while(l) {
if(l->p->depth < clipdepth) {
if(DEBUG&2) printf("(clipped)");
int size = sizeof(renderpoint_t);
int num = tag->len / size;
RGBA*line = line1;
+ state_t state;
+ memset(&state, 0, sizeof(state_t));
+
if((y&1) && i->antialize)
line = line2;
- state_t state;
- memset(&state, 0, sizeof(state_t));
if(!i->background) {
memset(line, 0, sizeof(RGBA)*i->width2);