+void swf_RemoveJPEGTables(SWF * swf)
+{
+ TAG *tag = swf->firstTag;
+ TAG *tables_tag = 0;
+ while (tag) {
+ if (tag->id == ST_JPEGTABLES) {
+ tables_tag = tag;
+ }
+ tag = tag->next;
+ }
+
+ if (!tables_tag)
+ return;
+
+ tag = swf->firstTag;
+ while (tag) {
+ if (tag->id == ST_DEFINEBITSJPEG) {
+ int len = tag->len;
+ void *data = rfx_alloc(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);
+ swf_SetBlock(tag, &((U8*)data)[2], len-2);
+ free(data);
+ }
+ tag = tag->next;
+ }
+ if (swf->firstTag == tables_tag)
+ swf->firstTag = tables_tag->next;
+ swf_DeleteTag(tables_tag);
+}
+
+typedef struct scale_lookup {
+ int pos;
+ unsigned int weight;
+} scale_lookup_t;
+
+typedef struct rgba_int {
+ unsigned int r,g,b,a;
+} rgba_int_t;
+
+static int bicubic = 0;
+
+static scale_lookup_t**make_scale_lookup(int width, int newwidth)
+{
+ 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;
+ int x;
+ scale_lookup_t*p_x = lookupx;
+
+ if(newwidth<=width) {
+ for(x=0;x<newwidth;x++) {
+ double ex = px + fx;
+ int fromx = (int)px;
+ int tox = (int)ex;
+ double rem = fromx+1-px;
+ int i = (int)(256/fx);
+ int xweight = (int)(rem*256/fx);
+ int xx;
+ int w = 0;
+ lblockx[x] = p_x;
+ if(tox>=width) tox = width-1;
+ for(xx=fromx;xx<=tox;xx++) {
+ if(xx==fromx && xx==tox) p_x->weight = 256;
+ else if(xx==fromx) p_x->weight = xweight;
+ else if(xx==tox) p_x->weight = 256-w;
+ else p_x->weight = i;
+ w+=p_x->weight;
+ p_x->pos = xx;
+ p_x++;
+ }
+ px = ex;
+ }
+ } else {
+ for(x=0;x<newwidth;x++) {
+ int ix1 = (int)px;
+ int ix2 = ((int)px)+1;
+ double r = px-ix1;
+ if(ix2>=width) ix2=width-1;
+ lblockx[x] = p_x;
+ if(bicubic)
+ r = -2*r*r*r+3*r*r;
+ p_x[0].weight = (int)(256*(1-r));
+ p_x[0].pos = ix1;
+ p_x[1].weight = 256-p_x[0].weight;
+ p_x[1].pos = ix2;
+ p_x+=2;
+ px += fx;
+ }
+ }
+ lblockx[newwidth] = p_x;
+ return lblockx;
+}
+
+static void encodeMonochromeImage(RGBA*data, int width, int height, RGBA*colors)
+{
+ int t;
+ int len = width*height;
+
+ U32* img = (U32*)data;
+ U32 color1 = img[0];
+ U32 color2 = 0;
+ for(t=1;t<len;t++) {
+ if(img[t] != color1) {
+ color2 = img[t];
+ break;
+ }
+ }
+ *(U32*)&colors[0] = color1;
+ *(U32*)&colors[1] = color2;
+ for(t=0;t<len;t++) {
+ if(img[t] == color1) {
+ img[t] = 0;
+ } else {
+ img[t] = 0xffffffff;
+ }
+ }
+}
+
+static void decodeMonochromeImage(RGBA*data, int width, int height, RGBA*colors)
+{
+ int t;
+ int len = width*height;
+
+ for(t=0;t<len;t++) {
+ U32 m = data[t].r;
+ data[t].r = (colors[0].r * (255-m) + colors[1].r * m) >> 8;
+ data[t].g = (colors[0].g * (255-m) + colors[1].g * m) >> 8;
+ data[t].b = (colors[0].b * (255-m) + colors[1].b * m) >> 8;
+ data[t].a = (colors[0].a * (255-m) + colors[1].a * m) >> 8;
+ }
+}
+
+RGBA* swf_ImageScale(RGBA*data, int width, int height, int newwidth, int newheight)
+{
+ int x,y;
+ RGBA* newdata;
+ scale_lookup_t *p, **lblockx,**lblocky;
+ rgba_int_t*tmpline;
+ int monochrome = 0;
+ RGBA monochrome_colors[2];
+
+ if(newwidth<1 || newheight<1)
+ return 0;
+
+ if(swf_ImageGetNumberOfPaletteEntries2(data, width, height) == 2) {
+ monochrome=1;
+ encodeMonochromeImage(data, width, height, monochrome_colors);
+ }
+
+ tmpline = (rgba_int_t*)malloc(width*sizeof(rgba_int_t));
+ newdata = (RGBA*)malloc(newwidth*newheight*sizeof(RGBA));
+
+ lblockx = make_scale_lookup(width, newwidth);
+ lblocky = make_scale_lookup(height, newheight);
+
+ for(p=lblocky[0];p<lblocky[newheight];p++)
+ p->pos*=width;
+
+ for(y=0;y<newheight;y++) {
+ RGBA*destline = &newdata[y*newwidth];
+
+ /* create lookup table for y */
+ rgba_int_t*l = tmpline;
+ scale_lookup_t*p_y,*p_x;
+ memset(tmpline, 0, width*sizeof(rgba_int_t));
+ for(p_y=lblocky[y];p_y<lblocky[y+1];p_y++) {
+ RGBA*line = &data[p_y->pos];
+ scale_lookup_t*p_x;
+ int weight = p_y->weight;
+ for(x=0;x<width;x++) {
+ tmpline[x].r += line[x].r*weight;
+ tmpline[x].g += line[x].g*weight;
+ tmpline[x].b += line[x].b*weight;
+ tmpline[x].a += line[x].a*weight;
+ }
+ }
+
+ /* process x direction */
+ p_x = lblockx[0];
+ for(x=0;x<newwidth;x++) {
+ unsigned int r=0,g=0,b=0,a=0;
+ scale_lookup_t*p_x_to = lblockx[x+1];
+ do {
+ rgba_int_t* col = &tmpline[p_x->pos];
+ unsigned int weight = p_x->weight;
+ r += col->r*weight;
+ g += col->g*weight;
+ b += col->b*weight;
+ a += col->a*weight;
+ p_x++;
+ } while (p_x<p_x_to);
+
+ destline->r = r >> 16;
+ destline->g = g >> 16;
+ destline->b = b >> 16;
+ destline->a = a >> 16;
+
+ destline++;
+ }
+ }
+
+ if(monochrome)
+ decodeMonochromeImage(newdata, newwidth, newheight, monochrome_colors);
+
+ free(tmpline);
+ free(*lblockx);
+ free(lblockx);
+ free(*lblocky);
+ free(lblocky);
+ return newdata;
+}
+
+