static void
cbz_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
{
fz_cbz_writer *wri = (fz_cbz_writer*)wri_;
fz_buffer *buffer;
char name[40];
fz_try(ctx)
fz_close_device(ctx, dev);
fz_always(ctx)
fz_drop_device(ctx, dev);
fz_catch(ctx)
fz_rethrow(ctx);
wri->count += 1;
fz_snprintf(name, sizeof name, "p%04d.png", wri->count);
buffer = fz_new_buffer_from_pixmap_as_png(ctx, wri->pixmap, NULL);
fz_try(ctx)
fz_write_zip_entry(ctx, wri->zip, name, buffer, 0);
fz_always(ctx)
fz_drop_buffer(ctx, buffer);
fz_catch(ctx)
fz_rethrow(ctx);
fz_drop_pixmap(ctx, wri->pixmap);
wri->pixmap = NULL;
}
fz_display_list *
fz_new_display_list_from_annot(fz_context *ctx, fz_annot *annot)
{
fz_display_list *list;
fz_rect bounds;
fz_device *dev;
list = fz_new_display_list(ctx, fz_bound_annot(ctx, annot, &bounds));
fz_try(ctx)
{
dev = fz_new_list_device(ctx, list);
fz_run_annot(ctx, annot, dev, &fz_identity, NULL);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_display_list(ctx, list);
fz_rethrow(ctx);
}
return list;
}
void *
renderer(void *data)
{
int pagenumber = ((struct data *) data)->pagenumber;
fz_context *ctx = ((struct data *) data)->ctx;
fz_display_list *list = ((struct data *) data)->list;
fz_rect bbox = ((struct data *) data)->bbox;
fz_pixmap *pix = ((struct data *) data)->pix;
fz_device *dev;
fprintf(stderr, "thread at page %d loading!\n", pagenumber);
// The context pointer is pointing to the main thread's
// context, so here we create a new context based on it for
// use in this thread.
ctx = fz_clone_context(ctx);
// Next we run the display list through the draw device which
// will render the request area of the page to the pixmap.
fprintf(stderr, "thread at page %d rendering!\n", pagenumber);
dev = fz_new_draw_device(ctx, &fz_identity, pix);
fz_run_display_list(ctx, list, dev, &fz_identity, &bbox, NULL);
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
// This threads context is freed.
fz_drop_context(ctx);
fprintf(stderr, "thread at page %d done!\n", pagenumber);
return data;
}
fz_stext_page *
fz_new_stext_page_from_page(fz_context *ctx, fz_page *page, fz_stext_sheet *sheet)
{
fz_stext_page *text;
fz_device *dev;
fz_rect mediabox;
if (page == NULL)
return NULL;
text = fz_new_stext_page(ctx, fz_bound_page(ctx, page, &mediabox));
fz_try(ctx)
{
dev = fz_new_stext_device(ctx, sheet, text);
fz_run_page(ctx, page, dev, &fz_identity, NULL);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_stext_page(ctx, text);
fz_rethrow(ctx);
}
return text;
}
static void
pwg_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
{
fz_pwg_writer *wri = (fz_pwg_writer*)wri_;
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
if (wri->mono)
{
fz_bitmap *bitmap = fz_new_bitmap_from_pixmap(ctx, wri->pixmap, NULL);
fz_try(ctx)
fz_write_bitmap_as_pwg_page(ctx, wri->out, bitmap, &wri->pwg);
fz_always(ctx)
fz_drop_bitmap(ctx, bitmap);
fz_catch(ctx)
fz_rethrow(ctx);
}
else
{
fz_write_pixmap_as_pwg_page(ctx, wri->out, wri->pixmap, &wri->pwg);
}
fz_drop_pixmap(ctx, wri->pixmap);
wri->pixmap = NULL;
}
static void
text_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
{
fz_text_writer *wri = (fz_text_writer*)wri_;
fz_close_device(ctx, dev);
fz_drop_device(ctx, dev);
switch (wri->format)
{
default:
case FZ_FORMAT_TEXT:
fz_print_stext_page_as_text(ctx, wri->out, wri->page);
break;
case FZ_FORMAT_HTML:
fz_print_stext_page_as_html(ctx, wri->out, wri->page);
break;
case FZ_FORMAT_XHTML:
fz_print_stext_page_as_xhtml(ctx, wri->out, wri->page);
break;
case FZ_FORMAT_STEXT:
fz_print_stext_page_as_xml(ctx, wri->out, wri->page);
break;
}
fz_drop_stext_page(ctx, wri->page);
wri->page = NULL;
}
void PDFDocument::Render(
Document::PixelWriter* pw, int page, float zoom, int rotation) {
assert((page >= 0) && (page < GetNumPages()));
std::unique_lock<std::mutex> lock(_render_mutex);
// 1. Init MuPDF structures.
const fz_matrix& m = Transform(zoom, rotation);
pdf_page* page_struct = GetPage(page);
const fz_irect& bbox = GetBoundingBox(page_struct, m);
fz_pixmap* pixmap = fz_new_pixmap_with_bbox(
_fz_context, fz_device_rgb(_fz_context), FZ_OBJ(bbox), nullptr, 1);
fz_device* dev = fz_new_draw_device(_fz_context, FZ_OBJ(fz_identity), pixmap);
// 2. Render page.
fz_clear_pixmap_with_value(_fz_context, pixmap, 0xff);
pdf_run_page(
_fz_context, _pdf_document, page_struct, dev, FZ_OBJ(m), nullptr);
// 3. Write pixmap to buffer. The page is vertically divided into n equal
// stripes, each copied to pw by one thread.
assert(fz_pixmap_components(_fz_context, pixmap) == 4);
uint8_t* buffer =
reinterpret_cast<uint8_t*>(fz_pixmap_samples(_fz_context, pixmap));
const int num_cols = fz_pixmap_width(_fz_context, pixmap);
const int num_rows = fz_pixmap_height(_fz_context, pixmap);
ExecuteInParallel([=](int num_threads, int i) {
const int num_rows_per_thread = num_rows / num_threads;
const int y_begin = i * num_rows_per_thread;
const int y_end =
(i == num_threads - 1) ? num_rows : (i + 1) * num_rows_per_thread;
uint8_t* p = buffer + y_begin * num_cols * 4;
for (int y = y_begin; y < y_end; ++y) {
for (int x = 0; x < num_cols; ++x) {
pw->Write(x, y, p[0], p[1], p[2]);
p += 4;
}
}
});
// 4. Clean up.
fz_close_device(_fz_context, dev);
fz_drop_device(_fz_context, dev);
fz_drop_pixmap(_fz_context, pixmap);
}
static void
pixmap_end_page(fz_context *ctx, fz_document_writer *wri_, fz_device *dev)
{
fz_pixmap_writer *wri = (fz_pixmap_writer*)wri_;
char path[PATH_MAX];
fz_try(ctx)
fz_close_device(ctx, dev);
fz_always(ctx)
fz_drop_device(ctx, dev);
fz_catch(ctx)
fz_rethrow(ctx);
wri->count += 1;
fz_format_output_path(ctx, path, sizeof path, wri->path, wri->count);
wri->save(ctx, wri->pixmap, path);
fz_drop_pixmap(ctx, wri->pixmap);
wri->pixmap = NULL;
}
fz_pixmap *
fz_new_pixmap_from_page(fz_context *ctx, fz_page *page, const fz_matrix *ctm, fz_colorspace *cs, int alpha)
{
fz_rect rect;
fz_irect irect;
fz_pixmap *pix;
fz_device *dev;
fz_bound_page(ctx, page, &rect);
fz_transform_rect(&rect, ctm);
fz_round_rect(&irect, &rect);
pix = fz_new_pixmap_with_bbox(ctx, cs, &irect, alpha);
if (alpha)
fz_clear_pixmap(ctx, pix);
else
fz_clear_pixmap_with_value(ctx, pix, 0xFF);
fz_try(ctx)
{
dev = fz_new_draw_device(ctx, ctm, pix);
fz_run_page(ctx, page, dev, &fz_identity, NULL);
fz_close_device(ctx, dev);
}
fz_always(ctx)
{
fz_drop_device(ctx, dev);
}
fz_catch(ctx)
{
fz_drop_pixmap(ctx, pix);
fz_rethrow(ctx);
}
return pix;
}
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;
}
