#include <memory.h>
#include "../gfxdevice.h"
#include "../gfxtools.h"
-#include "../png.h"
#include "../mem.h"
-
-typedef unsigned int U32;
-typedef unsigned char U8;
+#define PNG_INLINE_EXPORTS
+#include "../types.h"
+#include "../png.c"
+#include "render.h"
typedef gfxcolor_t RGBA;
int antialize;
int zoom;
int ymin, ymax;
+ int fillwhite;
RGBA* img;
col.r = (col.r*col.a)>>8;
col.g = (col.g*col.a)>>8;
col.b = (col.b*col.a)>>8;
- col.a = 255;
do {
if(z[bitpos]&bit) {
line[x].r = ((line[x].r*ainv)>>8)+col.r;
line[x].g = ((line[x].g*ainv)>>8)+col.g;
line[x].b = ((line[x].b*ainv)>>8)+col.b;
- line[x].a = 255;
+ //line[x].a = 255;
+ line[x].a = ((line[x].a*ainv)>>8)+col.a;
}
bit <<= 1;
if(!bit) {
int render_setparameter(struct _gfxdevice*dev, const char*key, const char*value)
{
internal_t*i = (internal_t*)dev->internal;
- if(!strcmp(key, "antialize")) {
+ if(!strcmp(key, "antialize") || !strcmp(key, "antialise")) {
i->antialize = atoi(value);
i->zoom = i->antialize * i->multiply;
+ return 1;
} else if(!strcmp(key, "multiply")) {
i->multiply = atoi(value);
i->zoom = i->antialize * i->multiply;
fprintf(stderr, "Warning: multiply not implemented yet\n");
+ return 1;
+ } else if(!strcmp(key, "fillwhite")) {
+ i->fillwhite = atoi(value);
+ return 1;
}
return 0;
}
{
internal_t*i = (internal_t*)dev->internal;
- clipbuffer_t*c = rfx_calloc(sizeof(clipbuffer_t));
- c->data = rfx_calloc(sizeof(U32) * i->bitwidth * i->height2);
+ clipbuffer_t*c = (clipbuffer_t*)rfx_calloc(sizeof(clipbuffer_t));
+ c->data = (U32*)rfx_calloc(sizeof(U32) * i->bitwidth * i->height2);
c->next = i->clipbuf;
i->clipbuf = c;
if(c->next)
}*/
while(line) {
- int x1,y1,x2,y2,x3,y3;
-
if(line->type == gfx_moveTo) {
} else if(line->type == gfx_lineTo) {
double x1=x*i->zoom,y1=y*i->zoom;
add_solidline(dev, x1, y1, x3, y3, width * i->multiply);
fill_solid(dev, color);
} else if(line->type == gfx_splineTo) {
- int c,t,parts,qparts;
+ int t,parts;
double xx,yy;
double x1=x*i->zoom,y1=y*i->zoom;
double x2=line->sx*i->zoom,y2=line->sy*i->zoom;
double x3=line->x*i->zoom,y3=line->y*i->zoom;
- c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
+ double c = abs(x3-2*x2+x1) + abs(y3-2*y2+y1);
xx=x1;
yy=y1;
void render_drawchar(struct _gfxdevice*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix)
{
internal_t*i = (internal_t*)dev->internal;
+ if(!font)
+ return;
+
+ /* align characters to whole pixels */
+ matrix->tx = (int)(matrix->tx * i->antialize) / i->antialize;
+ matrix->ty = (int)(matrix->ty * i->antialize) / i->antialize;
gfxglyph_t*glyph = &font->glyphs[glyphnr];
gfxline_t*line2 = gfxline_clone(glyph->line);
{
internal_result_t*i= (internal_result_t*)r->internal;
}
-int render_result_save(gfxresult_t*r, char*filename)
+int render_result_save(gfxresult_t*r, const char*filename)
{
- /*internal_result_t*i= (internal_result_t*)r->internal;
+ internal_result_t*i= (internal_result_t*)r->internal;
+ if(!i) {
+ return 0; // no pages drawn
+ }
if(i->next) {
int nr=0;
+ char filenamebuf[256];
+ char*origname = strdup(filename);
+ int l = strlen(origname);
+ if(l>3 && strchr("gG",origname[l-1]) && strchr("nN",filename[l-2]) &&
+ strchr("pP",origname[l-3]) && filename[l-4]=='.') {
+ origname[l-4] = 0;
+ }
while(i->next) {
+ sprintf(filenamebuf, "%s.%d.png", origname, nr);
writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
nr++;
}
+ free(origname);
} else {
writePNG(filename, (unsigned char*)i->img.data, i->img.width, i->img.height);
- }*/
+ }
return 1;
}
-void*render_result_get(gfxresult_t*r, char*name)
+char*gfximage_asXPM(gfximage_t*img, int depth)
+{
+ int d= 256/depth;
+ char*str = (char*)malloc(img->width*img->height*4 + 500 + 16*depth*depth*depth);
+ char*p = str;
+ p+= sprintf(p, "static char *noname[] = {\n\"%d %d 262144 3\",\n");
+ int r,g,b;
+ for(r=0;r<depth;r++)
+ for(g=0;g<depth;g++)
+ for(b=0;b<depth;b++) {
+ p += sprintf(p, "\"%c%c%c c #%02x%02x%02x\",\n", r+32,g+32,b+32, r*d,g*d,b*d);
+ }
+ int y;
+ for(y=0;y<img->height;y++) {
+ p+=sprintf(p, "\"");
+ gfxcolor_t*col = &img->data[y*img->height];
+ int x;
+ for(x=0;x<img->width;x++) {
+ p+=sprintf(p, "%c%c%c", 32+(col->r/d), 32+(col->g/d), 32+(col->b/d));
+ }
+ p+=sprintf(p, "\",\n");
+ }
+ *p = 0;
+ return p;
+}
+void*render_result_get(gfxresult_t*r, const char*name)
{
internal_result_t*i= (internal_result_t*)r->internal;
- if(!strncmp(name,"page",4)) {
+ if(!strncmp(name,"xpm",3)) {
+ int pagenr = atoi(&name[3]);
+ if(pagenr<0)
+ pagenr=0;
+ while(pagenr>0) {
+ i = i->next;
+ if(!i)
+ return 0;
+ }
+ return gfximage_asXPM(&i->img, 64);
+ } else if(!strncmp(name,"page",4)) {
int pagenr = atoi(&name[4]);
if(pagenr<0)
- return 0;
+ pagenr=0;
while(pagenr>0) {
i = i->next;
if(!i)
i->lines[y].num = 0;
}
i->img = (RGBA*)rfx_calloc(sizeof(RGBA)*i->width2*i->height2);
+ if(i->fillwhite) {
+ memset(i->img, 0xff, sizeof(RGBA)*i->width2*i->height2);
+ }
+
i->ymin = 0x7fffffff;
i->ymax = -0x80000000;
static void store_image(internal_t*i, internal_result_t*ir)
{
- ir->img.data = malloc(i->width*i->height*sizeof(RGBA));
+ ir->img.data = (gfxcolor_t*)malloc(i->width*i->height*sizeof(gfxcolor_t));
ir->img.width = i->width;
ir->img.height = i->height;
i->height2 = 0;
}
-void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, char*action)
+void render_drawlink(struct _gfxdevice*dev, gfxline_t*line, const char*action)
{
/* not supported for this output device */
}
void gfxdevice_render_init(gfxdevice_t*dev)
{
internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
- int y;
memset(dev, 0, sizeof(gfxdevice_t));
dev->name = "render";
git.asbjorn.biz / swftools.git / blobdiff