void fz_warn(fz_context *ctx, const char *fmt, ...)
{
va_list ap;
char buf[sizeof ctx->warn->message];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
#ifdef USE_OUTPUT_DEBUG_STRING
OutputDebugStringA(buf);
OutputDebugStringA("\n");
#endif
if (!strcmp(buf, ctx->warn->message))
{
ctx->warn->count++;
}
else
{
fz_flush_warnings(ctx);
fprintf(stderr, "warning: %s\n", buf);
LOGE("warning: %s\n", buf);
fz_strlcpy(ctx->warn->message, buf, sizeof ctx->warn->message);
ctx->warn->count = 1;
}
}
void
fz_drop_context(fz_context *ctx)
{
if (!ctx)
return;
/* Other finalisation calls go here (in reverse order) */
fz_drop_document_handler_context(ctx);
fz_drop_glyph_cache_context(ctx);
fz_drop_store_context(ctx);
fz_drop_aa_context(ctx);
fz_drop_colorspace_context(ctx);
fz_drop_font_context(ctx);
fz_drop_id_context(ctx);
if (ctx->warn)
{
fz_flush_warnings(ctx);
fz_free(ctx, ctx->warn);
}
if (ctx->error)
{
assert(ctx->error->top == -1);
fz_free(ctx, ctx->error);
}
/* Free the context itself */
ctx->alloc->free(ctx->alloc->user, ctx);
}
void pdfapp_close(pdfapp_t *app)
{
if (app->cache)
fz_free_glyph_cache(app->cache);
app->cache = NULL;
if (app->image)
fz_drop_pixmap(app->image);
app->image = NULL;
if (app->outline)
pdf_free_outline(app->outline);
app->outline = NULL;
if (app->xref)
{
if (app->xref->store)
pdf_free_store(app->xref->store);
app->xref->store = NULL;
pdf_free_xref(app->xref);
app->xref = NULL;
}
if (app->xps)
{
xps_free_context(app->xps);
app->xps = NULL;
}
fz_flush_warnings();
}
void fz_vwarn(fz_context *ctx, const char *fmt, va_list ap)
{
char buf[sizeof ctx->warn->message];
fz_vsnprintf(buf, sizeof buf, fmt, ap);
buf[sizeof(buf) - 1] = 0;
#ifdef USE_OUTPUT_DEBUG_STRING
OutputDebugStringA(buf);
OutputDebugStringA("\n");
#endif
#ifdef USE_ANDROID_LOG
__android_log_print(ANDROID_LOG_WARN, "libmupdf", "%s", buf);
#endif
if (!strcmp(buf, ctx->warn->message))
{
ctx->warn->count++;
}
else
{
fz_flush_warnings(ctx);
fprintf(stderr, "warning: %s\n", buf);
fz_strlcpy(ctx->warn->message, buf, sizeof ctx->warn->message);
ctx->warn->count = 1;
}
}
int pdfsign_main(int argc, char **argv)
{
fz_context *ctx;
pdf_document *doc;
char *password = "";
int i, n, c;
pdf_page *page = NULL;
while ((c = fz_getopt(argc, argv, "p:")) != -1)
{
switch (c)
{
case 'p': password = fz_optarg; break;
default: usage(); break;
}
}
if (argc - fz_optind < 1)
usage();
filename = argv[fz_optind++];
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot initialize context\n");
exit(1);
}
fz_var(page);
doc = pdf_open_document(ctx, filename);
fz_try(ctx)
{
if (pdf_needs_password(ctx, doc))
if (!pdf_authenticate_password(ctx, doc, password))
fz_warn(ctx, "cannot authenticate password: %s", filename);
n = pdf_count_pages(ctx, doc);
for (i = 0; i < n; ++i)
{
page = pdf_load_page(ctx, doc, i);
verify_page(ctx, doc, i, page);
fz_drop_page(ctx, (fz_page*)page);
page = NULL;
}
}
fz_always(ctx)
pdf_drop_document(ctx, doc);
fz_catch(ctx)
{
fz_drop_page(ctx, (fz_page*)page);
fprintf(stderr, "error verify signatures: %s\n", fz_caught_message(ctx));
}
fz_flush_warnings(ctx);
fz_drop_context(ctx);
return 0;
}
int pdfextract_main(int argc, char **argv)
{
char *infile;
char *password = "";
int c, o;
while ((c = fz_getopt(argc, argv, "p:r")) != -1)
{
switch (c)
{
case 'p':
password = fz_optarg;
break;
case 'r':
dorgb++;
break;
default:
usage();
break;
}
}
if (fz_optind == argc)
usage();
infile = argv[fz_optind++];
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot initialise context\n");
exit(1);
}
doc = pdf_open_document(ctx, infile);
if (pdf_needs_password(ctx, doc))
if (!pdf_authenticate_password(ctx, doc, password))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", infile);
if (fz_optind == argc)
{
int len = pdf_count_objects(ctx, doc);
for (o = 1; o < len; o++)
showobject(o);
}
else
{
while (fz_optind < argc)
{
showobject(atoi(argv[fz_optind]));
fz_optind++;
}
}
pdf_close_document(ctx, doc);
fz_flush_warnings(ctx);
fz_drop_context(ctx);
return 0;
}
int main(int argc, char **argv)
{
fz_error error;
char *infile;
char *password = "";
int c, o;
while ((c = fz_getopt(argc, argv, "p:r")) != -1)
{
switch (c)
{
case 'p': password = fz_optarg; break;
case 'r': dorgb++; break;
default: usage(); break;
}
}
if (fz_optind == argc)
usage();
infile = argv[fz_optind++];
ctx = fz_context_init(&fz_alloc_default);
if (ctx == NULL)
die(fz_error_note(ctx, 1, "failed to initialise context"));
error = pdf_open_xref(ctx, &xref, infile, password);
if (error)
die(fz_error_note(ctx, error, "cannot open input file '%s'", infile));
if (fz_optind == argc)
{
for (o = 0; o < xref->len; o++)
showobject(o);
}
else
{
while (fz_optind < argc)
{
showobject(atoi(argv[fz_optind]));
fz_optind++;
}
}
pdf_free_xref(xref);
fz_flush_warnings(ctx);
fz_context_fin(ctx);
return 0;
}
void pdfapp_close(pdfapp_t *app)
{
#if 0
if (app->page)
pdf_droppage(app->page);
app->page = nil;
if (app->image)
fz_droppixmap(app->image);
app->image = nil;
/* if (app->outline)
pdf_dropoutline(app->outline);
app->outline = nil;*/
if (app->xref->store)
pdf_dropstore(app->xref->store);
app->xref->store = nil;
pdf_closexref(app->xref);
app->xref = nil;
#else
if (app->cache)
fz_free_glyph_cache(app->cache);
app->cache = NULL;
if (app->image)
fz_drop_pixmap(app->image);
app->image = NULL;
if (app->outline)
pdf_free_outline(app->outline);
app->outline = NULL;
if (app->xref)
{
if (app->xref->store)
pdf_free_store(app->xref->store);
app->xref->store = NULL;
pdf_free_xref(app->xref);
app->xref = NULL;
}
fz_flush_warnings();
#endif
}
static void
fz_emit_error(char what, char *location, char *message)
{
fz_flush_warnings();
#ifdef _DEBUG
fprintf(stderr, "%c %s%s\n", what, location, message);
#endif
if (error_count < LINE_COUNT)
{
fz_strlcpy(error_message[error_count], location, LINE_LEN);
fz_strlcat(error_message[error_count], message, LINE_LEN);
error_count++;
}
}
void fz_warn(char *fmt, ...)
{
va_list ap;
char buf[LINE_LEN];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
if (!strcmp(buf, warn_message))
{
warn_count++;
}
else
{
fz_flush_warnings();
fprintf(stderr, "warning: %s\n", buf);
fz_strlcpy(warn_message, buf, sizeof warn_message);
warn_count = 1;
}
}
void fz_warn(fz_context *ctx, char *fmt, ...)
{
va_list ap;
char buf[sizeof ctx->warn->message];
va_start(ap, fmt);
vsnprintf(buf, sizeof buf, fmt, ap);
va_end(ap);
if (!strcmp(buf, ctx->warn->message))
{
ctx->warn->count++;
}
else
{
fz_flush_warnings(ctx);
fprintf(stderr, "warning: %s\n", buf);
LOGE("warning: %s\n", buf);
fz_strlcpy(ctx->warn->message, buf, sizeof ctx->warn->message);
ctx->warn->count = 1;
}
}
int wmupdf_numpages(char *filename)
{
fz_context *ctx;
fz_document *doc;
int np;
doc=NULL;
ctx = fz_new_context(NULL,NULL,FZ_STORE_DEFAULT);
if (!ctx)
return(-1);
fz_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-2);
}
np=fz_count_pages(doc);
fz_close_document(doc);
fz_flush_warnings(ctx);
fz_free_context(ctx);
return(np);
}
void
pdf_sort_cmap(fz_context *ctx, pdf_cmap *cmap)
{
pdf_range *a; /* last written range on output */
pdf_range *b; /* current range examined on input */
if (cmap->rlen == 0)
return;
qsort(cmap->ranges, cmap->rlen, sizeof(pdf_range), cmprange);
if (cmap->tlen == USHRT_MAX)
{
fz_warn(ctx, "cmap table is full; will not combine ranges");
return;
}
a = cmap->ranges;
b = cmap->ranges + 1;
while (b < cmap->ranges + cmap->rlen)
{
/* ignore one-to-many mappings */
if (pdf_range_flags(b) == PDF_CMAP_MULTI)
{
*(++a) = *b;
}
/* input contiguous */
else if (pdf_range_high(a) + 1 == b->low)
{
/* output contiguous */
if (pdf_range_high(a) - a->low + a->offset + 1 == b->offset)
{
/* SR -> R and SS -> R and RR -> R and RS -> R */
if ((pdf_range_flags(a) == PDF_CMAP_SINGLE || pdf_range_flags(a) == PDF_CMAP_RANGE) && (pdf_range_high(b) - a->low <= 0x3fff))
{
pdf_range_set_flags(a, PDF_CMAP_RANGE);
pdf_range_set_high(a, pdf_range_high(b));
}
/* LS -> L */
else if (pdf_range_flags(a) == PDF_CMAP_TABLE && pdf_range_flags(b) == PDF_CMAP_SINGLE && (pdf_range_high(b) - a->low <= 0x3fff))
{
pdf_range_set_high(a, pdf_range_high(b));
add_table(ctx, cmap, b->offset);
}
/* LR -> LR */
else if (pdf_range_flags(a) == PDF_CMAP_TABLE && pdf_range_flags(b) == PDF_CMAP_RANGE)
{
*(++a) = *b;
}
/* XX -> XX */
else
{
*(++a) = *b;
}
}
/* output separated */
else
{
/* SS -> L */
if (pdf_range_flags(a) == PDF_CMAP_SINGLE && pdf_range_flags(b) == PDF_CMAP_SINGLE)
{
pdf_range_set_flags(a, PDF_CMAP_TABLE);
pdf_range_set_high(a, pdf_range_high(b));
add_table(ctx, cmap, a->offset);
add_table(ctx, cmap, b->offset);
a->offset = cmap->tlen - 2;
}
/* LS -> L */
else if (pdf_range_flags(a) == PDF_CMAP_TABLE && pdf_range_flags(b) == PDF_CMAP_SINGLE && (pdf_range_high(b) - a->low <= 0x3fff))
{
pdf_range_set_high(a, pdf_range_high(b));
add_table(ctx, cmap, b->offset);
}
/* XX -> XX */
else
{
*(++a) = *b;
}
}
}
/* input separated: XX -> XX */
else
{
*(++a) = *b;
}
b ++;
}
cmap->rlen = a - cmap->ranges + 1;
fz_flush_warnings(ctx);
}
int bmpmupdf_pdffile_to_bmp(WILLUSBITMAP *bmp,char *filename,int pageno,double dpi,
int bpp)
{
fz_context *ctx;
fz_colorspace *colorspace;
fz_document *doc;
fz_page *page;
fz_display_list *list;
fz_device *dev;
fz_pixmap *pix;
double dpp;
fz_rect bounds,bounds2;
fz_matrix ctm;
fz_irect bbox;
// fz_glyph_cache *glyphcache;
// fz_error error;
int np,status;
dev=NULL;
list=NULL;
page=NULL;
doc=NULL;
status=0;
if (pageno<1)
return(-99);
ctx = fz_new_context(NULL,NULL,FZ_STORE_DEFAULT);
if (!ctx)
return(-1);
fz_try(ctx)
{
fz_register_document_handlers(ctx);
fz_set_aa_level(ctx,8);
/* Sumatra version of MuPDF v1.4 -- use locally installed fonts */
pdf_install_load_system_font_funcs(ctx);
// fz_accelerate();
// glyphcache=fz_new_glyph_cache();
colorspace=(bpp==8 ? fz_device_gray(ctx) : fz_device_rgb(ctx));
fz_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-1);
}
/*
if (fz_needs_password(doc) && !fz_authenticate_password(doc,password))
return(-2);
*/
// error=pdf_load_page_tree(xref);
// if (error)
// {
// pdf_free_xref(xref);
// return(-2);
// }
np=fz_count_pages(doc);
if (pageno>np)
return(-99);
fz_try(ctx) { page = fz_load_page(doc,pageno-1); }
fz_catch(ctx)
{
fz_close_document(doc);
fz_free_context(ctx);
return(-3);
}
fz_try(ctx) { list=fz_new_display_list(ctx);
dev=fz_new_list_device(ctx,list);
fz_run_page(doc,page,dev,&fz_identity,NULL);
}
fz_catch(ctx)
{
fz_free_device(dev);
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
fz_free_context(ctx);
return(-4);
}
fz_free_device(dev);
dev=NULL;
dpp=dpi/72.;
pix=NULL;
fz_var(pix);
fz_bound_page(doc,page,&bounds);
ctm=fz_identity;
fz_scale(&ctm,dpp,dpp);
// ctm=fz_concat(ctm,fz_rotate(rotation));
bounds2=bounds;
fz_transform_rect(&bounds2,&ctm);
fz_round_rect(&bbox,&bounds2);
// ctm=fz_translate(0,-page->mediabox.y1);
// ctm=fz_concat(ctm,fz_scale(dpp,-dpp));
// ctm=fz_concat(ctm,fz_rotate(page->rotate));
// ctm=fz_concat(ctm,fz_rotate(0));
// bbox=fz_round_rect(fz_transform_rect(ctm,page->mediabox));
// pix=fz_new_pixmap_with_rect(colorspace,bbox);
fz_try(ctx)
{
pix=fz_new_pixmap_with_bbox(ctx,colorspace,&bbox);
fz_clear_pixmap_with_value(ctx,pix,255);
dev=fz_new_draw_device(ctx,pix);
if (list)
fz_run_display_list(list,dev,&ctm,&bounds2,NULL);
else
fz_run_page(doc,page,dev,&ctm,NULL);
fz_free_device(dev);
dev=NULL;
status=bmpmupdf_pixmap_to_bmp(bmp,ctx,pix);
fz_drop_pixmap(ctx,pix);
}
fz_catch(ctx)
{
fz_free_device(dev);
fz_drop_pixmap(ctx,pix);
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
fz_free_context(ctx);
return(-5);
}
if (list)
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
// pdf_free_xref(xref);
fz_close_document(doc);
fz_flush_warnings(ctx);
} /* fz_catch before registering handlers */
fz_catch(ctx) /* Error registering */
{
status = -10;
}
fz_free_context(ctx);
// fz_free_glyph_cache(glyphcache);
// fz_flush_warnings();
if (status<0)
return(status-10);
return(0);
}
int main(int argc, char **argv)
{
fz_error error;
char *infile;
char *outfile = "out.pdf";
char *password = "";
int c, num;
int subset;
while ((c = fz_getopt(argc, argv, "adgp:")) != -1)
{
switch (c)
{
case 'p': password = fz_optarg; break;
case 'g': dogarbage ++; break;
case 'd': doexpand ++; break;
case 'a': doascii ++; break;
default: usage(); break;
}
}
if (argc - fz_optind < 1)
usage();
infile = argv[fz_optind++];
if (argc - fz_optind > 0 &&
(strstr(argv[fz_optind], ".pdf") || strstr(argv[fz_optind], ".PDF")))
{
outfile = argv[fz_optind++];
}
subset = 0;
if (argc - fz_optind > 0)
subset = 1;
ctx = fz_context_init(&fz_alloc_default);
if (ctx == NULL)
die(fz_error_note(ctx, 1, "failed to initialise context"));
error = pdf_open_xref(ctx, &xref, infile, password);
if (error)
die(fz_error_note(ctx, error, "cannot open input file '%s'", infile));
out = fopen(outfile, "wb");
if (!out)
die(fz_error_make(ctx, "cannot open output file '%s'", outfile));
fprintf(out, "%%PDF-%d.%d\n", xref->version / 10, xref->version % 10);
fprintf(out, "%%\316\274\341\277\246\n\n");
uselist = fz_calloc(ctx, xref->len + 1, sizeof(char));
ofslist = fz_calloc(ctx, xref->len + 1, sizeof(int));
genlist = fz_calloc(ctx, xref->len + 1, sizeof(int));
renumbermap = fz_calloc(ctx, xref->len + 1, sizeof(int));
for (num = 0; num < xref->len; num++)
{
uselist[num] = 0;
ofslist[num] = 0;
genlist[num] = 0;
renumbermap[num] = num;
}
/* Make sure any objects hidden in compressed streams have been loaded */
preloadobjstms();
/* Only retain the specified subset of the pages */
if (subset)
retainpages(argc, argv);
/* Sweep & mark objects from the trailer */
if (dogarbage >= 1)
sweepobj(xref->trailer);
/* Coalesce and renumber duplicate objects */
if (dogarbage >= 3)
removeduplicateobjs();
/* Compact xref by renumbering and removing unused objects */
if (dogarbage >= 2)
compactxref();
/* Make renumbering affect all indirect references and update xref */
/* Do not renumber objects if encryption is in use, as the object
* numbers are baked into the streams/strings, and we can't currently
* cope with moving them. See bug 692627. */
if (dogarbage >= 2 && xref->crypt == NULL)
renumberobjs();
writepdf();
if (fclose(out))
die(fz_error_make(ctx, "cannot close output file '%s'", outfile));
fz_free(xref->ctx, uselist);
fz_free(xref->ctx, ofslist);
fz_free(xref->ctx, genlist);
fz_free(xref->ctx, renumbermap);
pdf_free_xref(xref);
fz_flush_warnings(ctx);
fz_context_fin(ctx);
return 0;
}
static void processpage(fz_context *ctx, fz_document *doc, int pagenum)
{
fz_page *page;
int needshot = 0;
fz_try(ctx)
{
page = fz_load_page(ctx, doc, pagenum - 1);
}
fz_catch(ctx)
{
fz_rethrow_message(ctx, "cannot load page %d in file '%s'", pagenum, filename);
}
pdf_document *inter = pdf_specifics(ctx, doc);
pdf_widget *widget = NULL;
if (inter)
widget = pdf_first_widget(inter, (pdf_page *)page);
if (widget)
{
fprintf(mujstest_file, "GOTO %d\n", pagenum);
needshot = 1;
}
for (;widget; widget = pdf_next_widget(widget))
{
fz_rect rect;
int w, h, len;
int type = pdf_widget_get_type(widget);
pdf_bound_widget(widget, &rect);
w = (rect.x1 - rect.x0);
h = (rect.y1 - rect.y0);
++mujstest_count;
switch (type)
{
default:
fprintf(mujstest_file, "%% UNKNOWN %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case PDF_WIDGET_TYPE_PUSHBUTTON:
fprintf(mujstest_file, "%% PUSHBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case PDF_WIDGET_TYPE_CHECKBOX:
fprintf(mujstest_file, "%% CHECKBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case PDF_WIDGET_TYPE_RADIOBUTTON:
fprintf(mujstest_file, "%% RADIOBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case PDF_WIDGET_TYPE_TEXT:
{
int maxlen = pdf_text_widget_max_len(inter, widget);
int texttype = pdf_text_widget_content_type(inter, widget);
/* If height is low, assume a single row, and base
* the width off that. */
if (h < 10)
{
w = (w+h-1) / (h ? h : 1);
h = 1;
}
/* Otherwise, if width is low, work off height */
else if (w < 10)
{
h = (w+h-1) / (w ? w : 1);
w = 1;
}
else
{
w = (w+9)/10;
h = (h+9)/10;
}
len = w*h;
if (len < 2)
len = 2;
if (len > maxlen)
len = maxlen;
fprintf(mujstest_file, "%% TEXT %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
switch (texttype)
{
default:
case PDF_WIDGET_CONTENT_UNRESTRAINED:
fprintf(mujstest_file, "TEXT %d ", mujstest_count);
escape_string(mujstest_file, len-3, lorem);
fprintf(mujstest_file, "\n");
break;
case PDF_WIDGET_CONTENT_NUMBER:
fprintf(mujstest_file, "TEXT %d\n", mujstest_count);
break;
case PDF_WIDGET_CONTENT_SPECIAL:
#ifdef __MINGW32__
fprintf(mujstest_file, "TEXT %I64d\n", 46702919800LL + mujstest_count);
#else
fprintf(mujstest_file, "TEXT %lld\n", 46702919800LL + mujstest_count);
#endif
break;
case PDF_WIDGET_CONTENT_DATE:
fprintf(mujstest_file, "TEXT Jun %d 1979\n", 1 + ((13 + mujstest_count) % 30));
break;
case PDF_WIDGET_CONTENT_TIME:
++mujstest_count;
fprintf(mujstest_file, "TEXT %02d:%02d\n", ((mujstest_count/60) % 24), mujstest_count % 60);
break;
}
break;
}
case PDF_WIDGET_TYPE_LISTBOX:
fprintf(mujstest_file, "%% LISTBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case PDF_WIDGET_TYPE_COMBOBOX:
fprintf(mujstest_file, "%% COMBOBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
}
fprintf(mujstest_file, "CLICK %0.2f %0.2f\n", (rect.x0+rect.x1)/2, (rect.y0+rect.y1)/2);
}
fz_flush_warnings(ctx);
if (mujstest_file && needshot)
{
fprintf(mujstest_file, "SCREENSHOT\n");
}
}
static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
{
fz_page *page;
fz_display_list *list = NULL;
fz_device *dev = NULL;
int start;
fz_cookie cookie = { 0 };
fz_var(list);
fz_var(dev);
fz_try(ctx)
{
page = fz_load_page(doc, pagenum - 1);
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot load page %d in file '%s'", pagenum, filename);
}
float zoom;
fz_matrix ctm;
fz_rect bounds, bounds2;
fz_bbox bbox;
fz_pixmap *pix = NULL;
int w, h;
fz_var(pix);
bounds = fz_bound_page(doc, page);
zoom = resolution / 72;
ctm = fz_scale(zoom, zoom);
ctm = fz_concat(ctm, fz_rotate(rotation));
bounds2 = fz_transform_rect(ctm, bounds);
bbox = fz_round_rect(bounds2);
/* Make local copies of our width/height */
w = width;
h = height;
/* If a resolution is specified, check to see whether w/h are
* exceeded; if not, unset them. */
if (res_specified)
{
int t;
t = bbox.x1 - bbox.x0;
if (w && t <= w)
w = 0;
t = bbox.y1 - bbox.y0;
if (h && t <= h)
h = 0;
}
/* Now w or h will be 0 unless then need to be enforced. */
if (w || h)
{
float scalex = w/(bounds2.x1-bounds2.x0);
float scaley = h/(bounds2.y1-bounds2.y0);
if (fit)
{
if (w == 0)
scalex = 1.0f;
if (h == 0)
scaley = 1.0f;
}
else
{
if (w == 0)
scalex = scaley;
if (h == 0)
scaley = scalex;
}
if (!fit)
{
if (scalex > scaley)
scalex = scaley;
else
scaley = scalex;
}
ctm = fz_concat(ctm, fz_scale(scalex, scaley));
bounds2 = fz_transform_rect(ctm, bounds);
}
bbox = fz_round_rect(bounds2);
/* TODO: banded rendering and multi-page ppm */
fz_try(ctx)
{
pix = fz_new_pixmap_with_bbox(ctx, colorspace, bbox);
fz_clear_pixmap_with_value(ctx, pix, 255);
dev = fz_new_draw_device(ctx, pix);
if (list)
fz_run_display_list(list, dev, ctm, bbox, &cookie);
else
fz_run_page(doc, page, dev, ctm, &cookie);
fz_free_device(dev);
dev = NULL;
int size = fz_pixmap_height(ctx, pix) * fz_pixmap_width(ctx, pix);
inplace_reorder(fz_pixmap_samples(ctx, pix), size);
size_t x_offset = (width - fz_pixmap_width(ctx, pix)) / 2;
size_t y_offset = (height - fz_pixmap_height(ctx, pix)) / 2;;
if (toggle_decors) {
x_offset += decor_left_width;
y_offset += decor_top_height;
}
for (int i = 0; i < fz_pixmap_height(ctx, pix); ++i) {
memcpy(&GFX(gfx_ctx, x_offset, y_offset + i), &fz_pixmap_samples(ctx, pix)[fz_pixmap_width(ctx, pix) * i * 4], fz_pixmap_width(ctx, pix) * 4);
}
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
fz_drop_pixmap(ctx, pix);
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
if (list)
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_flush_warnings(ctx);
if (cookie.errors)
errored = 1;
}
static void pdfapp_showpage(pdfapp_t *app, int loadpage, int drawpage, int repaint)
{
char buf[256];
fz_device *idev;
fz_device *tdev;
fz_colorspace *colorspace;
fz_matrix ctm;
fz_bbox bbox;
wincursor(app, WAIT);
if (loadpage)
{
if (app->page_list)
fz_free_display_list(app->page_list);
if (app->page_text)
fz_free_text_span(app->page_text);
if (app->page_links)
pdf_free_link(app->page_links);
if (app->xref)
pdfapp_loadpage_pdf(app);
if (app->xps)
pdfapp_loadpage_xps(app);
/* Zero search hit position */
app->hit = -1;
app->hitlen = 0;
/* Extract text */
app->page_text = fz_new_text_span();
tdev = fz_new_text_device(app->page_text);
fz_execute_display_list(app->page_list, tdev, fz_identity, fz_infinite_bbox);
fz_free_device(tdev);
}
if (drawpage)
{
sprintf(buf, "%s - %d/%d (%d dpi)", app->doctitle,
app->pageno, app->pagecount, app->resolution);
wintitle(app, buf);
ctm = pdfapp_viewctm(app);
bbox = fz_round_rect(fz_transform_rect(ctm, app->page_bbox));
/* Draw */
if (app->image)
fz_drop_pixmap(app->image);
if (app->grayscale)
colorspace = fz_device_gray;
else
#ifdef _WIN32
colorspace = fz_device_bgr;
#else
colorspace = fz_device_rgb;
#endif
app->image = fz_new_pixmap_with_rect(colorspace, bbox);
fz_clear_pixmap_with_color(app->image, 255);
idev = fz_new_draw_device(app->cache, app->image);
fz_execute_display_list(app->page_list, idev, ctm, bbox);
fz_free_device(idev);
}
if (repaint)
{
pdfapp_panview(app, app->panx, app->pany);
if (app->shrinkwrap)
{
int w = app->image->w;
int h = app->image->h;
if (app->winw == w)
app->panx = 0;
if (app->winh == h)
app->pany = 0;
if (w > app->scrw * 90 / 100)
w = app->scrw * 90 / 100;
if (h > app->scrh * 90 / 100)
h = app->scrh * 90 / 100;
if (w != app->winw || h != app->winh)
winresize(app, w, h);
}
winrepaint(app);
wincursor(app, ARROW);
}
fz_flush_warnings();
}
int pdfmerge_main(int argc, char **argv)
{
pdf_write_options opts = { 0 };
char *output = "out.pdf";
char *flags = "";
char *input;
int c;
while ((c = fz_getopt(argc, argv, "o:O:")) != -1)
{
switch (c)
{
case 'o': output = fz_optarg; break;
case 'O': flags = fz_optarg; break;
default: usage(); break;
}
}
if (fz_optind == argc)
usage();
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "error: Cannot initialize MuPDF context.\n");
exit(1);
}
pdf_parse_write_options(ctx, &opts, flags);
fz_try(ctx)
{
doc_des = pdf_create_document(ctx);
}
fz_catch(ctx)
{
fprintf(stderr, "error: Cannot create destination document.\n");
exit(1);
}
/* Step through the source files */
while (fz_optind < argc)
{
input = argv[fz_optind++];
fz_try(ctx)
{
pdf_drop_document(ctx, doc_src);
doc_src = pdf_open_document(ctx, input);
if (fz_optind == argc || !fz_is_page_range(ctx, argv[fz_optind]))
merge_range("1-N");
else
merge_range(argv[fz_optind++]);
}
fz_catch(ctx)
{
fprintf(stderr, "error: Cannot merge document '%s'.\n", input);
exit(1);
}
}
fz_try(ctx)
{
pdf_save_document(ctx, doc_des, output, &opts);
}
fz_always(ctx)
{
pdf_drop_document(ctx, doc_des);
pdf_drop_document(ctx, doc_src);
}
fz_catch(ctx)
{
fprintf(stderr, "error: Cannot save output file: '%s'.\n", output);
exit(1);
}
fz_flush_warnings(ctx);
fz_drop_context(ctx);
return 0;
}
int pdfmerge_main(int argc, char **argv)
{
pdf_write_options opts = { 0 };
char *output = "out.pdf";
char *infile_src;
int c;
while ((c = fz_getopt(argc, argv, "adlszo:")) != -1)
{
switch (c)
{
case 'o': output = fz_optarg; break;
case 'a': opts.do_ascii ++; break;
case 'd': opts.do_expand ^= PDF_EXPAND_ALL; break;
case 'l': opts.do_linear ++; break;
case 's': opts.do_clean ++; break;
case 'z': opts.do_deflate ++; break;
default: usage(); break;
}
}
if (fz_optind == argc)
usage();
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "Cannot initialise context\n");
exit(1);
}
fz_try(ctx)
{
doc_des = pdf_create_document(ctx);
}
fz_catch(ctx)
{
fprintf(stderr, "Failed to allocate destination document file %s\n", output);
exit(1);
}
/* Step through the source files */
while (fz_optind < argc)
{
fz_try(ctx)
{
infile_src = argv[fz_optind++];
pdf_drop_document(ctx, doc_src);
doc_src = pdf_open_document(ctx, infile_src);
if (fz_optind == argc || !isrange(argv[fz_optind]))
merge_range("1-");
else
merge_range(argv[fz_optind++]);
}
fz_catch(ctx)
{
fprintf(stderr, "Failed merging document %s\n", infile_src);
exit(1);
}
}
fz_try(ctx)
{
pdf_save_document(ctx, doc_des, output, &opts);
}
fz_always(ctx)
{
pdf_drop_document(ctx, doc_des);
pdf_drop_document(ctx, doc_src);
}
fz_catch(ctx)
{
fprintf(stderr, "Error encountered during file save.\n");
exit(1);
}
fz_flush_warnings(ctx);
fz_drop_context(ctx);
return 0;
}