void pdfapp_open_progressive(pdfapp_t *app, char *filename, int reload, int bps)
{
fz_context *ctx = app->ctx;
char *password = "";
fz_try(ctx)
{
fz_register_document_handlers(ctx);
#ifdef HAVE_CURL
if (!strncmp(filename, "http://", 7))
{
app->stream = fz_stream_from_curl(ctx, filename, pdfapp_more_data, app);
while (1)
{
fz_try(ctx)
{
fz_seek(ctx, app->stream, 0, SEEK_SET);
app->doc = fz_open_document_with_stream(ctx, filename, app->stream);
}
fz_catch(ctx)
{
if (fz_caught(ctx) == FZ_ERROR_TRYLATER)
{
pdfapp_warn(app, "not enough data to open yet");
continue;
}
fz_rethrow(ctx);
}
break;
}
}
else
#endif
if (bps == 0)
bool Viewer::init() {
ctx = fz_new_context(nullptr, nullptr, FZ_STORE_UNLIMITED);
if (ctx) {
fz_register_document_handlers(ctx);
return true;
} else {
return false;
}
}
void
Init_mupdf_ext()
{
to_s = rb_intern ("to_s");
FZ_CONTEXT = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
fz_register_document_handlers(FZ_CONTEXT);
/*
MuPDF Module
Holds the stuffs
*/
rb_MuPDF = rb_define_module( "MuPDF" );
Init_Document();
}
pdf::pdf(const char *filepath)
{
_filepath = filepath;
_good = true;
_image_name = nullptr;
_needs_password = false;
_size = 0;
// Create a context to hold the exception stack and various caches.
_ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!_ctx)
{
_good = false;
return;
}
fz_try(_ctx)
{
// Register the default file types.
fz_register_document_handlers(_ctx);
// Open the PDF, XPS or CBZ document.
_doc = fz_open_document(_ctx, filepath);
if (fz_needs_password(_ctx, _doc))
{
_needs_password = true;
_good = false;
}
else
{
// Retrieve the number of pages (not used in this example).
_size = fz_count_pages(_ctx, _doc);
}
}
fz_catch(_ctx)
{
_doc = 0;
_good = false;
}
}
bool MupdfBackend::load(const QString& filePath) {
Q_ASSERT(m_doc == 0);
Q_ASSERT(m_ctx == 0);
m_ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT); // TODO: locks
if (!m_ctx) {
return false;
}
fz_register_document_handlers(m_ctx);
fz_try(m_ctx) {
m_doc = fz_open_document(m_ctx, filePath.toUtf8());
}
fz_catch(m_ctx) {
fz_drop_context(m_ctx);
m_ctx = 0;
return false;
}
return true;
}
JNIFUNC(jlong, MuContext, nNew)(JNIEnv *env, jclass clazz) {
ContextGlue* glue = new ContextGlue;
glue->ctx = fz_new_context(nullptr, nullptr, FZ_STORE_UNLIMITED);
fz_register_document_handlers(glue->ctx);
glue->RectF = env->FindClass("android/graphics/RectF");
glue->RectF_left = env->GetFieldID(glue->RectF, "left", "F");
glue->RectF_top = env->GetFieldID(glue->RectF, "top", "F");
glue->RectF_right = env->GetFieldID(glue->RectF, "right", "F");
glue->RectF_bottom = env->GetFieldID(glue->RectF, "bottom", "F");
glue->Bitmap = env->FindClass("android/graphics/Bitmap");
glue->Bitmap_mWidth = env->GetFieldID(glue->Bitmap, "mWidth", "I");
glue->Bitmap_mHeight = env->GetFieldID(glue->Bitmap, "mHeight", "I");
glue->MuDocument = env->FindClass("com/github/jiboo/dwiinaar/mupdf/MuDocument");
glue->MuDocument_dPageCount = env->GetFieldID(glue->MuDocument, "dPageCount", "I");
glue->MuDocument_dNeedsPassword = env->GetFieldID(glue->MuDocument, "dNeedsPassword", "Z");
glue->MuPDFException = env->FindClass("com/github/jiboo/dwiinaar/mupdf/MuPDFException");
return reinterpret_cast<jlong>(glue);
}
MuError MuOfficeLib_create(MuOfficeLib **pMu)
{
MuOfficeLib *mu;
fz_locks_context *locks;
if (pMu == NULL)
return MuOfficeDocErrorType_IllegalArgument;
mu = Pal_Mem_calloc(1, sizeof(MuOfficeLib));
if (mu == NULL)
return MuOfficeDocErrorType_OutOfMemory;
locks = init_muoffice_locks(mu);
if (locks == NULL)
goto Fail;
mu->ctx = fz_new_context(&muoffice_alloc, locks, FZ_STORE_DEFAULT);
if (mu->ctx == NULL)
goto Fail;
fz_try(mu->ctx)
fz_register_document_handlers(mu->ctx);
fz_catch(mu->ctx)
goto Fail;
*pMu = mu;
return MuOfficeDocErrorType_NoError;
Fail:
if (mu)
{
fin_muoffice_locks(mu);
Pal_Mem_free(mu);
}
return MuOfficeDocErrorType_OutOfMemory;
}
int main(int argc, char **argv)
{
char *filename = argc >= 2 ? argv[1] : "";
pthread_t *thread = NULL;
fz_locks_context locks;
pthread_mutex_t mutex[FZ_LOCK_MAX];
fz_context *ctx;
fz_document *doc;
int threads;
int i;
// Initialize FZ_LOCK_MAX number of non-recursive mutexes.
for (i = 0; i < FZ_LOCK_MAX; i++)
{
if (pthread_mutex_init(&mutex[i], NULL) != 0)
fail("pthread_mutex_init()");
}
// Initialize the locking structure with function pointers to
// the locking functions and to the user data. In this case
// the user data is a pointer to the array of mutexes so the
// locking functions can find the relevant lock to change when
// they are called. This way we avoid global variables.
locks.user = mutex;
locks.lock = lock_mutex;
locks.unlock = unlock_mutex;
// This is the main threads context function, so supply the
// locking structure. This context will be used to parse all
// the pages from the document.
ctx = fz_new_context(NULL, &locks, FZ_STORE_UNLIMITED);
// Register default file types.
fz_register_document_handlers(ctx);
// Open the PDF, XPS or CBZ document. Note, this binds doc to ctx.
// You must only ever use doc with ctx - never a clone of it!
doc = fz_open_document(ctx, filename);
// Retrieve the number of pages, which translates to the
// number of threads used for rendering pages.
threads = fz_count_pages(ctx, doc);
fprintf(stderr, "spawning %d threads, one per page...\n", threads);
thread = malloc(threads * sizeof (pthread_t));
for (i = 0; i < threads; i++)
{
fz_page *page;
fz_rect bbox;
fz_irect rbox;
fz_display_list *list;
fz_device *dev;
fz_pixmap *pix;
struct data *data;
// Load the relevant page for each thread. Note, that this
// cannot be done on the worker threads, as each use of doc
// uses ctx, and only one thread can be using ctx at a time.
page = fz_load_page(ctx, doc, i);
// Compute the bounding box for each page.
fz_bound_page(ctx, page, &bbox);
// Create a display list that will hold the drawing
// commands for the page. Once we have the display list
// this can safely be used on any other thread as it is
// not bound to a given context.
list = fz_new_display_list(ctx, &bbox);
// Run the loaded page through a display list device
// to populate the page's display list.
dev = fz_new_list_device(ctx, list);
fz_run_page(ctx, page, dev, &fz_identity, NULL);
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
// The page is no longer needed, all drawing commands
// are now in the display list.
fz_drop_page(ctx, page);
// Create a white pixmap using the correct dimensions.
pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), fz_round_rect(&rbox, &bbox), 0);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
// Populate the data structure to be sent to the
// rendering thread for this page.
data = malloc(sizeof (struct data));
data->pagenumber = i + 1;
data->ctx = ctx;
data->list = list;
data->bbox = bbox;
data->pix = pix;
// Create the thread and pass it the data structure.
if (pthread_create(&thread[i], NULL, renderer, data) != 0)
fail("pthread_create()");
}
// Now each thread is rendering pages, so wait for each thread
// to complete its rendering.
fprintf(stderr, "joining %d threads...\n", threads);
for (i = threads - 1; i >= 0; i--)
{
char filename[42];
struct data *data;
if (pthread_join(thread[i], (void **) &data) != 0)
fail("pthread_join");
sprintf(filename, "out%04d.png", i);
fprintf(stderr, "\tSaving %s...\n", filename);
// Write the rendered image to a PNG file
fz_save_pixmap_as_png(ctx, data->pix, filename);
// Free the thread's pixmap and display list since
// they were allocated by the main thread above.
fz_drop_pixmap(ctx, data->pix);
fz_drop_display_list(ctx, data->list);
// Free the data structured passed back and forth
// between the main thread and rendering thread.
free(data);
}
fprintf(stderr, "finally!\n");
fflush(NULL);
free(thread);
// Finally the document is closed and the main thread's
// context is freed.
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return 0;
}
int main(int argc, char **argv)
#endif
{
const GLFWvidmode *video_mode;
int c;
while ((c = fz_getopt(argc, argv, "p:r:W:H:S:U:X")) != -1)
{
switch (c)
{
default:
usage(argv[0]);
break;
case 'p':
password = fz_optarg;
break;
case 'r':
currentzoom = fz_atof(fz_optarg);
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;
}
}
if (fz_optind < argc)
{
fz_strlcpy(filename, argv[fz_optind], sizeof filename);
}
else
{
#ifdef _WIN32
win_install();
if (!win_open_file(filename, sizeof filename))
exit(0);
#else
usage(argv[0]);
#endif
}
title = strrchr(filename, '/');
if (!title)
title = strrchr(filename, '\\');
if (title)
++title;
else
title = filename;
memset(&ui, 0, sizeof ui);
search_input.p = search_input.text;
search_input.q = search_input.p;
search_input.end = search_input.p;
glfwSetErrorCallback(on_error);
if (!glfwInit()) {
fprintf(stderr, "cannot initialize glfw\n");
exit(1);
}
video_mode = glfwGetVideoMode(glfwGetPrimaryMonitor());
screen_w = video_mode->width;
screen_h = video_mode->height;
window = glfwCreateWindow(DEFAULT_WINDOW_W, DEFAULT_WINDOW_H, filename, NULL, NULL);
if (!window) {
fprintf(stderr, "cannot create glfw window\n");
exit(1);
}
glfwMakeContextCurrent(window);
ctx = fz_new_context(NULL, NULL, 0);
fz_register_document_handlers(ctx);
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);
has_ARB_texture_non_power_of_two = glfwExtensionSupported("GL_ARB_texture_non_power_of_two");
if (!has_ARB_texture_non_power_of_two)
fz_warn(ctx, "OpenGL implementation does not support non-power of two texture sizes");
glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
ui.fontsize = DEFAULT_UI_FONTSIZE;
ui.baseline = DEFAULT_UI_BASELINE;
ui.lineheight = DEFAULT_UI_LINEHEIGHT;
ui_init_fonts(ctx, ui.fontsize);
reload();
shrinkwrap();
glfwSetFramebufferSizeCallback(window, on_reshape);
glfwSetCursorPosCallback(window, on_mouse_motion);
glfwSetMouseButtonCallback(window, on_mouse_button);
glfwSetScrollCallback(window, on_scroll);
glfwSetCharModsCallback(window, on_char);
glfwSetKeyCallback(window, on_key);
glfwSetWindowRefreshCallback(window, on_display);
glfwGetFramebufferSize(window, &window_w, &window_h);
ui_needs_update = 1;
while (!glfwWindowShouldClose(window))
{
glfwWaitEvents();
if (ui_needs_update)
run_main_loop();
}
ui_finish_fonts(ctx);
fz_drop_link(ctx, links);
fz_drop_page(ctx, page);
fz_drop_outline(ctx, outline);
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
glfwTerminate();
return 0;
}
MuPdf::Sharp::Fitz::Context::Context(int maxStore)
{
m_pCtx = fz_new_context(NULL, NULL, maxStore);
fz_register_document_handlers(m_pCtx);
}
int muconvert_main(int argc, char **argv)
{
int i, c;
while ((c = fz_getopt(argc, argv, "p:A:W:H:S:U:o:F:O:")) != -1)
{
switch (c)
{
default: usage(); break;
case 'p': password = fz_optarg; break;
case 'A': alphabits = atoi(fz_optarg); break;
case 'W': layout_w = atof(fz_optarg); break;
case 'H': layout_h = atof(fz_optarg); break;
case 'S': layout_em = atof(fz_optarg); break;
case 'U': layout_css = fz_optarg; break;
case 'o': output = fz_optarg; break;
case 'F': format = fz_optarg; break;
case 'O': options = fz_optarg; break;
}
}
if (fz_optind == argc || (!format && !output))
usage();
/* Create a context to hold the exception stack and various caches. */
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot create mupdf context\n");
return EXIT_FAILURE;
}
/* Register the default file types to handle. */
fz_try(ctx)
fz_register_document_handlers(ctx);
fz_catch(ctx)
{
fprintf(stderr, "cannot register document handlers: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
fz_set_aa_level(ctx, alphabits);
if (layout_css)
{
fz_buffer *buf = fz_read_file(ctx, layout_css);
fz_write_buffer_byte(ctx, buf, 0);
fz_set_user_css(ctx, (char*)buf->data);
fz_drop_buffer(ctx, buf);
}
/* Open the output document. */
fz_try(ctx)
out = fz_new_document_writer(ctx, output, format, options);
fz_catch(ctx)
{
fprintf(stderr, "cannot create document: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
for (i = fz_optind; i < argc; ++i)
{
doc = fz_open_document(ctx, argv[i]);
if (fz_needs_password(ctx, doc))
if (!fz_authenticate_password(ctx, doc, password))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", argv[i]);
fz_layout_document(ctx, doc, layout_w, layout_h, layout_em);
count = fz_count_pages(ctx, doc);
if (i+1 < argc && fz_is_page_range(ctx, argv[i+1]))
runrange(argv[++i]);
else
runrange("1-N");
fz_drop_document(ctx, doc);
}
fz_drop_document_writer(ctx, out);
fz_drop_context(ctx);
return EXIT_SUCCESS;
}
void j_mu_register_document_handlers(void* p_ctx)
{
fz_context* ctx = (fz_context*) p_ctx;
fz_register_document_handlers(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);
}
/*
** Returns 0 if got dimensions.
*/
int bmpmupdf_pdffile_width_and_height(char *filename,int pageno,double *width_in,double *height_in)
{
fz_context *ctx;
fz_document *doc;
fz_page *page;
fz_display_list *list;
fz_device *dev;
fz_rect bounds;
int np;
dev=NULL;
list=NULL;
page=NULL;
doc=NULL;
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_try(ctx) { doc=fz_open_document(ctx,filename); }
fz_catch(ctx)
{
fz_free_context(ctx);
return(-1);
}
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;
fz_bound_page(doc,page,&bounds);
if (width_in!=NULL)
(*width_in)=fabs(bounds.x1-bounds.x0)/72.;
if (height_in!=NULL)
(*height_in)=fabs(bounds.y1-bounds.y0)/72.;
fz_drop_display_list(ctx,list);
fz_free_page(doc,page);
fz_close_document(doc);
}
fz_catch(ctx) /* Error registering */
{
fz_free_context(ctx);
return(-20);
}
fz_free_context(ctx);
return(0);
}
MuPdf::Sharp::Fitz::Context::Context(fz_context* ctx)
{
m_pCtx = ctx;
fz_register_document_handlers(m_pCtx);
}
int main(int argc, char **argv)
{
char *password = "";
fz_document *doc = NULL;
fz_context *ctx;
int c;
fz_var(ctx, doc);
while ((c = fz_getopt(argc, argv, "p:")) != -1)
{
switch (c)
{
default: usage(); break;
case 'p': password = fz_optarg; break;
}
}
if (fz_optind + 2 != argc)
usage();
filename = argv[fz_optind];
mujstest_filename = argv[fz_optind+1];
if (strcmp(mujstest_filename, "-") == 0)
mujstest_file = stdout;
else
mujstest_file = fopen(mujstest_filename, "wb");
ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
if (!ctx)
{
fprintf(stderr, "cannot initialise context\n");
exit(1);
}
fz_register_document_handlers(ctx);
fz_try(ctx)
{
doc = fz_open_document(ctx, filename);
if (fz_needs_password(doc))
{
if (!fz_authenticate_password(ctx, doc, password))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", filename);
fprintf(mujstest_file, "PASSWORD %s\n", password);
}
fprintf(mujstest_file, "OPEN %s\n", filename);
processpages(ctx, doc);
fz_drop_document(ctx, doc);
}
fz_catch(ctx)
{
fprintf(stderr, "mjsgen: cannot process document: %s\n", filename);
return 1;
}
fclose(mujstest_file);
fz_drop_context(ctx);
return 0;
}
int main(int argc, char **argv)
{
char *input;
float zoom, rotate;
int page_number, page_count;
fz_context *ctx;
fz_document *doc;
fz_pixmap *pix;
fz_matrix ctm;
int x, y;
if (argc < 3)
{
fprintf(stderr, "usage: example input-file page-number [ zoom [ rotate ] ]\n");
fprintf(stderr, "\tinput-file: path of PDF, XPS, CBZ or EPUB document to open\n");
fprintf(stderr, "\tPage numbering starts from one.\n");
fprintf(stderr, "\tZoom level is in percent (100 percent is 72 dpi).\n");
fprintf(stderr, "\tRotation is in degrees clockwise.\n");
return EXIT_FAILURE;
}
input = argv[1];
page_number = atoi(argv[2]) - 1;
zoom = argc > 3 ? atof(argv[3]) : 100;
rotate = argc > 4 ? atof(argv[4]) : 0;
/* Create a context to hold the exception stack and various caches. */
ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
if (!ctx)
{
fprintf(stderr, "cannot create mupdf context\n");
return EXIT_FAILURE;
}
/* Register the default file types to handle. */
fz_try(ctx)
fz_register_document_handlers(ctx);
fz_catch(ctx)
{
fprintf(stderr, "cannot register document handlers: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Open the document. */
fz_try(ctx)
doc = fz_open_document(ctx, input);
fz_catch(ctx)
{
fprintf(stderr, "cannot open document: %s\n", fz_caught_message(ctx));
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Count the number of pages. */
fz_try(ctx)
page_count = fz_count_pages(ctx, doc);
fz_catch(ctx)
{
fprintf(stderr, "cannot count number of pages: %s\n", fz_caught_message(ctx));
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
if (page_number < 0 || page_number >= page_count)
{
fprintf(stderr, "page number out of range: %d (page count %d)\n", page_number + 1, page_count);
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Compute a transformation matrix for the zoom and rotation desired. */
/* The default resolution without scaling is 72 dpi. */
fz_scale(&ctm, zoom / 100, zoom / 100);
fz_pre_rotate(&ctm, rotate);
/* Render page to an RGB pixmap. */
fz_try(ctx)
pix = fz_new_pixmap_from_page_number(ctx, doc, page_number, &ctm, fz_device_rgb(ctx), 0);
fz_catch(ctx)
{
fprintf(stderr, "cannot render page: %s\n", fz_caught_message(ctx));
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_FAILURE;
}
/* Print image data in ascii PPM format. */
printf("P3\n");
printf("%d %d\n", pix->w, pix->h);
printf("255\n");
for (y = 0; y < pix->h; ++y)
{
unsigned char *p = &pix->samples[y * pix->stride];
for (x = 0; x < pix->w; ++x)
{
if (x > 0)
printf(" ");
printf("%3d %3d %3d", p[0], p[1], p[2]);
p += pix->n;
}
printf("\n");
}
/* Clean up. */
fz_drop_pixmap(ctx, pix);
fz_drop_document(ctx, doc);
fz_drop_context(ctx);
return EXIT_SUCCESS;
}
