SeanOMik
/
eBookReaderSwitch
mirror of https://github.com/SeanOMik/eBookReaderSwitch.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
eBookReaderSwitch/mupdf/source/tools/mudraw.c

2046 lines
48 KiB
C
Raw Blame History

/*
* mudraw -- command line tool for drawing and converting documents
*/
#include "mupdf/fitz.h"
#if FZ_ENABLE_PDF
#include "mupdf/pdf.h" /* for pdf output */
#endif
#ifndef DISABLE_MUTHREADS
#include "mupdf/helpers/mu-threads.h"
#endif
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef _MSC_VER
struct timeval;
struct timezone;
int gettimeofday(struct timeval *tv, struct timezone *tz);
#else
#include <sys/time.h>
#endif
/* Allow for windows stdout being made binary */
#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#endif
/* Enable for helpful threading debug */
/* #define DEBUG_THREADS(A) do { printf A; fflush(stdout); } while (0) */
#define DEBUG_THREADS(A) do { } while (0)
enum {
OUT_NONE,
OUT_PNG, OUT_PNM, OUT_PGM, OUT_PPM, OUT_PAM,
OUT_PBM, OUT_PKM, OUT_PWG, OUT_PCL, OUT_PS, OUT_PSD,
OUT_TEXT, OUT_HTML, OUT_XHTML, OUT_STEXT, OUT_PCLM,
OUT_TRACE, OUT_SVG,
#if FZ_ENABLE_PDF
OUT_PDF,
#endif
};
enum { CS_INVALID, CS_UNSET, CS_MONO, CS_GRAY, CS_GRAY_ALPHA, CS_RGB, CS_RGB_ALPHA, CS_CMYK, CS_CMYK_ALPHA, CS_ICC };
enum { SPOTS_NONE, SPOTS_OVERPRINT_SIM, SPOTS_FULL };
typedef struct
{
char *suffix;
int format;
int spots;
} suffix_t;
static const suffix_t suffix_table[] =
{
{ ".png", OUT_PNG, 0 },
{ ".pgm", OUT_PGM, 0 },
{ ".ppm", OUT_PPM, 0 },
{ ".pnm", OUT_PNM, 0 },
{ ".pam", OUT_PAM, 0 },
{ ".pbm", OUT_PBM, 0 },
{ ".pkm", OUT_PKM, 0 },
{ ".svg", OUT_SVG, 0 },
{ ".pwg", OUT_PWG, 0 },
{ ".pclm", OUT_PCLM, 0 },
{ ".pcl", OUT_PCL, 0 },
#if FZ_ENABLE_PDF
{ ".pdf", OUT_PDF, 0 },
#endif
{ ".psd", OUT_PSD, 1 },
{ ".ps", OUT_PS, 0 },
{ ".txt", OUT_TEXT, 0 },
{ ".text", OUT_TEXT, 0 },
{ ".html", OUT_HTML, 0 },
{ ".xhtml", OUT_XHTML, 0 },
{ ".stext", OUT_STEXT, 0 },
{ ".trace", OUT_TRACE, 0 },
};
typedef struct
{
char *name;
int colorspace;
} cs_name_t;
static const cs_name_t cs_name_table[] =
{
{ "m", CS_MONO },
{ "mono", CS_MONO },
{ "g", CS_GRAY },
{ "gray", CS_GRAY },
{ "grey", CS_GRAY },
{ "ga", CS_GRAY_ALPHA },
{ "grayalpha", CS_GRAY_ALPHA },
{ "greyalpha", CS_GRAY_ALPHA },
{ "rgb", CS_RGB },
{ "rgba", CS_RGB_ALPHA },
{ "rgbalpha", CS_RGB_ALPHA },
{ "cmyk", CS_CMYK },
{ "cmyka", CS_CMYK_ALPHA },
{ "cmykalpha", CS_CMYK_ALPHA },
};
typedef struct
{
int format;
int default_cs;
int permitted_cs[7];
} format_cs_table_t;
static const format_cs_table_t format_cs_table[] =
{
{ OUT_PNG, CS_RGB, { CS_GRAY, CS_GRAY_ALPHA, CS_RGB, CS_RGB_ALPHA, CS_ICC } },
{ OUT_PPM, CS_RGB, { CS_GRAY, CS_RGB } },
{ OUT_PNM, CS_GRAY, { CS_GRAY, CS_RGB } },
{ OUT_PAM, CS_RGB_ALPHA, { CS_GRAY, CS_GRAY_ALPHA, CS_RGB, CS_RGB_ALPHA, CS_CMYK, CS_CMYK_ALPHA } },
{ OUT_PGM, CS_GRAY, { CS_GRAY, CS_RGB } },
{ OUT_PBM, CS_MONO, { CS_MONO } },
{ OUT_PKM, CS_CMYK, { CS_CMYK } },
{ OUT_PWG, CS_RGB, { CS_MONO, CS_GRAY, CS_RGB, CS_CMYK } },
{ OUT_PCL, CS_MONO, { CS_MONO, CS_RGB } },
{ OUT_PCLM, CS_RGB, { CS_RGB, CS_GRAY } },
{ OUT_PS, CS_RGB, { CS_GRAY, CS_RGB, CS_CMYK } },
{ OUT_PSD, CS_CMYK, { CS_GRAY, CS_GRAY_ALPHA, CS_RGB, CS_RGB_ALPHA, CS_CMYK, CS_CMYK_ALPHA, CS_ICC } },
{ OUT_TRACE, CS_RGB, { CS_RGB } },
{ OUT_SVG, CS_RGB, { CS_RGB } },
#if FZ_ENABLE_PDF
{ OUT_PDF, CS_RGB, { CS_RGB } },
#endif
{ OUT_TEXT, CS_RGB, { CS_RGB } },
{ OUT_HTML, CS_RGB, { CS_RGB } },
{ OUT_XHTML, CS_RGB, { CS_RGB } },
{ OUT_STEXT, CS_RGB, { CS_RGB } },
};
/*
In the presence of pthreads or Windows threads, we can offer
a multi-threaded option. In the absence, of such, we degrade
nicely.
*/
#ifndef DISABLE_MUTHREADS
static mu_mutex mutexes[FZ_LOCK_MAX];
static void mudraw_lock(void *user, int lock)
{
mu_lock_mutex(&mutexes[lock]);
}
static void mudraw_unlock(void *user, int lock)
{
mu_unlock_mutex(&mutexes[lock]);
}
static fz_locks_context mudraw_locks =
{
NULL, mudraw_lock, mudraw_unlock
};
static void fin_mudraw_locks(void)
{
int i;
for (i = 0; i < FZ_LOCK_MAX; i++)
mu_destroy_mutex(&mutexes[i]);
}
static fz_locks_context *init_mudraw_locks(void)
{
int i;
int failed = 0;
for (i = 0; i < FZ_LOCK_MAX; i++)
failed |= mu_create_mutex(&mutexes[i]);
if (failed)
{
fin_mudraw_locks();
return NULL;
}
return &mudraw_locks;
}
#endif
typedef struct worker_t {
fz_context *ctx;
int num;
int band; /* -1 to shutdown, or band to render */
fz_display_list *list;
fz_matrix ctm;
fz_rect tbounds;
fz_pixmap *pix;
fz_bitmap *bit;
fz_cookie cookie;
#ifndef DISABLE_MUTHREADS
mu_semaphore start;
mu_semaphore stop;
mu_thread thread;
#endif
} worker_t;
static char *output = NULL;
static fz_output *out = NULL;
static int output_pagenum = 0;
static int output_file_per_page = 0;
static char *format = NULL;
static int output_format = OUT_NONE;
static float rotation = 0;
static float resolution = 72;
static int res_specified = 0;
static int width = 0;
static int height = 0;
static int fit = 0;
static float layout_w = FZ_DEFAULT_LAYOUT_W;
static float layout_h = FZ_DEFAULT_LAYOUT_H;
static float layout_em = FZ_DEFAULT_LAYOUT_EM;
static char *layout_css = NULL;
static int layout_use_doc_css = 1;
static float min_line_width = 0.0f;
static int showfeatures = 0;
static int showtime = 0;
static int showmemory = 0;
static int showmd5 = 0;
#if FZ_ENABLE_PDF
static pdf_document *pdfout = NULL;
#endif
static int no_icc = 0;
static int ignore_errors = 0;
static int uselist = 1;
static int alphabits_text = 8;
static int alphabits_graphics = 8;
static int out_cs = CS_UNSET;
static const char *proof_filename = NULL;
fz_colorspace *proof_cs = NULL;
static const char *icc_filename = NULL;
static float gamma_value = 1;
static int invert = 0;
static int band_height = 0;
static int lowmemory = 0;
static int quiet = 0;
static int errored = 0;
static fz_colorspace *colorspace = NULL;
static fz_colorspace *oi = NULL;
#if FZ_ENABLE_SPOT_RENDERING
static int spots = SPOTS_OVERPRINT_SIM;
#else
static int spots = SPOTS_NONE;
#endif
static int alpha;
static char *filename;
static int files = 0;
static int num_workers = 0;
static worker_t *workers;
static fz_band_writer *bander = NULL;
static const char *layer_config = NULL;
static struct {
int active;
int started;
fz_context *ctx;
#ifndef DISABLE_MUTHREADS
mu_thread thread;
mu_semaphore start;
mu_semaphore stop;
#endif
int pagenum;
char *filename;
fz_display_list *list;
fz_page *page;
int interptime;
fz_separations *seps;
} bgprint;
static struct {
int count, total;
int min, max;
int mininterp, maxinterp;
int minpage, maxpage;
char *minfilename;
char *maxfilename;
} timing;
static void usage(void)
{
fprintf(stderr,
"mudraw version " FZ_VERSION "\n"
"Usage: mudraw [options] file [pages]\n"
"\t-p -\tpassword\n"
"\n"
"\t-o -\toutput file name (%%d for page number)\n"
"\t-F -\toutput format (default inferred from output file name)\n"
"\t\traster: png, pnm, pam, pbm, pkm, pwg, pcl, ps\n"
"\t\tvector: svg, pdf, trace\n"
"\t\ttext: txt, html, stext\n"
"\n"
"\t-q\tbe quiet (don't print progress messages)\n"
"\t-s -\tshow extra information:\n"
"\t\tm - show memory use\n"
"\t\tt - show timings\n"
"\t\tf - show page features\n"
"\t\t5 - show md5 checksum of rendered image\n"
"\n"
"\t-R -\trotate clockwise (default: 0 degrees)\n"
"\t-r -\tresolution in dpi (default: 72)\n"
"\t-w -\twidth (in pixels) (maximum width if -r is specified)\n"
"\t-h -\theight (in pixels) (maximum height if -r is specified)\n"
"\t-f -\tfit width and/or height exactly; ignore original aspect ratio\n"
"\t-B -\tmaximum band_height (pXm, pcl, pclm, ps, psd and png output only)\n"
#ifndef DISABLE_MUTHREADS
"\t-T -\tnumber of threads to use for rendering (banded mode only)\n"
#else
"\t-T -\tnumber of threads to use for rendering (disabled in this non-threading build)\n"
#endif
"\n"
"\t-W -\tpage width for EPUB layout\n"
"\t-H -\tpage height for EPUB layout\n"
"\t-S -\tfont size for EPUB layout\n"
"\t-U -\tfile name of user stylesheet for EPUB layout\n"
"\t-X\tdisable document styles for EPUB layout\n"
"\n"
"\t-c -\tcolorspace (mono, gray, grayalpha, rgb, rgba, cmyk, cmykalpha, filename of ICC profile)\n"
"\t-e -\tproof icc profile (filename of ICC profile)\n"
"\t-G -\tapply gamma correction\n"
"\t-I\tinvert colors\n"
"\n"
"\t-A -\tnumber of bits of antialiasing (0 to 8)\n"
"\t-A -/-\tnumber of bits of antialiasing (0 to 8) (graphics, text)\n"
"\t-l -\tminimum stroked line width (in pixels)\n"
"\t-D\tdisable use of display list\n"
"\t-i\tignore errors\n"
"\t-L\tlow memory mode (avoid caching, clear objects after each page)\n"
#ifndef DISABLE_MUTHREADS
"\t-P\tparallel interpretation/rendering\n"
#else
"\t-P\tparallel interpretation/rendering (disabled in this non-threading build)\n"
#endif
"\t-N\tdisable ICC workflow (\"N\"o color management)\n"
"\t-O -\tControl spot/overprint rendering\n"
#if FZ_ENABLE_SPOT_RENDERING
"\t\t 0 = No spot rendering\n"
"\t\t 1 = Overprint simulation (default)\n"
"\t\t 2 = Full spot rendering\n"
#else
"\t\t 0 = No spot rendering (default)\n"
"\t\t 1 = Overprint simulation (Disabled in this build)\n"
"\t\t 2 = Full spot rendering (Disabled in this build)\n"
#endif
"\n"
"\t-y l\tList the layer configs to stderr\n"
"\t-y -\tSelect layer config (by number)\n"
"\t-y -{,-}*\tSelect layer config (by number), and toggle the listed entries\n"
"\n"
"\tpages\tcomma separated list of page numbers and ranges\n"
);
exit(1);
}
static int gettime(void)
{
static struct timeval first;
static int once = 1;
struct timeval now;
if (once)
{
gettimeofday(&first, NULL);
once = 0;
}
gettimeofday(&now, NULL);
return (now.tv_sec - first.tv_sec) * 1000 + (now.tv_usec - first.tv_usec) / 1000;
}
static int has_percent_d(char *s)
{
/* find '%[0-9]*d' */
while (*s)
{
if (*s++ == '%')
{
while (*s >= '0' && *s <= '9')
++s;
if (*s == 'd')
return 1;
}
}
return 0;
}
/* Output file level (as opposed to page level) headers */
static void
file_level_headers(fz_context *ctx)
{
if (output_format == OUT_STEXT || output_format == OUT_TRACE)
fz_write_printf(ctx, out, "<?xml version=\"1.0\"?>\n");
if (output_format == OUT_HTML)
fz_print_stext_header_as_html(ctx, out);
if (output_format == OUT_XHTML)
fz_print_stext_header_as_xhtml(ctx, out);
if (output_format == OUT_STEXT || output_format == OUT_TRACE)
fz_write_printf(ctx, out, "<document name=\"%s\">\n", filename);
if (output_format == OUT_PS)
fz_write_ps_file_header(ctx, out);
if (output_format == OUT_PWG)
fz_write_pwg_file_header(ctx, out);
if (output_format == OUT_PCLM)
{
fz_pclm_options opts = { 0 };
fz_parse_pclm_options(ctx, &opts, "compression=flate");
bander = fz_new_pclm_band_writer(ctx, out, &opts);
}
}
static void
file_level_trailers(fz_context *ctx)
{
if (output_format == OUT_STEXT || output_format == OUT_TRACE)
fz_write_printf(ctx, out, "</document>\n");
if (output_format == OUT_HTML)
fz_print_stext_trailer_as_html(ctx, out);
if (output_format == OUT_XHTML)
fz_print_stext_trailer_as_xhtml(ctx, out);
if (output_format == OUT_PS)
fz_write_ps_file_trailer(ctx, out, output_pagenum);
if (output_format == OUT_PCLM)
fz_drop_band_writer(ctx, bander);
}
static void drawband(fz_context *ctx, fz_page *page, fz_display_list *list, fz_matrix ctm, fz_rect tbounds, fz_cookie *cookie, int band_start, fz_pixmap *pix, fz_bitmap **bit)
{
fz_device *dev = NULL;
fz_var(dev);
*bit = NULL;
fz_try(ctx)
{
if (pix->alpha)
fz_clear_pixmap(ctx, pix);
else
fz_clear_pixmap_with_value(ctx, pix, 255);
dev = fz_new_draw_device_with_proof(ctx, fz_identity, pix, proof_cs);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
if (alphabits_graphics == 0)
fz_enable_device_hints(ctx, dev, FZ_DONT_INTERPOLATE_IMAGES);
if (list)
fz_run_display_list(ctx, list, dev, ctm, tbounds, cookie);
else
fz_run_page(ctx, page, dev, ctm, cookie);
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
dev = NULL;
if (invert)
fz_invert_pixmap(ctx, pix);
if (gamma_value != 1)
fz_gamma_pixmap(ctx, pix, gamma_value);
if (((output_format == OUT_PCL || output_format == OUT_PWG) && out_cs == CS_MONO) || (output_format == OUT_PBM) || (output_format == OUT_PKM))
*bit = fz_new_bitmap_from_pixmap_band(ctx, pix, NULL, band_start);
}
fz_catch(ctx)
{
fz_drop_device(ctx, dev);
fz_rethrow(ctx);
}
}
static void dodrawpage(fz_context *ctx, fz_page *page, fz_display_list *list, int pagenum, fz_cookie *cookie, int start, int interptime, char *filename, int bg, fz_separations *seps)
{
fz_rect mediabox;
fz_device *dev = NULL;
fz_var(dev);
if (output_file_per_page)
file_level_headers(ctx);
fz_try(ctx)
{
if (list)
mediabox = fz_bound_display_list(ctx, list);
else
mediabox = fz_bound_page(ctx, page);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
if (output_format == OUT_TRACE)
{
fz_try(ctx)
{
fz_write_printf(ctx, out, "<page mediabox=\"%g %g %g %g\">\n",
mediabox.x0, mediabox.y0, mediabox.x1, mediabox.y1);
dev = fz_new_trace_device(ctx, out);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
if (list)
fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, cookie);
else
fz_run_page(ctx, page, dev, fz_identity, cookie);
fz_write_printf(ctx, out, "</page>\n");
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
else if (output_format == OUT_TEXT || output_format == OUT_HTML || output_format == OUT_XHTML || output_format == OUT_STEXT)
{
fz_stext_page *text = NULL;
float zoom;
fz_matrix ctm;
zoom = resolution / 72;
ctm = fz_pre_scale(fz_rotate(rotation), zoom, zoom);
fz_var(text);
fz_try(ctx)
{
fz_stext_options stext_options;
stext_options.flags = (output_format == OUT_HTML || output_format == OUT_XHTML) ? FZ_STEXT_PRESERVE_IMAGES : 0;
text = fz_new_stext_page(ctx, mediabox);
dev = fz_new_stext_device(ctx, text, &stext_options);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
if (list)
fz_run_display_list(ctx, list, dev, ctm, fz_infinite_rect, cookie);
else
fz_run_page(ctx, page, dev, ctm, cookie);
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
dev = NULL;
if (output_format == OUT_STEXT)
{
fz_print_stext_page_as_xml(ctx, out, text, pagenum);
}
else if (output_format == OUT_HTML)
{
fz_print_stext_page_as_html(ctx, out, text, pagenum);
}
else if (output_format == OUT_XHTML)
{
fz_print_stext_page_as_xhtml(ctx, out, text, pagenum);
}
else if (output_format == OUT_TEXT)
{
fz_print_stext_page_as_text(ctx, out, text);
fz_write_printf(ctx, out, "\f\n");
}
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
fz_drop_stext_page(ctx, text);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
#if FZ_ENABLE_PDF
else if (output_format == OUT_PDF)
{
fz_buffer *contents = NULL;
pdf_obj *resources = NULL;
fz_var(contents);
fz_var(resources);
fz_try(ctx)
{
pdf_obj *page_obj;
dev = pdf_page_write(ctx, pdfout, mediabox, &resources, &contents);
if (list)
fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, cookie);
else
fz_run_page(ctx, page, dev, fz_identity, cookie);
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
dev = NULL;
page_obj = pdf_add_page(ctx, pdfout, mediabox, rotation, resources, contents);
pdf_insert_page(ctx, pdfout, -1, page_obj);
pdf_drop_obj(ctx, page_obj);
}
fz_always(ctx)
{
pdf_drop_obj(ctx, resources);
fz_drop_buffer(ctx, contents);
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
#endif
else if (output_format == OUT_SVG)
{
float zoom;
fz_matrix ctm;
fz_rect tbounds;
char buf[512];
fz_output *out = NULL;
fz_var(out);
zoom = resolution / 72;
ctm = fz_pre_rotate(fz_scale(zoom, zoom), rotation);
tbounds = fz_transform_rect(mediabox, ctm);
fz_try(ctx)
{
if (!output || !strcmp(output, "-"))
out = fz_stdout(ctx);
else
{
fz_snprintf(buf, sizeof(buf), output, pagenum);
out = fz_new_output_with_path(ctx, buf, 0);
}
dev = fz_new_svg_device(ctx, out, tbounds.x1-tbounds.x0, tbounds.y1-tbounds.y0, FZ_SVG_TEXT_AS_PATH, 1);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
if (list)
fz_run_display_list(ctx, list, dev, ctm, tbounds, cookie);
else
fz_run_page(ctx, page, dev, ctm, cookie);
fz_close_device(ctx, dev);
fz_close_output(ctx, out);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
fz_drop_output(ctx, out);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
else
{
float zoom;
fz_matrix ctm;
fz_rect tbounds;
fz_irect ibounds;
fz_pixmap *pix = NULL;
int w, h;
fz_bitmap *bit = NULL;
fz_var(pix);
fz_var(bander);
fz_var(bit);
zoom = resolution / 72;
ctm = fz_pre_scale(fz_rotate(rotation), zoom, zoom);
tbounds = fz_transform_rect(mediabox, ctm);
ibounds = fz_round_rect(tbounds);
/* 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 = ibounds.x1 - ibounds.x0;
if (w && t <= w)
w = 0;
t = ibounds.y1 - ibounds.y0;
if (h && t <= h)
h = 0;
}
/* Now w or h will be 0 unless they need to be enforced. */
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
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;
}
scale_mat = fz_scale(scalex, scaley);
ctm = fz_concat(ctm, scale_mat);
tbounds = fz_transform_rect(mediabox, ctm);
}
ibounds = fz_round_rect(tbounds);
tbounds = fz_rect_from_irect(ibounds);
fz_try(ctx)
{
fz_irect band_ibounds = ibounds;
int band, bands = 1;
int totalheight = ibounds.y1 - ibounds.y0;
int drawheight = totalheight;
if (band_height != 0)
{
/* Banded rendering; we'll only render to a
* given height at a time. */
drawheight = band_height;
if (totalheight > band_height)
band_ibounds.y1 = band_ibounds.y0 + band_height;
bands = (totalheight + band_height-1)/band_height;
tbounds.y1 = tbounds.y0 + band_height + 2;
DEBUG_THREADS(("Using %d Bands\n", bands));
}
if (num_workers > 0)
{
for (band = 0; band < fz_mini(num_workers, bands); band++)
{
workers[band].band = band;
workers[band].ctm = ctm;
workers[band].tbounds = tbounds;
memset(&workers[band].cookie, 0, sizeof(fz_cookie));
workers[band].list = list;
workers[band].pix = fz_new_pixmap_with_bbox(ctx, colorspace, band_ibounds, seps, alpha);
fz_set_pixmap_resolution(ctx, workers[band].pix, resolution, resolution);
#ifndef DISABLE_MUTHREADS
DEBUG_THREADS(("Worker %d, Pre-triggering band %d\n", band, band));
mu_trigger_semaphore(&workers[band].start);
#endif
ctm.f -= drawheight;
}
pix = workers[0].pix;
}
else
{
pix = fz_new_pixmap_with_bbox(ctx, colorspace, band_ibounds, seps, alpha);
fz_set_pixmap_resolution(ctx, pix, resolution, resolution);
}
/* Output any page level headers (for banded formats) */
if (output)
{
if (output_format == OUT_PGM || output_format == OUT_PPM || output_format == OUT_PNM)
bander = fz_new_pnm_band_writer(ctx, out);
else if (output_format == OUT_PAM)
bander = fz_new_pam_band_writer(ctx, out);
else if (output_format == OUT_PNG)
bander = fz_new_png_band_writer(ctx, out);
else if (output_format == OUT_PBM)
bander = fz_new_pbm_band_writer(ctx, out);
else if (output_format == OUT_PKM)
bander = fz_new_pkm_band_writer(ctx, out);
else if (output_format == OUT_PS)
bander = fz_new_ps_band_writer(ctx, out);
else if (output_format == OUT_PSD)
bander = fz_new_psd_band_writer(ctx, out);
else if (output_format == OUT_PWG)
{
if (out_cs == CS_MONO)
bander = fz_new_mono_pwg_band_writer(ctx, out, NULL);
else
bander = fz_new_pwg_band_writer(ctx, out, NULL);
}
else if (output_format == OUT_PCL)
{
if (out_cs == CS_MONO)
bander = fz_new_mono_pcl_band_writer(ctx, out, NULL);
else
bander = fz_new_color_pcl_band_writer(ctx, out, NULL);
}
if (bander)
{
fz_write_header(ctx, bander, pix->w, totalheight, pix->n, pix->alpha, pix->xres, pix->yres, output_pagenum++, pix->colorspace, pix->seps);
}
}
for (band = 0; band < bands; band++)
{
if (num_workers > 0)
{
worker_t *w = &workers[band % num_workers];
#ifndef DISABLE_MUTHREADS
DEBUG_THREADS(("Waiting for worker %d to complete band %d\n", w->num, band));
mu_wait_semaphore(&w->stop);
#endif
pix = w->pix;
bit = w->bit;
w->bit = NULL;
cookie->errors += w->cookie.errors;
}
else
drawband(ctx, page, list, ctm, tbounds, cookie, band * band_height, pix, &bit);
if (output)
{
if (bander)
fz_write_band(ctx, bander, bit ? bit->stride : pix->stride, drawheight, bit ? bit->samples : pix->samples);
fz_drop_bitmap(ctx, bit);
bit = NULL;
}
if (num_workers > 0 && band + num_workers < bands)
{
worker_t *w = &workers[band % num_workers];
w->band = band + num_workers;
w->ctm = ctm;
w->tbounds = tbounds;
memset(&w->cookie, 0, sizeof(fz_cookie));
#ifndef DISABLE_MUTHREADS
DEBUG_THREADS(("Triggering worker %d for band %d\n", w->num, w->band));
mu_trigger_semaphore(&w->start);
#endif
}
ctm.f -= drawheight;
}
/* FIXME */
if (showmd5)
{
unsigned char digest[16];
int i;
fz_md5_pixmap(ctx, pix, digest);
fprintf(stderr, " ");
for (i = 0; i < 16; i++)
fprintf(stderr, "%02x", digest[i]);
}
}
fz_always(ctx)
{
if (output_format != OUT_PCLM)
fz_drop_band_writer(ctx, bander);
fz_drop_bitmap(ctx, bit);
bit = NULL;
if (num_workers > 0)
{
int band;
for (band = 0; band < num_workers; band++)
fz_drop_pixmap(ctx, workers[band].pix);
}
else
fz_drop_pixmap(ctx, pix);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
fz_drop_display_list(ctx, list);
if (output_file_per_page)
file_level_trailers(ctx);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
if (showtime)
{
int end = gettime();
int diff = end - start;
if (bg)
{
if (diff + interptime < timing.min)
{
timing.min = diff + interptime;
timing.mininterp = interptime;
timing.minpage = pagenum;
timing.minfilename = filename;
}
if (diff + interptime > timing.max)
{
timing.max = diff + interptime;
timing.maxinterp = interptime;
timing.maxpage = pagenum;
timing.maxfilename = filename;
}
timing.count ++;
fprintf(stderr, " %dms (interpretation) %dms (rendering) %dms (total)", interptime, diff, diff + interptime);
}
else
{
if (diff < timing.min)
{
timing.min = diff;
timing.minpage = pagenum;
timing.minfilename = filename;
}
if (diff > timing.max)
{
timing.max = diff;
timing.maxpage = pagenum;
timing.maxfilename = filename;
}
timing.total += diff;
timing.count ++;
fprintf(stderr, " %dms", diff);
}
}
if (!quiet || showfeatures || showtime || showmd5)
fprintf(stderr, "\n");
if (lowmemory)
fz_empty_store(ctx);
if (showmemory)
fz_dump_glyph_cache_stats(ctx);
fz_flush_warnings(ctx);
if (cookie->errors)
errored = 1;
}
static void bgprint_flush(void)
{
if (!bgprint.active || !bgprint.started)
return;
#ifndef DISABLE_MUTHREADS
mu_wait_semaphore(&bgprint.stop);
#endif
bgprint.started = 0;
}
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_separations *seps = NULL;
const char *features = "";
fz_var(list);
fz_var(dev);
fz_var(seps);
start = (showtime ? gettime() : 0);
page = fz_load_page(ctx, doc, pagenum - 1);
if (spots != SPOTS_NONE)
{
fz_try(ctx)
{
seps = fz_page_separations(ctx, page);
if (seps)
{
int i, n = fz_count_separations(ctx, seps);
if (spots == SPOTS_FULL)
for (i = 0; i < n; i++)
fz_set_separation_behavior(ctx, seps, i, FZ_SEPARATION_SPOT);
else
for (i = 0; i < n; i++)
fz_set_separation_behavior(ctx, seps, i, FZ_SEPARATION_COMPOSITE);
}
else if (fz_page_uses_overprint(ctx, page))
{
/* This page uses overprint, so we need an empty
* sep object to force the overprint simulation on. */
seps = fz_new_separations(ctx, 0);
}
else if (oi && fz_colorspace_n(ctx, oi) != fz_colorspace_n(ctx, colorspace))
{
/* We have an output intent, and it's incompatible
* with the colorspace our device needs. Force the
* overprint simulation on, because this ensures that
* we 'simulate' the output intent too. */
seps = fz_new_separations(ctx, 0);
}
}
fz_catch(ctx)
{
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
}
if (uselist)
{
fz_try(ctx)
{
list = fz_new_display_list(ctx, fz_bound_page(ctx, page));
dev = fz_new_list_device(ctx, list);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
fz_run_page(ctx, page, dev, fz_identity, &cookie);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
if (bgprint.active && showtime)
{
int end = gettime();
start = end - start;
}
}
if (showfeatures)
{
int iscolor;
dev = fz_new_test_device(ctx, &iscolor, 0.02f, 0, NULL);
if (lowmemory)
fz_enable_device_hints(ctx, dev, FZ_NO_CACHE);
fz_try(ctx)
{
if (list)
fz_run_display_list(ctx, list, dev, fz_identity, fz_infinite_rect, NULL);
else
fz_run_page(ctx, page, dev, fz_identity, &cookie);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_drop_separations(ctx, seps);
fz_drop_page(ctx, page);
fz_rethrow(ctx);
}
features = iscolor ? " color" : " grayscale";
}
if (output_file_per_page)
{
char text_buffer[512];
bgprint_flush();
if (out)
{
fz_close_output(ctx, out);
fz_drop_output(ctx, out);
}
fz_snprintf(text_buffer, sizeof(text_buffer), output, pagenum);
out = fz_new_output_with_path(ctx, text_buffer, 0);
}
if (bgprint.active)
{
bgprint_flush();
if (bgprint.active)
{
if (!quiet || showfeatures || showtime || showmd5)
fprintf(stderr, "page %s %d%s", filename, pagenum, features);
}
bgprint.started = 1;
bgprint.page = page;
bgprint.list = list;
bgprint.seps = seps;
bgprint.filename = filename;
bgprint.pagenum = pagenum;
bgprint.interptime = start;
#ifndef DISABLE_MUTHREADS
mu_trigger_semaphore(&bgprint.start);
#else
fz_drop_display_list(ctx, list);
fz_drop_page(ctx, page);
#endif
}
else
{
if (!quiet || showfeatures || showtime || showmd5)
fprintf(stderr, "page %s %d%s", filename, pagenum, features);
dodrawpage(ctx, page, list, pagenum, &cookie, start, 0, filename, 0, seps);
}
}
static void drawrange(fz_context *ctx, fz_document *doc, const char *range)
{
int page, spage, epage, pagecount;
pagecount = fz_count_pages(ctx, doc);
while ((range = fz_parse_page_range(ctx, range, &spage, &epage, pagecount)))
{
if (spage < epage)
for (page = spage; page <= epage; page++)
{
fz_try(ctx)
drawpage(ctx, doc, page);
fz_catch(ctx)
{
if (ignore_errors)
fz_warn(ctx, "ignoring error on page %d in '%s'", page, filename);
else
fz_rethrow(ctx);
}
}
else
for (page = spage; page >= epage; page--)
{
fz_try(ctx)
drawpage(ctx, doc, page);
fz_catch(ctx)
{
if (ignore_errors)
fz_warn(ctx, "ignoring error on page %d in '%s'", page, filename);
else
fz_rethrow(ctx);
}
}
}
}
static int
parse_colorspace(const char *name)
{
int i;
for (i = 0; i < (int)nelem(cs_name_table); i++)
{
if (!strcmp(name, cs_name_table[i].name))
return cs_name_table[i].colorspace;
}
/* Assume ICC. We will error out later if not the case. */
icc_filename = name;
return CS_ICC;
}
typedef struct
{
size_t size;
#if defined(_M_IA64) || defined(_M_AMD64)
size_t align;
#endif
} trace_header;
typedef struct
{
size_t current;
size_t peak;
size_t total;
} trace_info;
static void *
trace_malloc(void *arg, size_t size)
{
trace_info *info = (trace_info *) arg;
trace_header *p;
if (size == 0)
return NULL;
p = malloc(size + sizeof(trace_header));
if (p == NULL)
return NULL;
p[0].size = size;
info->current += size;
info->total += size;
if (info->current > info->peak)
info->peak = info->current;
return (void *)&p[1];
}
static void
trace_free(void *arg, void *p_)
{
trace_info *info = (trace_info *) arg;
trace_header *p = (trace_header *)p_;
if (p == NULL)
return;
info->current -= p[-1].size;
free(&p[-1]);
}
static void *
trace_realloc(void *arg, void *p_, size_t size)
{
trace_info *info = (trace_info *) arg;
trace_header *p = (trace_header *)p_;
size_t oldsize;
if (size == 0)
{
trace_free(arg, p_);
return NULL;
}
if (p == NULL)
return trace_malloc(arg, size);
oldsize = p[-1].size;
p = realloc(&p[-1], size + sizeof(trace_header));
if (p == NULL)
return NULL;
info->current += size - oldsize;
if (size > oldsize)
info->total += size - oldsize;
if (info->current > info->peak)
info->peak = info->current;
p[0].size = size;
return &p[1];
}
#ifndef DISABLE_MUTHREADS
static void worker_thread(void *arg)
{
worker_t *me = (worker_t *)arg;
do
{
DEBUG_THREADS(("Worker %d waiting\n", me->num));
mu_wait_semaphore(&me->start);
DEBUG_THREADS(("Worker %d woken for band %d\n", me->num, me->band));
if (me->band >= 0)
drawband(me->ctx, NULL, me->list, me->ctm, me->tbounds, &me->cookie, me->band * band_height, me->pix, &me->bit);
DEBUG_THREADS(("Worker %d completed band %d\n", me->num, me->band));
mu_trigger_semaphore(&me->stop);
}
while (me->band >= 0);
}
static void bgprint_worker(void *arg)
{
fz_cookie cookie = { 0 };
int pagenum;
(void)arg;
do
{
DEBUG_THREADS(("BGPrint waiting\n"));
mu_wait_semaphore(&bgprint.start);
pagenum = bgprint.pagenum;
DEBUG_THREADS(("BGPrint woken for pagenum %d\n", pagenum));
if (pagenum >= 0)
{
int start = gettime();
memset(&cookie, 0, sizeof(cookie));
dodrawpage(bgprint.ctx, bgprint.page, bgprint.list, pagenum, &cookie, start, bgprint.interptime, bgprint.filename, 1, bgprint.seps);
}
DEBUG_THREADS(("BGPrint completed page %d\n", pagenum));
mu_trigger_semaphore(&bgprint.stop);
}
while (pagenum >= 0);
}
#endif
static inline int iswhite(int ch)
{
return
ch == '\011' || ch == '\012' ||
ch == '\014' || ch == '\015' || ch == '\040';
}
static void apply_layer_config(fz_context *ctx, fz_document *doc, const char *lc)
{
#if FZ_ENABLE_PDF
pdf_document *pdoc = pdf_specifics(ctx, doc);
int config;
int n, j;
pdf_layer_config info;
if (!pdoc)
{
fz_warn(ctx, "Only PDF files have layers");
return;
}
while (iswhite(*lc))
lc++;
if (*lc == 0 || *lc == 'l')
{
int num_configs = pdf_count_layer_configs(ctx, pdoc);
fprintf(stderr, "Layer configs:\n");
for (config = 0; config < num_configs; config++)
{
fprintf(stderr, " %s%d:", config < 10 ? " " : "", config);
pdf_layer_config_info(ctx, pdoc, config, &info);
if (info.name)
fprintf(stderr, " Name=\"%s\"", info.name);
if (info.creator)
fprintf(stderr, " Creator=\"%s\"", info.creator);
fprintf(stderr, "\n");
}
return;
}
/* Read the config number */
if (*lc < '0' || *lc > '9')
{
fprintf(stderr, "cannot find number expected for -y\n");
return;
}
config = fz_atoi(lc);
pdf_select_layer_config(ctx, pdoc, config);
while (*lc)
{
int item;
/* Skip over the last number we read (in the fz_atoi) */
while (*lc >= '0' && *lc <= '9')
lc++;
while (iswhite(*lc))
lc++;
if (*lc != ',')
break;
lc++;
while (iswhite(*lc))
lc++;
if (*lc < '0' || *lc > '9')
{
fprintf(stderr, "Expected a number for UI item to toggle\n");
return;
}
item = fz_atoi(lc);
pdf_toggle_layer_config_ui(ctx, pdoc, item);
}
/* Now list the final state of the config */
fprintf(stderr, "Layer Config %d:\n", config);
pdf_layer_config_info(ctx, pdoc, config, &info);
if (info.name)
fprintf(stderr, " Name=\"%s\"", info.name);
if (info.creator)
fprintf(stderr, " Creator=\"%s\"", info.creator);
fprintf(stderr, "\n");
n = pdf_count_layer_config_ui(ctx, pdoc);
for (j = 0; j < n; j++)
{
pdf_layer_config_ui ui;
pdf_layer_config_ui_info(ctx, pdoc, j, &ui);
fprintf(stderr, "%s%d: ", j < 10 ? " " : "", j);
while (ui.depth > 0)
{
ui.depth--;
fprintf(stderr, " ");
}
if (ui.type == PDF_LAYER_UI_CHECKBOX)
fprintf(stderr, " [%c] ", ui.selected ? 'x' : ' ');
else if (ui.type == PDF_LAYER_UI_RADIOBOX)
fprintf(stderr, " (%c) ", ui.selected ? 'x' : ' ');
if (ui.text)
fprintf(stderr, "%s", ui.text);
if (ui.type != PDF_LAYER_UI_LABEL && ui.locked)
fprintf(stderr, " <locked>");
fprintf(stderr, "\n");
}
#endif
}
#ifdef MUDRAW_STANDALONE
int main(int argc, char **argv)
#else
int mudraw_main(int argc, char **argv)
#endif
{
char *password = "";
fz_document *doc = NULL;
int c;
fz_context *ctx;
trace_info info = { 0, 0, 0 };
fz_alloc_context alloc_ctx = { &info, trace_malloc, trace_realloc, trace_free };
fz_locks_context *locks = NULL;
fz_var(doc);
while ((c = fz_getopt(argc, argv, "qp:o:F:R:r:w:h:fB:c:e:G:Is:A:DiW:H:S:T:U:XLvPl:y:NO:")) != -1)
{
switch (c)
{
default: usage(); break;
case 'q': quiet = 1; break;
case 'p': password = fz_optarg; break;
case 'o': output = fz_optarg; break;
case 'F': format = fz_optarg; break;
case 'R': rotation = fz_atof(fz_optarg); break;
case 'r': resolution = fz_atof(fz_optarg); res_specified = 1; break;
case 'w': width = fz_atof(fz_optarg); break;
case 'h': height = fz_atof(fz_optarg); break;
case 'f': fit = 1; break;
case 'B': band_height = atoi(fz_optarg); break;
case 'c': out_cs = parse_colorspace(fz_optarg); break;
case 'e': proof_filename = fz_optarg; break;
case 'G': gamma_value = fz_atof(fz_optarg); break;
case 'I': invert++; break;
case 'W': layout_w = fz_atof(fz_optarg); break;
case 'H': layout_h = fz_atof(fz_optarg); break;
case 'S': layout_em = fz_atof(fz_optarg); break;
case 'U': layout_css = fz_optarg; break;
case 'X': layout_use_doc_css = 0; break;
case 'O': spots = fz_atof(fz_optarg);
#ifndef FZ_ENABLE_SPOT_RENDERING
fprintf(stderr, "Spot rendering/Overprint/Overprint simulation not enabled in this build\n");
spots = SPOTS_NONE;
#endif
break;
case 's':
if (strchr(fz_optarg, 't')) ++showtime;
if (strchr(fz_optarg, 'm')) ++showmemory;
if (strchr(fz_optarg, 'f')) ++showfeatures;
if (strchr(fz_optarg, '5')) ++showmd5;
break;
case 'A':
{
char *sep;
alphabits_graphics = atoi(fz_optarg);
sep = strchr(fz_optarg, '/');
if (sep)
alphabits_text = atoi(sep+1);
else
alphabits_text = alphabits_graphics;
break;
}
case 'D': uselist = 0; break;
case 'l': min_line_width = fz_atof(fz_optarg); break;
case 'i': ignore_errors = 1; break;
case 'N': no_icc = 1; break;
case 'T':
#ifndef DISABLE_MUTHREADS
num_workers = atoi(fz_optarg); break;
#else
fprintf(stderr, "Threads not enabled in this build\n");
break;
#endif
case 'L': lowmemory = 1; break;
case 'P':
#ifndef DISABLE_MUTHREADS
bgprint.active = 1; break;
#else
fprintf(stderr, "Threads not enabled in this build\n");
break;
#endif
case 'y': layer_config = fz_optarg; break;
case 'v': fprintf(stderr, "mudraw version %s\n", FZ_VERSION); return 1;
}
}
if (fz_optind == argc)
usage();
if (num_workers > 0)
{
if (uselist == 0)
{
fprintf(stderr, "cannot use multiple threads without using display list\n");
exit(1);
}
if (band_height == 0)
{
fprintf(stderr, "Using multiple threads without banding is pointless\n");
}
}
if (bgprint.active)
{
if (uselist == 0)
{
fprintf(stderr, "cannot bgprint without using display list\n");
exit(1);
}
}
#ifndef DISABLE_MUTHREADS
locks = init_mudraw_locks();
if (locks == NULL)
{
fprintf(stderr, "mutex initialisation failed\n");
exit(1);
}
#endif
ctx = fz_new_context((showmemory == 0 ? NULL : &alloc_ctx), locks, (lowmemory ? 1 : FZ_STORE_DEFAULT));
if (!ctx)
{
fprintf(stderr, "cannot initialise context\n");
exit(1);
}
fz_try(ctx)
{
if (proof_filename)
{
fz_buffer *proof_buffer = fz_read_file(ctx, proof_filename);
proof_cs = fz_new_icc_colorspace(ctx, FZ_COLORSPACE_NONE, 0, NULL, proof_buffer);
fz_drop_buffer(ctx, proof_buffer);
}
fz_set_text_aa_level(ctx, alphabits_text);
fz_set_graphics_aa_level(ctx, alphabits_graphics);
fz_set_graphics_min_line_width(ctx, min_line_width);
if (no_icc)
fz_disable_icc(ctx);
else
fz_enable_icc(ctx);
#ifndef DISABLE_MUTHREADS
if (bgprint.active)
{
int fail = 0;
bgprint.ctx = fz_clone_context(ctx);
fail |= mu_create_semaphore(&bgprint.start);
fail |= mu_create_semaphore(&bgprint.stop);
fail |= mu_create_thread(&bgprint.thread, bgprint_worker, NULL);
if (fail)
{
fprintf(stderr, "bgprint startup failed\n");
exit(1);
}
}
if (num_workers > 0)
{
int i;
int fail = 0;
workers = fz_calloc(ctx, num_workers, sizeof(*workers));
for (i = 0; i < num_workers; i++)
{
workers[i].ctx = fz_clone_context(ctx);
workers[i].num = i;
fail |= mu_create_semaphore(&workers[i].start);
fail |= mu_create_semaphore(&workers[i].stop);
fail |= mu_create_thread(&workers[i].thread, worker_thread, &workers[i]);
}
if (fail)
{
fprintf(stderr, "worker startup failed\n");
exit(1);
}
}
#endif /* DISABLE_MUTHREADS */
if (layout_css)
{
fz_buffer *buf = fz_read_file(ctx, layout_css);
fz_set_user_css(ctx, fz_string_from_buffer(ctx, buf));
fz_drop_buffer(ctx, buf);
}
fz_set_use_document_css(ctx, layout_use_doc_css);
/* Determine output type */
if (band_height < 0)
{
fprintf(stderr, "Bandheight must be > 0\n");
exit(1);
}
output_format = OUT_PNG;
if (format)
{
int i;
for (i = 0; i < (int)nelem(suffix_table); i++)
{
if (!strcmp(format, suffix_table[i].suffix+1))
{
output_format = suffix_table[i].format;
if (spots == SPOTS_FULL && suffix_table[i].spots == 0)
{
fprintf(stderr, "Output format '%s' does not support spot rendering.\nDoing overprint simulation instead.\n", suffix_table[i].suffix+1);
spots = SPOTS_OVERPRINT_SIM;
}
break;
}
}
if (i == (int)nelem(suffix_table))
{
fprintf(stderr, "Unknown output format '%s'\n", format);
exit(1);
}
}
else if (output)
{
char *suffix = output;
int i;
for (i = 0; i < (int)nelem(suffix_table); i++)
{
char *s = strstr(suffix, suffix_table[i].suffix);
if (s != NULL)
{
suffix = s+1;
output_format = suffix_table[i].format;
if (spots == SPOTS_FULL && suffix_table[i].spots == 0)
{
fprintf(stderr, "Output format '%s' does not support spot rendering.\nDoing overprint simulation instead.\n", suffix_table[i].suffix+1);
spots = SPOTS_OVERPRINT_SIM;
}
i = 0;
}
}
}
if (band_height)
{
if (output_format != OUT_PAM && output_format != OUT_PGM && output_format != OUT_PPM && output_format != OUT_PNM && output_format != OUT_PNG && output_format != OUT_PBM && output_format != OUT_PKM && output_format != OUT_PCL && output_format != OUT_PCLM && output_format != OUT_PS && output_format != OUT_PSD)
{
fprintf(stderr, "Banded operation only possible with PxM, PCL, PCLM, PS, PSD, and PNG outputs\n");
exit(1);
}
if (showmd5)
{
fprintf(stderr, "Banded operation not compatible with MD5\n");
exit(1);
}
}
{
int i, j;
for (i = 0; i < (int)nelem(format_cs_table); i++)
{
if (format_cs_table[i].format == output_format)
{
if (out_cs == CS_UNSET)
out_cs = format_cs_table[i].default_cs;
for (j = 0; j < (int)nelem(format_cs_table[i].permitted_cs); j++)
{
if (format_cs_table[i].permitted_cs[j] == out_cs)
break;
}
if (j == (int)nelem(format_cs_table[i].permitted_cs))
{
fprintf(stderr, "Unsupported colorspace for this format\n");
exit(1);
}
}
}
}
alpha = 1;
switch (out_cs)
{
case CS_MONO:
case CS_GRAY:
case CS_GRAY_ALPHA:
colorspace = fz_device_gray(ctx);
alpha = (out_cs == CS_GRAY_ALPHA);
break;
case CS_RGB:
case CS_RGB_ALPHA:
colorspace = fz_device_rgb(ctx);
alpha = (out_cs == CS_RGB_ALPHA);
break;
case CS_CMYK:
case CS_CMYK_ALPHA:
colorspace = fz_device_cmyk(ctx);
alpha = (out_cs == CS_CMYK_ALPHA);
break;
case CS_ICC:
fz_try(ctx)
{
fz_buffer *icc_buffer = fz_read_file(ctx, icc_filename);
colorspace = fz_new_icc_colorspace(ctx, FZ_COLORSPACE_NONE, 0, NULL, icc_buffer);
fz_drop_buffer(ctx, icc_buffer);
}
fz_catch(ctx)
{
fprintf(stderr, "Invalid ICC destination color space\n");
exit(1);
}
if (colorspace == NULL)
{
fprintf(stderr, "Invalid ICC destination color space\n");
exit(1);
}
alpha = 0;
break;
default:
fprintf(stderr, "Unknown colorspace!\n");
exit(1);
break;
}
if (out_cs != CS_ICC)
colorspace = fz_keep_colorspace(ctx, colorspace);
else
{
int i, j, okay;
/* Check to make sure this icc profile is ok with the output format */
okay = 0;
for (i = 0; i < (int)nelem(format_cs_table); i++)
{
if (format_cs_table[i].format == output_format)
{
for (j = 0; j < (int)nelem(format_cs_table[i].permitted_cs); j++)
{
switch (format_cs_table[i].permitted_cs[j])
{
case CS_MONO:
case CS_GRAY:
case CS_GRAY_ALPHA:
if (fz_colorspace_is_gray(ctx, colorspace))
okay = 1;
break;
case CS_RGB:
case CS_RGB_ALPHA:
if (fz_colorspace_is_rgb(ctx, colorspace))
okay = 1;
break;
case CS_CMYK:
case CS_CMYK_ALPHA:
if (fz_colorspace_is_cmyk(ctx, colorspace))
okay = 1;
break;
}
}
}
}
if (!okay)
{
fprintf(stderr, "ICC profile uses a colorspace that cannot be used for this format\n");
exit(1);
}
}
#if FZ_ENABLE_PDF
if (output_format == OUT_PDF)
{
pdfout = pdf_create_document(ctx);
}
else
#endif
if (output_format == OUT_SVG)
{
/* SVG files are always opened for each page. Do not open "output". */
}
else if (output && (output[0] != '-' || output[1] != 0) && *output != 0)
{
if (has_percent_d(output))
output_file_per_page = 1;
else
out = fz_new_output_with_path(ctx, output, 0);
}
else
{
quiet = 1; /* automatically be quiet if printing to stdout */
#ifdef _WIN32
/* Windows specific code to make stdout binary. */
if (output_format != OUT_TEXT && output_format != OUT_STEXT && output_format != OUT_HTML && output_format != OUT_XHTML && output_format != OUT_TRACE)
setmode(fileno(stdout), O_BINARY);
#endif
out = fz_stdout(ctx);
}
filename = argv[fz_optind];
if (!output_file_per_page)
file_level_headers(ctx);
timing.count = 0;
timing.total = 0;
timing.min = 1 << 30;
timing.max = 0;
timing.mininterp = 1 << 30;
timing.maxinterp = 0;
timing.minpage = 0;
timing.maxpage = 0;
timing.minfilename = "";
timing.maxfilename = "";
if (showtime && bgprint.active)
timing.total = gettime();
fz_try(ctx)
{
fz_register_document_handlers(ctx);
while (fz_optind < argc)
{
fz_try(ctx)
{
filename = argv[fz_optind++];
files++;
doc = fz_open_document(ctx, filename);
if (fz_needs_password(ctx, doc))
{
if (!fz_authenticate_password(ctx, doc, password))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", filename);
}
/* Once document is open check for output intent colorspace */
oi = fz_document_output_intent(ctx, doc);
if (oi)
{
/* See if we had explicitly set a profile to render */
if (out_cs != CS_ICC)
{
/* In this case, we want to render to the output intent
* color space if the number of channels is the same */
if (fz_colorspace_n(ctx, oi) == fz_colorspace_n(ctx, colorspace))
{
fz_drop_colorspace(ctx, colorspace);
colorspace = fz_keep_colorspace(ctx, oi);
}
}
}
fz_layout_document(ctx, doc, layout_w, layout_h, layout_em);
if (layer_config)
apply_layer_config(ctx, doc, layer_config);
if (fz_optind == argc || !fz_is_page_range(ctx, argv[fz_optind]))
drawrange(ctx, doc, "1-N");
if (fz_optind < argc && fz_is_page_range(ctx, argv[fz_optind]))
drawrange(ctx, doc, argv[fz_optind++]);
bgprint_flush();
}
fz_always(ctx)
{
fz_drop_document(ctx, doc);
doc = NULL;
}
fz_catch(ctx)
{
if (!ignore_errors)
fz_rethrow(ctx);
bgprint_flush();
fz_warn(ctx, "ignoring error in '%s'", filename);
}
}
}
fz_catch(ctx)
{
bgprint_flush();
fz_drop_document(ctx, doc);
fprintf(stderr, "error: cannot draw '%s'\n", filename);
errored = 1;
}
if (!output_file_per_page)
file_level_trailers(ctx);
#if FZ_ENABLE_PDF
if (output_format == OUT_PDF)
{
if (!output)
output = "out.pdf";
pdf_save_document(ctx, pdfout, output, NULL);
pdf_drop_document(ctx, pdfout);
}
else
#endif
{
fz_close_output(ctx, out);
fz_drop_output(ctx, out);
out = NULL;
}
if (showtime && timing.count > 0)
{
if (bgprint.active)
timing.total = gettime() - timing.total;
if (files == 1)
{
fprintf(stderr, "total %dms / %d pages for an average of %dms\n",
timing.total, timing.count, timing.total / timing.count);
if (bgprint.active)
{
fprintf(stderr, "fastest page %d: %dms (interpretation) %dms (rendering) %dms(total)\n",
timing.minpage, timing.mininterp, timing.min - timing.mininterp, timing.min);
fprintf(stderr, "slowest page %d: %dms (interpretation) %dms (rendering) %dms(total)\n",
timing.maxpage, timing.maxinterp, timing.max - timing.maxinterp, timing.max);
}
else
{
fprintf(stderr, "fastest page %d: %dms\n", timing.minpage, timing.min);
fprintf(stderr, "slowest page %d: %dms\n", timing.maxpage, timing.max);
}
}
else
{
fprintf(stderr, "total %dms / %d pages for an average of %dms in %d files\n",
timing.total, timing.count, timing.total / timing.count, files);
fprintf(stderr, "fastest page %d: %dms (%s)\n", timing.minpage, timing.min, timing.minfilename);
fprintf(stderr, "slowest page %d: %dms (%s)\n", timing.maxpage, timing.max, timing.maxfilename);
}
}
#ifndef DISABLE_MUTHREADS
if (num_workers > 0)
{
int i;
for (i = 0; i < num_workers; i++)
{
workers[i].band = -1;
mu_trigger_semaphore(&workers[i].start);
mu_wait_semaphore(&workers[i].stop);
mu_destroy_semaphore(&workers[i].start);
mu_destroy_semaphore(&workers[i].stop);
mu_destroy_thread(&workers[i].thread);
fz_drop_context(workers[i].ctx);
}
fz_free(ctx, workers);
}
if (bgprint.active)
{
bgprint.pagenum = -1;
mu_trigger_semaphore(&bgprint.start);
mu_wait_semaphore(&bgprint.stop);
mu_destroy_semaphore(&bgprint.start);
mu_destroy_semaphore(&bgprint.stop);
mu_destroy_thread(&bgprint.thread);
fz_drop_context(bgprint.ctx);
}
#endif /* DISABLE_MUTHREADS */
}
fz_always(ctx)
{
fz_drop_colorspace(ctx, colorspace);
fz_drop_colorspace(ctx, proof_cs);
}
fz_catch(ctx)
{
}
fz_drop_context(ctx);
#ifndef DISABLE_MUTHREADS
fin_mudraw_locks();
#endif /* DISABLE_MUTHREADS */
if (showmemory)
{
char buf[100];
fz_snprintf(buf, sizeof buf, "Memory use total=%zu peak=%zu current=%zu", info.total, info.peak, info.current);
fprintf(stderr, "%s\n", buf);
}
return (errored != 0);
}
Reference in New Issue View Git Blame Copy Permalink