diff options
| author | Tor Andersson <tor.andersson@artifex.com> | 2015-01-21 16:42:45 +0100 |
|---|---|---|
| committer | Tor Andersson <tor.andersson@artifex.com> | 2015-02-17 18:05:39 +0100 |
| commit | f84a189d5f94250e46d2cbd1a75aba00130e2dd6 (patch) | |
| tree | 8ee614ab90de1baa8941f91ae4946ed5c2e70721 /source | |
| parent | 681039767f2ccc72e236246178893eb0989169c9 (diff) | |
| download | mupdf-f84a189d5f94250e46d2cbd1a75aba00130e2dd6.tar.xz | |
Add ctx parameter and remove embedded contexts for API regularity.
Purge several embedded contexts:
Remove embedded context in fz_output.
Remove embedded context in fz_stream.
Remove embedded context in fz_device.
Remove fz_rebind_stream (since it is no longer necessary).
Remove embedded context in svg_device.
Remove embedded context in XML parser.
Add ctx argument to fz_document functions.
Remove embedded context in fz_document.
Remove embedded context in pdf_document.
Remove embedded context in pdf_obj.
Make fz_page independent of fz_document in the interface.
We shouldn't need to pass the document to all functions handling a page.
If a page is tied to the source document, it's redundant; otherwise it's
just pointless.
Fix reference counting oddity in fz_new_image_from_pixmap.
Diffstat (limited to 'source')
111 files changed, 8130 insertions, 8620 deletions
diff --git a/source/cbz/mucbz.c b/source/cbz/mucbz.c index 72b6a185..75148490 100644 --- a/source/cbz/mucbz.c +++ b/source/cbz/mucbz.c @@ -1,8 +1,9 @@ -#include "mupdf/cbz.h" +#include "mupdf/fitz.h" #define DPI 72.0f -static void cbz_init_document(cbz_document *doc); +typedef struct cbz_document_s cbz_document; +typedef struct cbz_page_s cbz_page; static const char *cbz_ext_list[] = { ".jpg", ".jpeg", ".png", @@ -12,13 +13,13 @@ static const char *cbz_ext_list[] = { struct cbz_page_s { + fz_page super; fz_image *image; }; struct cbz_document_s { fz_document super; - fz_context *ctx; fz_archive *zip; int page_count; const char **page; @@ -73,9 +74,8 @@ cbz_compare_page_names(const void *a, const void *b) } static void -cbz_create_page_list(cbz_document *doc) +cbz_create_page_list(fz_context *ctx, cbz_document *doc) { - fz_context *ctx = doc->ctx; fz_archive *zip = doc->zip; int i, k, count; @@ -92,87 +92,68 @@ cbz_create_page_list(cbz_document *doc) if (strstr(name, cbz_ext_list[k])) { doc->page[doc->page_count++] = name; -printf("found page %d = '%s'\n", i, name); break; } } } qsort((char **)doc->page, doc->page_count, sizeof *doc->page, cbz_compare_page_names); - - for (i = 0; i < doc->page_count; ++i) - printf(" %d = %s\n", i, doc->page[i]); } -cbz_document * -cbz_open_document_with_stream(fz_context *ctx, fz_stream *file) +static void +cbz_close_document(fz_context *ctx, cbz_document *doc) { - cbz_document *doc; - - doc = fz_malloc_struct(ctx, cbz_document); - cbz_init_document(doc); - doc->ctx = ctx; - doc->page_count = 0; - doc->page = NULL; - - fz_try(ctx) - { - doc->zip = fz_open_archive_with_stream(ctx, file); - cbz_create_page_list(doc); - } - fz_catch(ctx) - { - cbz_close_document(doc); - fz_rethrow(ctx); - } - - return doc; + fz_drop_archive(ctx, doc->zip); + fz_free(ctx, (char **)doc->page); + fz_free(ctx, doc); } -cbz_document * -cbz_open_document(fz_context *ctx, const char *filename) +static int +cbz_count_pages(fz_context *ctx, cbz_document *doc) { - fz_stream *file; - cbz_document *doc; - - file = fz_open_file(ctx, filename); - if (!file) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); + return doc->page_count; +} - fz_try(ctx) - { - doc = cbz_open_document_with_stream(ctx, file); - } - fz_always(ctx) - { - fz_drop_stream(file); - } - fz_catch(ctx) - { - fz_rethrow(ctx); - } +static fz_rect * +cbz_bound_page(fz_context *ctx, cbz_page *page, fz_rect *bbox) +{ + fz_image *image = page->image; + int xres, yres; - return doc; + fz_image_get_sanitised_res(image, &xres, &yres); + bbox->x0 = bbox->y0 = 0; + bbox->x1 = image->w * DPI / xres; + bbox->y1 = image->h * DPI / yres; + return bbox; } -void -cbz_close_document(cbz_document *doc) +static void +cbz_run_page(fz_context *ctx, cbz_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { - fz_drop_archive(doc->ctx, doc->zip); - fz_free(doc->ctx, (char **)doc->page); - fz_free(doc->ctx, doc); + fz_matrix local_ctm = *ctm; + fz_image *image = page->image; + int xres, yres; + float w, h; + + fz_image_get_sanitised_res(image, &xres, &yres); + w = image->w * DPI / xres; + h = image->h * DPI / yres; + fz_pre_scale(&local_ctm, w, h); + fz_fill_image(ctx, dev, image, &local_ctm, 1); } -int -cbz_count_pages(cbz_document *doc) +static void +cbz_drop_page_imp(fz_context *ctx, cbz_page *page) { - return doc->page_count; + if (!page) + return; + fz_drop_image(ctx, page->image); + fz_free(ctx, page); } -cbz_page * -cbz_load_page(cbz_document *doc, int number) +static cbz_page * +cbz_load_page(fz_context *ctx, cbz_document *doc, int number) { - fz_context *ctx = doc->ctx; unsigned char *data = NULL; cbz_page *page = NULL; fz_buffer *buf; @@ -183,65 +164,31 @@ cbz_load_page(cbz_document *doc, int number) fz_var(data); fz_var(page); - buf = fz_read_archive_entry(doc->ctx, doc->zip, doc->page[number]); + buf = fz_read_archive_entry(ctx, doc->zip, doc->page[number]); fz_try(ctx) { - page = fz_malloc_struct(ctx, cbz_page); + page = fz_new_page(ctx, sizeof *page); + page->super.bound_page = (fz_page_bound_page_fn *)cbz_bound_page; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)cbz_run_page; + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)cbz_drop_page_imp; page->image = fz_new_image_from_buffer(ctx, buf); } fz_always(ctx) { - fz_drop_buffer(doc->ctx, buf); + fz_drop_buffer(ctx, buf); } fz_catch(ctx) { fz_free(ctx, data); - cbz_free_page(doc, page); + cbz_drop_page_imp(ctx, page); fz_rethrow(ctx); } return page; } -void -cbz_free_page(cbz_document *doc, cbz_page *page) -{ - if (!page) - return; - fz_drop_image(doc->ctx, page->image); - fz_free(doc->ctx, page); -} - -fz_rect * -cbz_bound_page(cbz_document *doc, cbz_page *page, fz_rect *bbox) -{ - fz_image *image = page->image; - int xres, yres; - - fz_image_get_sanitised_res(image, &xres, &yres); - bbox->x0 = bbox->y0 = 0; - bbox->x1 = image->w * DPI / xres; - bbox->y1 = image->h * DPI / yres; - return bbox; -} - -void -cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) -{ - fz_matrix local_ctm = *ctm; - fz_image *image = page->image; - int xres, yres; - float w, h; - - fz_image_get_sanitised_res(image, &xres, &yres); - w = image->w * DPI / xres; - h = image->h * DPI / yres; - fz_pre_scale(&local_ctm, w, h); - fz_fill_image(dev, image, &local_ctm, 1); -} - static int -cbz_meta(cbz_document *doc, int key, void *ptr, int size) +cbz_meta(fz_context *ctx, cbz_document *doc, int key, void *ptr, int size) { switch (key) { @@ -253,25 +200,47 @@ cbz_meta(cbz_document *doc, int key, void *ptr, int size) } } -static void -cbz_rebind(cbz_document *doc, fz_context *ctx) +static cbz_document * +cbz_open_document_with_stream(fz_context *ctx, fz_stream *file) { - doc->ctx = ctx; - fz_rebind_archive(doc->zip, ctx); -} + cbz_document *doc = fz_new_document(ctx, sizeof *doc); -static void -cbz_init_document(cbz_document *doc) -{ - doc->super.refs = 1; doc->super.close = (fz_document_close_fn *)cbz_close_document; doc->super.count_pages = (fz_document_count_pages_fn *)cbz_count_pages; doc->super.load_page = (fz_document_load_page_fn *)cbz_load_page; - doc->super.bound_page = (fz_document_bound_page_fn *)cbz_bound_page; - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)cbz_run_page; - doc->super.free_page = (fz_document_free_page_fn *)cbz_free_page; doc->super.meta = (fz_document_meta_fn *)cbz_meta; - doc->super.rebind = (fz_document_rebind_fn *)cbz_rebind; + + fz_try(ctx) + { + doc->zip = fz_open_archive_with_stream(ctx, file); + cbz_create_page_list(ctx, doc); + } + fz_catch(ctx) + { + cbz_close_document(ctx, doc); + fz_rethrow(ctx); + } + return doc; +} + +static cbz_document * +cbz_open_document(fz_context *ctx, const char *filename) +{ + fz_stream *file; + cbz_document *doc; + + file = fz_open_file(ctx, filename); + if (!file) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); + + fz_try(ctx) + doc = cbz_open_document_with_stream(ctx, file); + fz_always(ctx) + fz_drop_stream(ctx, file); + fz_catch(ctx) + fz_rethrow(ctx); + + return doc; } static int diff --git a/source/cbz/muimg.c b/source/cbz/muimg.c new file mode 100644 index 00000000..a288a4f4 --- /dev/null +++ b/source/cbz/muimg.c @@ -0,0 +1,187 @@ +#include "mupdf/fitz.h" + +#define DPI 72.0f + +typedef struct img_document_s img_document; +typedef struct img_page_s img_page; + +struct img_page_s +{ + fz_page super; + fz_image *image; +}; + +struct img_document_s +{ + fz_document super; + fz_image *image; +}; + +static void +img_close_document(fz_context *ctx, img_document *doc) +{ + fz_drop_image(ctx, doc->image); + fz_free(ctx, doc); +} + +static int +img_count_pages(fz_context *ctx, img_document *doc) +{ + return 1; +} + +static fz_rect * +img_bound_page(fz_context *ctx, img_page *page, fz_rect *bbox) +{ + fz_image *image = (fz_image *)page; + int xres, yres; + fz_image_get_sanitised_res(image, &xres, &yres); + bbox->x0 = bbox->y0 = 0; + bbox->x1 = image->w * DPI / xres; + bbox->y1 = image->h * DPI / yres; + return bbox; +} + +static void +img_run_page(fz_context *ctx, img_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +{ + fz_matrix local_ctm = *ctm; + fz_image *image = (fz_image *)page; + int xres, yres; + float w, h; + fz_image_get_sanitised_res(image, &xres, &yres); + w = image->w * DPI / xres; + h = image->h * DPI / yres; + fz_pre_scale(&local_ctm, w, h); + fz_fill_image(ctx, dev, image, &local_ctm, 1); +} + +static void +img_drop_page_imp(fz_context *ctx, img_page *page) +{ + fz_drop_image(ctx, page->image); +} + +static img_page * +img_load_page(fz_context *ctx, img_document *doc, int number) +{ + img_page *page; + + if (number != 0) + return NULL; + + page = fz_new_page(ctx, sizeof *page); + + page->super.bound_page = (fz_page_bound_page_fn *)img_bound_page; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)img_run_page; + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)img_drop_page_imp; + + page->image = fz_keep_image(ctx, doc->image); + + return page; +} + +static int +img_meta(fz_context *ctx, img_document *doc, int key, void *ptr, int size) +{ + switch(key) + { + case FZ_META_FORMAT_INFO: + sprintf((char *)ptr, "IMAGE"); + return FZ_META_OK; + default: + return FZ_META_UNKNOWN_KEY; + } +} + +static img_document * +img_new_document(fz_context *ctx, fz_image *image) +{ + img_document *doc = fz_new_document(ctx, sizeof *doc); + + doc->super.close = (fz_document_close_fn *)img_close_document; + doc->super.count_pages = (fz_document_count_pages_fn *)img_count_pages; + doc->super.load_page = (fz_document_load_page_fn *)img_load_page; + doc->super.meta = (fz_document_meta_fn *)img_meta; + + doc->image = fz_keep_image(ctx, image); + + return doc; +} + +static img_document * +img_open_document_with_stream(fz_context *ctx, fz_stream *stm) +{ + fz_buffer *buffer = NULL; + fz_image *image = NULL; + img_document *doc; + + fz_var(buffer); + fz_var(image); + + fz_try(ctx) + { + buffer = fz_read_all(ctx, stm, 1024); + image = fz_new_image_from_buffer(ctx, buffer); + doc = img_new_document(ctx, image); + } + fz_always(ctx) + { + fz_drop_buffer(ctx, buffer); + fz_drop_stream(ctx, stm); + } + fz_catch(ctx) + { + fz_rethrow(ctx); + } + + return doc; +} + +static img_document * +img_open_document(fz_context *ctx, const char *filename) +{ + fz_stream *stm; + img_document *doc; + + stm = fz_open_file(ctx, filename); + if (!stm) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); + + fz_try(ctx) + doc = img_open_document_with_stream(ctx, stm); + fz_always(ctx) + fz_drop_stream(ctx, stm); + fz_catch(ctx) + fz_rethrow(ctx); + + return doc; +} + +static int +img_recognize(fz_context *doc, const char *magic) +{ + char *ext = strrchr(magic, '.'); + + if (ext) + { + if (!fz_strcasecmp(ext, ".png") || !fz_strcasecmp(ext, ".jpg") || + !fz_strcasecmp(ext, ".jpeg") || !fz_strcasecmp(ext, ".jfif") || + !fz_strcasecmp(ext, ".jfif-tbnl") || !fz_strcasecmp(ext, ".jpe")) + return 100; + } + if (!strcmp(magic, "png") || !strcmp(magic, "image/png") || + !strcmp(magic, "jpg") || !strcmp(magic, "image/jpeg") || + !strcmp(magic, "jpeg") || !strcmp(magic, "image/pjpeg") || + !strcmp(magic, "jpe") || !strcmp(magic, "jfif")) + return 100; + + return 0; +} + +fz_document_handler img_document_handler = +{ + (fz_document_recognize_fn *)&img_recognize, + (fz_document_open_fn *)&img_open_document, + (fz_document_open_with_stream_fn *)&img_open_document_with_stream +}; diff --git a/source/tiff/mutiff.c b/source/cbz/mutiff.c index 20086621..c03cb3b7 100644 --- a/source/tiff/mutiff.c +++ b/source/cbz/mutiff.c @@ -1,163 +1,108 @@ -#include "mupdf/tiff.h" +#include "mupdf/fitz.h" -static void tiff_init_document(tiff_document *doc); +typedef struct tiff_document_s tiff_document; +typedef struct tiff_page_s tiff_page; #define DPI 72.0f struct tiff_page_s { + fz_page super; fz_image *image; }; struct tiff_document_s { fz_document super; - - fz_context *ctx; fz_stream *file; fz_buffer *buffer; int page_count; }; -tiff_document * -tiff_open_document_with_stream(fz_context *ctx, fz_stream *file) +static fz_rect * +tiff_bound_page(fz_context *ctx, tiff_page *page, fz_rect *bbox) { - tiff_document *doc; - int len; - unsigned char *buf; - - doc = fz_malloc_struct(ctx, tiff_document); - tiff_init_document(doc); - doc->ctx = ctx; - doc->file = fz_keep_stream(file); - doc->page_count = 0; - - fz_try(ctx) - { - doc->buffer = fz_read_all(doc->file, 1024); - len = doc->buffer->len; - buf = doc->buffer->data; - - doc->page_count = fz_load_tiff_subimage_count(ctx, buf, len); - } - fz_catch(ctx) - { - tiff_close_document(doc); - fz_rethrow(ctx); - } + fz_image *image = page->image; + int xres, yres; - return doc; + fz_image_get_sanitised_res(image, &xres, &yres); + bbox->x0 = bbox->y0 = 0; + bbox->x1 = image->w * DPI / xres; + bbox->y1 = image->h * DPI / yres; + return bbox; } -tiff_document * -tiff_open_document(fz_context *ctx, const char *filename) +static void +tiff_run_page(fz_context *ctx, tiff_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { - fz_stream *file; - tiff_document *doc; - - file = fz_open_file(ctx, filename); - if (!file) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); - - fz_try(ctx) - { - doc = tiff_open_document_with_stream(ctx, file); - } - fz_always(ctx) - { - fz_drop_stream(file); - } - fz_catch(ctx) - { - fz_rethrow(ctx); - } - - return doc; -} + fz_matrix local_ctm = *ctm; + fz_image *image = page->image; + int xres, yres; + float w, h; -void -tiff_close_document(tiff_document *doc) -{ - fz_context *ctx = doc->ctx; - fz_drop_buffer(ctx, doc->buffer); - fz_drop_stream(doc->file); - fz_free(ctx, doc); + fz_image_get_sanitised_res(image, &xres, &yres); + w = image->w * DPI / xres; + h = image->h * DPI / yres; + fz_pre_scale(&local_ctm, w, h); + fz_fill_image(ctx, dev, image, &local_ctm, 1); } -int -tiff_count_pages(tiff_document *doc) +static void +tiff_drop_page_imp(fz_context *ctx, tiff_page *page) { - return doc->page_count; + if (!page) + return; + fz_drop_image(ctx, page->image); + fz_free(ctx, page); } -tiff_page * -tiff_load_page(tiff_document *doc, int number) +static tiff_page * +tiff_load_page(fz_context *ctx, tiff_document *doc, int number) { - fz_context *ctx = doc->ctx; - fz_image *mask = NULL; fz_pixmap *pixmap = NULL; + fz_image *image = NULL; tiff_page *page = NULL; if (number < 0 || number >= doc->page_count) return NULL; fz_var(pixmap); + fz_var(image); fz_var(page); + fz_try(ctx) { pixmap = fz_load_tiff_subimage(ctx, doc->buffer->data, doc->buffer->len, number); + image = fz_new_image_from_pixmap(ctx, pixmap, NULL); - page = fz_malloc_struct(ctx, tiff_page); - page->image = fz_new_image_from_pixmap(ctx, pixmap, mask); + page = fz_new_page(ctx, sizeof *page); + page->super.bound_page = (fz_page_bound_page_fn *)tiff_bound_page; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)tiff_run_page; + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)tiff_drop_page_imp; + page->image = fz_keep_image(ctx, image); + } + fz_always(ctx) + { + fz_drop_image(ctx, image); + fz_drop_pixmap(ctx, pixmap); } fz_catch(ctx) { - tiff_free_page(doc, page); + fz_free(ctx, page); fz_rethrow(ctx); } return page; } -void -tiff_free_page(tiff_document *doc, tiff_page *page) -{ - if (!page) - return; - fz_drop_image(doc->ctx, page->image); - fz_free(doc->ctx, page); -} - -fz_rect * -tiff_bound_page(tiff_document *doc, tiff_page *page, fz_rect *bbox) -{ - fz_image *image = page->image; - int xres, yres; - - fz_image_get_sanitised_res(image, &xres, &yres); - bbox->x0 = bbox->y0 = 0; - bbox->x1 = image->w * DPI / xres; - bbox->y1 = image->h * DPI / yres; - return bbox; -} - -void -tiff_run_page(tiff_document *doc, tiff_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +static int +tiff_count_pages(fz_context *ctx, tiff_document *doc) { - fz_matrix local_ctm = *ctm; - fz_image *image = page->image; - int xres, yres; - float w, h; - - fz_image_get_sanitised_res(image, &xres, &yres); - w = image->w * DPI / xres; - h = image->h * DPI / yres; - fz_pre_scale(&local_ctm, w, h); - fz_fill_image(dev, image, &local_ctm, 1); + return doc->page_count; } static int -tiff_meta(tiff_document *doc, int key, void *ptr, int size) +tiff_meta(fz_context *ctx, tiff_document *doc, int key, void *ptr, int size) { switch (key) { @@ -170,24 +115,71 @@ tiff_meta(tiff_document *doc, int key, void *ptr, int size) } static void -tiff_rebind(tiff_document *doc, fz_context *ctx) +tiff_close_document(fz_context *ctx, tiff_document *doc) { - doc->ctx = ctx; - fz_rebind_stream(doc->file, ctx); + fz_drop_buffer(ctx, doc->buffer); + fz_drop_stream(ctx, doc->file); + fz_free(ctx, doc); } -static void -tiff_init_document(tiff_document *doc) +static tiff_document * +tiff_open_document_with_stream(fz_context *ctx, fz_stream *file) { - doc->super.refs = 1; + tiff_document *doc; + unsigned char *buf; + int len; + + doc = fz_new_document(ctx, sizeof *doc); + doc->super.close = (fz_document_close_fn *)tiff_close_document; doc->super.count_pages = (fz_document_count_pages_fn *)tiff_count_pages; doc->super.load_page = (fz_document_load_page_fn *)tiff_load_page; - doc->super.bound_page = (fz_document_bound_page_fn *)tiff_bound_page; - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)tiff_run_page; - doc->super.free_page = (fz_document_free_page_fn *)tiff_free_page; doc->super.meta = (fz_document_meta_fn *)tiff_meta; - doc->super.rebind = (fz_document_rebind_fn *)tiff_rebind; + + doc->file = fz_keep_stream(ctx, file); + doc->page_count = 0; + + fz_try(ctx) + { + doc->buffer = fz_read_all(ctx, doc->file, 1024); + len = doc->buffer->len; + buf = doc->buffer->data; + + doc->page_count = fz_load_tiff_subimage_count(ctx, buf, len); + } + fz_catch(ctx) + { + tiff_close_document(ctx, doc); + fz_rethrow(ctx); + } + + return doc; +} + +static tiff_document * +tiff_open_document(fz_context *ctx, const char *filename) +{ + fz_stream *file; + tiff_document *doc; + + file = fz_open_file(ctx, filename); + if (!file) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); + + fz_try(ctx) + { + doc = tiff_open_document_with_stream(ctx, file); + } + fz_always(ctx) + { + fz_drop_stream(ctx, file); + } + fz_catch(ctx) + { + fz_rethrow(ctx); + } + + return doc; } static int diff --git a/source/fitz/bbox-device.c b/source/fitz/bbox-device.c index b8e63b56..b11a78a7 100644 --- a/source/fitz/bbox-device.c +++ b/source/fitz/bbox-device.c @@ -12,7 +12,7 @@ typedef struct fz_bbox_data_s } fz_bbox_data; static void -fz_bbox_add_rect(fz_device *dev, const fz_rect *rect, int clip) +fz_bbox_add_rect(fz_context *ctx, fz_device *dev, const fz_rect *rect, int clip) { fz_bbox_data *data = dev->user; fz_rect r = *rect; @@ -32,117 +32,117 @@ fz_bbox_add_rect(fz_device *dev, const fz_rect *rect, int clip) } static void -fz_bbox_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_bbox_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_path(dev->ctx, path, NULL, ctm, &r), 0); + fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, NULL, ctm, &r), 0); } static void -fz_bbox_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, +fz_bbox_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_path(dev->ctx, path, stroke, ctm, &r), 0); + fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, stroke, ctm, &r), 0); } static void -fz_bbox_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_bbox_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_text(dev->ctx, text, NULL, ctm, &r), 0); + fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, NULL, ctm, &r), 0); } static void -fz_bbox_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, +fz_bbox_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_text(dev->ctx, text, stroke, ctm, &r), 0); + fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, stroke, ctm, &r), 0); } static void -fz_bbox_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_bbox_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_shade(dev->ctx, shade, ctm, &r), 0); + fz_bbox_add_rect(ctx, dev, fz_bound_shade(ctx, shade, ctm, &r), 0); } static void -fz_bbox_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +fz_bbox_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { fz_rect r = fz_unit_rect; - fz_bbox_add_rect(dev, fz_transform_rect(&r, ctm), 0); + fz_bbox_add_rect(ctx, dev, fz_transform_rect(&r, ctm), 0); } static void -fz_bbox_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_bbox_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_rect r = fz_unit_rect; - fz_bbox_add_rect(dev, fz_transform_rect(&r, ctm), 0); + fz_bbox_add_rect(ctx, dev, fz_transform_rect(&r, ctm), 0); } static void -fz_bbox_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_bbox_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_path(dev->ctx, path, NULL, ctm, &r), 1); + fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, NULL, ctm, &r), 1); } static void -fz_bbox_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_bbox_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_path(dev->ctx, path, stroke, ctm, &r), 1); + fz_bbox_add_rect(ctx, dev, fz_bound_path(ctx, path, stroke, ctm, &r), 1); } static void -fz_bbox_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_bbox_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { fz_rect r = fz_infinite_rect; if (accumulate) - fz_bbox_add_rect(dev, &r, accumulate != 2); + fz_bbox_add_rect(ctx, dev, &r, accumulate != 2); else - fz_bbox_add_rect(dev, fz_bound_text(dev->ctx, text, NULL, ctm, &r), 1); + fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, NULL, ctm, &r), 1); } static void -fz_bbox_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_bbox_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_rect r; - fz_bbox_add_rect(dev, fz_bound_text(dev->ctx, text, stroke, ctm, &r), 1); + fz_bbox_add_rect(ctx, dev, fz_bound_text(ctx, text, stroke, ctm, &r), 1); } static void -fz_bbox_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_bbox_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { fz_rect r = fz_unit_rect; - fz_bbox_add_rect(dev, fz_transform_rect(&r, ctm), 1); + fz_bbox_add_rect(ctx, dev, fz_transform_rect(&r, ctm), 1); } static void -fz_bbox_pop_clip(fz_device *dev) +fz_bbox_pop_clip(fz_context *ctx, fz_device *dev) { fz_bbox_data *data = dev->user; if (data->top > 0) data->top--; else - fz_warn(dev->ctx, "unexpected pop clip"); + fz_warn(ctx, "unexpected pop clip"); } static void -fz_bbox_begin_mask(fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color) +fz_bbox_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color) { fz_bbox_data *data = dev->user; - fz_bbox_add_rect(dev, rect, 1); + fz_bbox_add_rect(ctx, dev, rect, 1); data->ignore++; } static void -fz_bbox_end_mask(fz_device *dev) +fz_bbox_end_mask(fz_context *ctx, fz_device *dev) { fz_bbox_data *data = dev->user; assert(data->ignore > 0); @@ -150,29 +150,29 @@ fz_bbox_end_mask(fz_device *dev) } static void -fz_bbox_begin_group(fz_device *dev, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) +fz_bbox_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) { - fz_bbox_add_rect(dev, rect, 1); + fz_bbox_add_rect(ctx, dev, rect, 1); } static void -fz_bbox_end_group(fz_device *dev) +fz_bbox_end_group(fz_context *ctx, fz_device *dev) { - fz_bbox_pop_clip(dev); + fz_bbox_pop_clip(ctx, dev); } static int -fz_bbox_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_bbox_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { fz_bbox_data *data = dev->user; fz_rect r = *area; - fz_bbox_add_rect(dev, fz_transform_rect(&r, ctm), 0); + fz_bbox_add_rect(ctx, dev, fz_transform_rect(&r, ctm), 0); data->ignore++; return 0; } static void -fz_bbox_end_tile(fz_device *dev) +fz_bbox_end_tile(fz_context *ctx, fz_device *dev) { fz_bbox_data *data = dev->user; assert(data->ignore > 0); @@ -180,12 +180,12 @@ fz_bbox_end_tile(fz_device *dev) } static void -fz_bbox_drop_user(fz_device *dev) +fz_bbox_drop_user(fz_context *ctx, fz_device *dev) { fz_bbox_data *data = dev->user; if (data->top > 0) - fz_warn(dev->ctx, "items left on stack in bbox device: %d", data->top); - fz_free(dev->ctx, dev->user); + fz_warn(ctx, "items left on stack in bbox device: %d", data->top); + fz_free(ctx, dev->user); } fz_device * diff --git a/source/fitz/buffer.c b/source/fitz/buffer.c index 12de453a..df0163f5 100644 --- a/source/fitz/buffer.c +++ b/source/fitz/buffer.c @@ -361,7 +361,7 @@ fz_test_buffer_write(fz_context *ctx) k = (rand() & 31)+1; if (k > j) k = j; - fz_write_buffer_bits(ctx, copy, fz_read_bits(stm, k), k); + fz_write_buffer_bits(ctx, copy, fz_read_bits(ctx, stm, k), k); j -= k; } while (j); diff --git a/source/fitz/colorspace.c b/source/fitz/colorspace.c index f1dff20c..42aa6129 100644 --- a/source/fitz/colorspace.c +++ b/source/fitz/colorspace.c @@ -286,7 +286,7 @@ fz_set_device_cmyk(fz_context *ctx, fz_colorspace *cs) } int -fz_colorspace_is_indexed(fz_colorspace *cs) +fz_colorspace_is_indexed(fz_context *ctx, fz_colorspace *cs) { return (cs && !strcmp(cs->name, "Indexed")); } @@ -840,14 +840,14 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src) { fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, ds, ss); + fz_lookup_color_converter(ctx, &cc, ds, ss); for (; xy > 0; xy--) { srcv[0] = *s++ / 255.0f * 100; srcv[1] = *s++ - 128; srcv[2] = *s++ - 128; - cc.convert(&cc, dstv, srcv); + cc.convert(ctx, &cc, dstv, srcv); for (k = 0; k < dstn; k++) *d++ = dstv[k] * 255; @@ -861,13 +861,13 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src) { fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, ds, ss); + fz_lookup_color_converter(ctx, &cc, ds, ss); for (; xy > 0; xy--) { for (k = 0; k < srcn; k++) srcv[k] = *s++ / 255.0f; - cc.convert(&cc, dstv, srcv); + cc.convert(ctx, &cc, dstv, srcv); for (k = 0; k < dstn; k++) *d++ = dstv[k] * 255; @@ -882,11 +882,11 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src) unsigned char lookup[FZ_MAX_COLORS * 256]; fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, ds, ss); + fz_lookup_color_converter(ctx, &cc, ds, ss); for (i = 0; i < 256; i++) { srcv[0] = i / 255.0f; - cc.convert(&cc, dstv, srcv); + cc.convert(ctx, &cc, dstv, srcv); for (k = 0; k < dstn; k++) lookup[i * dstn + k] = dstv[k] * 255; } @@ -909,7 +909,7 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src) unsigned char *sold = &dummy; fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, ds, ss); + fz_lookup_color_converter(ctx, &cc, ds, ss); lookup = fz_new_hash_table(ctx, 509, srcn, -1); for (; xy > 0; xy--) @@ -937,7 +937,7 @@ fz_std_conv_pixmap(fz_context *ctx, fz_pixmap *dst, fz_pixmap *src) { for (k = 0; k < srcn; k++) srcv[k] = *s++ / 255.0f; - cc.convert(&cc, dstv, srcv); + cc.convert(ctx, &cc, dstv, srcv); for (k = 0; k < dstn; k++) *d++ = dstv[k] * 255; @@ -1000,13 +1000,12 @@ fz_convert_pixmap(fz_context *ctx, fz_pixmap *dp, fz_pixmap *sp) /* Convert a single color */ static void -std_conv_color(fz_color_converter *cc, float *dstv, const float *srcv) +std_conv_color(fz_context *ctx, fz_color_converter *cc, float *dstv, const float *srcv) { float rgb[3]; int i; fz_colorspace *srcs = cc->ss; fz_colorspace *dsts = cc->ds; - fz_context *ctx = cc->ctx; if (srcs != dsts) { @@ -1024,7 +1023,7 @@ std_conv_color(fz_color_converter *cc, float *dstv, const float *srcv) } static void -g2rgb(fz_color_converter *cc, float *dv, const float *sv) +g2rgb(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { dv[0] = sv[0]; dv[1] = sv[0]; @@ -1032,7 +1031,7 @@ g2rgb(fz_color_converter *cc, float *dv, const float *sv) } static void -g2cmyk(fz_color_converter *cc, float *dv, const float *sv) +g2cmyk(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { dv[0] = 0; dv[1] = 0; @@ -1041,13 +1040,13 @@ g2cmyk(fz_color_converter *cc, float *dv, const float *sv) } static void -rgb2g(fz_color_converter *cc, float *dv, const float *sv) +rgb2g(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { dv[0] = sv[0] * 0.3f + sv[1] * 0.59f + sv[2] * 0.11f; } static void -rgb2bgr(fz_color_converter *cc, float *dv, const float *sv) +rgb2bgr(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { dv[0] = sv[2]; dv[1] = sv[1]; @@ -1055,7 +1054,7 @@ rgb2bgr(fz_color_converter *cc, float *dv, const float *sv) } static void -rgb2cmyk(fz_color_converter *cc, float *dv, const float *sv) +rgb2cmyk(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { float c = 1 - sv[0]; float m = 1 - sv[1]; @@ -1068,13 +1067,13 @@ rgb2cmyk(fz_color_converter *cc, float *dv, const float *sv) } static void -bgr2g(fz_color_converter *cc, float *dv, const float *sv) +bgr2g(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { dv[0] = sv[0] * 0.11f + sv[1] * 0.59f + sv[2] * 0.3f; } static void -bgr2cmyk(fz_color_converter *cc, float *dv, const float *sv) +bgr2cmyk(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { float c = 1 - sv[2]; float m = 1 - sv[1]; @@ -1087,7 +1086,7 @@ bgr2cmyk(fz_color_converter *cc, float *dv, const float *sv) } static void -cmyk2g(fz_color_converter *cc, float *dv, const float *sv) +cmyk2g(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { float c = sv[0] * 0.3f; float m = sv[1] * 0.59f; @@ -1096,10 +1095,10 @@ cmyk2g(fz_color_converter *cc, float *dv, const float *sv) } static void -cmyk2rgb(fz_color_converter *cc, float *dv, const float *sv) +cmyk2rgb(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { #ifdef SLOWCMYK - cmyk_to_rgb(cc->ctx, NULL, sv, dv); + cmyk_to_rgb(ctx, NULL, sv, dv); #else dv[0] = 1 - fz_min(sv[0] + sv[3], 1); dv[1] = 1 - fz_min(sv[1] + sv[3], 1); @@ -1108,11 +1107,11 @@ cmyk2rgb(fz_color_converter *cc, float *dv, const float *sv) } static void -cmyk2bgr(fz_color_converter *cc, float *dv, const float *sv) +cmyk2bgr(fz_context *ctx, fz_color_converter *cc, float *dv, const float *sv) { #ifdef SLOWCMYK float rgb[3]; - cmyk_to_rgb(cc->ctx, NULL, sv, rgb); + cmyk_to_rgb(ctx, NULL, sv, rgb); dv[0] = rgb[2]; dv[1] = rgb[1]; dv[2] = rgb[0]; @@ -1123,9 +1122,8 @@ cmyk2bgr(fz_color_converter *cc, float *dv, const float *sv) #endif } -void fz_lookup_color_converter(fz_color_converter *cc, fz_context *ctx, fz_colorspace *ds, fz_colorspace *ss) +void fz_lookup_color_converter(fz_context *ctx, fz_color_converter *cc, fz_colorspace *ds, fz_colorspace *ss) { - cc->ctx = ctx; cc->ds = ds; cc->ss = ss; if (ss == fz_default_gray) @@ -1182,8 +1180,8 @@ void fz_convert_color(fz_context *ctx, fz_colorspace *ds, float *dv, fz_colorspace *ss, const float *sv) { fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, ds, ss); - cc.convert(&cc, dv, sv); + fz_lookup_color_converter(ctx, &cc, ds, ss); + cc.convert(ctx, &cc, dv, sv); } /* Indexed */ @@ -1293,10 +1291,9 @@ typedef struct fz_cached_color_converter } fz_cached_color_converter; -static void fz_cached_color_convert(fz_color_converter *cc_, float *ds, const float *ss) +static void fz_cached_color_convert(fz_context *ctx, fz_color_converter *cc_, float *ds, const float *ss) { fz_cached_color_converter *cc = cc_->opaque; - fz_context *ctx = cc->base.ctx; void *val = fz_hash_find(ctx, cc->hash, ss); int n = cc->base.ds->n * sizeof(float); fz_color_converter *base_cc = &cc->base; @@ -1307,7 +1304,7 @@ static void fz_cached_color_convert(fz_color_converter *cc_, float *ds, const fl return; } - base_cc->convert(base_cc, ds, ss); + base_cc->convert(ctx, base_cc, ds, ss); val = fz_malloc(ctx, n); memcpy(val, ds, n); fz_try(ctx) @@ -1327,10 +1324,9 @@ void fz_init_cached_color_converter(fz_context *ctx, fz_color_converter *cc, fz_ fz_try(ctx) { - fz_lookup_color_converter(&cached->base, ctx, ds, ss); + fz_lookup_color_converter(ctx, &cached->base, ds, ss); cached->hash = fz_new_hash_table(ctx, 256, n * sizeof(float), -1); cc->convert = fz_cached_color_convert; - cc->ctx = ctx; cc->ds = ds; cc->ss = ss; cc->opaque = cached; @@ -1342,10 +1338,9 @@ void fz_init_cached_color_converter(fz_context *ctx, fz_color_converter *cc, fz_ } } -void fz_fin_cached_color_converter(fz_color_converter *cc_) +void fz_fin_cached_color_converter(fz_context *ctx, fz_color_converter *cc_) { fz_cached_color_converter *cc; - fz_context *ctx; int i, n; if (cc_ == NULL) @@ -1354,7 +1349,6 @@ void fz_fin_cached_color_converter(fz_color_converter *cc_) if (cc == NULL) return; cc_->opaque = NULL; - ctx = cc_->ctx; n = fz_hash_len(ctx, cc->hash); for (i = 0; i < n; i++) diff --git a/source/fitz/compressed-buffer.c b/source/fitz/compressed-buffer.c index 48f88eff..85890c72 100644 --- a/source/fitz/compressed-buffer.c +++ b/source/fitz/compressed-buffer.c @@ -28,7 +28,7 @@ fz_open_image_decomp_stream(fz_context *ctx, fz_stream *chain, fz_compression_pa { case FZ_IMAGE_FAX: *l2factor = 0; - return fz_open_faxd(chain, + return fz_open_faxd(ctx, chain, params->u.fax.k, params->u.fax.end_of_line, params->u.fax.encoded_byte_align, @@ -39,21 +39,21 @@ fz_open_image_decomp_stream(fz_context *ctx, fz_stream *chain, fz_compression_pa case FZ_IMAGE_JPEG: if (*l2factor > 3) *l2factor = 3; - return fz_open_dctd(chain, params->u.jpeg.color_transform, *l2factor, NULL); + return fz_open_dctd(ctx, chain, params->u.jpeg.color_transform, *l2factor, NULL); case FZ_IMAGE_RLD: *l2factor = 0; - return fz_open_rld(chain); + return fz_open_rld(ctx, chain); case FZ_IMAGE_FLATE: *l2factor = 0; - chain = fz_open_flated(chain, 15); + chain = fz_open_flated(ctx, chain, 15); if (params->u.flate.predictor > 1) - chain = fz_open_predict(chain, params->u.flate.predictor, params->u.flate.columns, params->u.flate.colors, params->u.flate.bpc); + chain = fz_open_predict(ctx, chain, params->u.flate.predictor, params->u.flate.columns, params->u.flate.colors, params->u.flate.bpc); return chain; case FZ_IMAGE_LZW: *l2factor = 0; - chain = fz_open_lzwd(chain, params->u.lzw.early_change); + chain = fz_open_lzwd(ctx, chain, params->u.lzw.early_change); if (params->u.lzw.predictor > 1) - chain = fz_open_predict(chain, params->u.lzw.predictor, params->u.lzw.columns, params->u.lzw.colors, params->u.lzw.bpc); + chain = fz_open_predict(ctx, chain, params->u.lzw.predictor, params->u.lzw.columns, params->u.lzw.colors, params->u.lzw.bpc); return chain; default: *l2factor = 0; diff --git a/source/fitz/device.c b/source/fitz/device.c index cb57256e..36a0f534 100644 --- a/source/fitz/device.c +++ b/source/fitz/device.c @@ -7,67 +7,56 @@ fz_new_device(fz_context *ctx, void *user) dev->hints = 0; dev->flags = 0; dev->user = user; - dev->ctx = ctx; dev->error_depth = 0; return dev; } void -fz_drop_device(fz_device *dev) +fz_drop_device(fz_context *ctx, fz_device *dev) { if (dev == NULL) return; if (dev->drop_user) - dev->drop_user(dev); - fz_free(dev->ctx, dev->container); - fz_free(dev->ctx, dev); + dev->drop_user(ctx, dev); + fz_free(ctx, dev->container); + fz_free(ctx, dev); } void -fz_enable_device_hints(fz_device *dev, int hints) +fz_enable_device_hints(fz_context *ctx, fz_device *dev, int hints) { dev->hints |= hints; } void -fz_disable_device_hints(fz_device *dev, int hints) +fz_disable_device_hints(fz_context *ctx, fz_device *dev, int hints) { dev->hints &= ~hints; } void -fz_rebind_device(fz_device *dev, fz_context *ctx) -{ - if (dev == NULL) - return; - dev->ctx = ctx; - if (dev->rebind) - dev->rebind(dev); -} - -void -fz_begin_page(fz_device *dev, const fz_rect *rect, const fz_matrix *ctm) +fz_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *rect, const fz_matrix *ctm) { if (dev->begin_page) - dev->begin_page(dev, rect, ctm); + dev->begin_page(ctx, dev, rect, ctm); } void -fz_end_page(fz_device *dev) +fz_end_page(fz_context *ctx, fz_device *dev) { if (dev->end_page) - dev->end_page(dev); + dev->end_page(ctx, dev); } static void -push_clip_stack(fz_device *dev, const fz_rect *rect, int flags) +push_clip_stack(fz_context *ctx, fz_device *dev, const fz_rect *rect, int flags) { if (dev->container_len == dev->container_cap) { int newmax = dev->container_cap * 2; if (newmax == 0) newmax = 4; - dev->container = fz_resize_array(dev->ctx, dev->container, newmax, sizeof(*dev->container)); + dev->container = fz_resize_array(ctx, dev->container, newmax, sizeof(*dev->container)); dev->container_cap = newmax; } if (dev->container_len == 0) @@ -83,7 +72,7 @@ push_clip_stack(fz_device *dev, const fz_rect *rect, int flags) } static void -push_clip_stack_accumulate(fz_device *dev, const fz_rect *rect, int accumulate) +push_clip_stack_accumulate(fz_context *ctx, fz_device *dev, const fz_rect *rect, int accumulate) { if (accumulate <= 1) { @@ -93,7 +82,7 @@ push_clip_stack_accumulate(fz_device *dev, const fz_rect *rect, int accumulate) int newmax = dev->container_cap * 2; if (newmax == 0) newmax = 4; - dev->container = fz_resize_array(dev->ctx, dev->container, newmax, sizeof(*dev->container)); + dev->container = fz_resize_array(ctx, dev->container, newmax, sizeof(*dev->container)); dev->container_cap = newmax; } if (dev->container_len > 0) @@ -115,37 +104,35 @@ push_clip_stack_accumulate(fz_device *dev, const fz_rect *rect, int accumulate) } static void -pop_clip_stack(fz_device *dev) +pop_clip_stack(fz_context *ctx, fz_device *dev) { if (dev->container_len > 0) dev->container_len--; } void -fz_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (dev->error_depth) return; if (dev->fill_path) - dev->fill_path(dev, path, even_odd, ctm, colorspace, color, alpha); + dev->fill_path(ctx, dev, path, even_odd, ctm, colorspace, color, alpha); } void -fz_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (dev->error_depth) return; if (dev->stroke_path) - dev->stroke_path(dev, path, stroke, ctm, colorspace, color, alpha); + dev->stroke_path(ctx, dev, path, stroke, ctm, colorspace, color, alpha); } void -fz_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -160,13 +147,13 @@ fz_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, c { fz_rect bbox; fz_bound_path(ctx, path, NULL, ctm, &bbox); - push_clip_stack(dev, &bbox, fz_device_container_stack_is_clip_path); + push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_path); } else - push_clip_stack(dev, rect, fz_device_container_stack_is_clip_path); + push_clip_stack(ctx, dev, rect, fz_device_container_stack_is_clip_path); } if (dev->clip_path) - dev->clip_path(dev, path, rect, even_odd, ctm); + dev->clip_path(ctx, dev, path, rect, even_odd, ctm); } fz_catch(ctx) { @@ -177,10 +164,8 @@ fz_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, c } void -fz_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -195,13 +180,13 @@ fz_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_strok { fz_rect bbox; fz_bound_path(ctx, path, stroke, ctm, &bbox); - push_clip_stack(dev, &bbox, fz_device_container_stack_is_clip_stroke_path); + push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_stroke_path); } else - push_clip_stack(dev, rect, fz_device_container_stack_is_clip_stroke_path); + push_clip_stack(ctx, dev, rect, fz_device_container_stack_is_clip_stroke_path); } if (dev->clip_stroke_path) - dev->clip_stroke_path(dev, path, rect, stroke, ctm); + dev->clip_stroke_path(ctx, dev, path, rect, stroke, ctm); } fz_catch(ctx) { @@ -212,30 +197,28 @@ fz_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_strok } void -fz_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (dev->error_depth) return; if (dev->fill_text) - dev->fill_text(dev, text, ctm, colorspace, color, alpha); + dev->fill_text(ctx, dev, text, ctm, colorspace, color, alpha); } void -fz_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (dev->error_depth) return; if (dev->stroke_text) - dev->stroke_text(dev, text, stroke, ctm, colorspace, color, alpha); + dev->stroke_text(ctx, dev, text, stroke, ctm, colorspace, color, alpha); } void -fz_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { if (accumulate == 0 || accumulate == 1) @@ -249,10 +232,10 @@ fz_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate { fz_rect bbox; fz_bound_text(ctx, text, NULL, ctm, &bbox); - push_clip_stack_accumulate(dev, &bbox, accumulate); + push_clip_stack_accumulate(ctx, dev, &bbox, accumulate); } if (dev->clip_text) - dev->clip_text(dev, text, ctm, accumulate); + dev->clip_text(ctx, dev, text, ctm, accumulate); } fz_catch(ctx) { @@ -265,10 +248,8 @@ fz_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate } void -fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -281,10 +262,10 @@ fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, cons { fz_rect bbox; fz_bound_text(ctx, text, stroke, ctm, &bbox); - push_clip_stack(dev, &bbox, fz_device_container_stack_is_clip_stroke_text); + push_clip_stack(ctx, dev, &bbox, fz_device_container_stack_is_clip_stroke_text); } if (dev->clip_stroke_text) - dev->clip_stroke_text(dev, text, stroke, ctm); + dev->clip_stroke_text(ctx, dev, text, stroke, ctm); } fz_catch(ctx) { @@ -295,63 +276,61 @@ fz_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, cons } void -fz_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { if (dev->error_depth) return; if (dev->ignore_text) - dev->ignore_text(dev, text, ctm); + dev->ignore_text(ctx, dev, text, ctm); } void -fz_pop_clip(fz_device *dev) +fz_pop_clip(fz_context *ctx, fz_device *dev) { if (dev->error_depth) { dev->error_depth--; if (dev->error_depth == 0) - fz_throw(dev->ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); + fz_throw(ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); return; } if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK) - pop_clip_stack(dev); + pop_clip_stack(ctx, dev); if (dev->pop_clip) - dev->pop_clip(dev); + dev->pop_clip(ctx, dev); } void -fz_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { if (dev->error_depth) return; if (dev->fill_shade) - dev->fill_shade(dev, shade, ctm, alpha); + dev->fill_shade(ctx, dev, shade, ctm, alpha); } void -fz_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +fz_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { if (dev->error_depth) return; if (dev->fill_image) - dev->fill_image(dev, image, ctm, alpha); + dev->fill_image(ctx, dev, image, ctm, alpha); } void -fz_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (dev->error_depth) return; if (dev->fill_image_mask) - dev->fill_image_mask(dev, image, ctm, colorspace, color, alpha); + dev->fill_image_mask(ctx, dev, image, ctm, colorspace, color, alpha); } void -fz_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -361,9 +340,9 @@ fz_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const f fz_try(ctx) { if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK) - push_clip_stack(dev, rect, fz_device_container_stack_is_clip_image_mask); + push_clip_stack(ctx, dev, rect, fz_device_container_stack_is_clip_image_mask); if (dev->clip_image_mask) - dev->clip_image_mask(dev, image, rect, ctm); + dev->clip_image_mask(ctx, dev, image, rect, ctm); } fz_catch(ctx) { @@ -374,10 +353,8 @@ fz_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const f } void -fz_begin_mask(fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, float *bc) +fz_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace *colorspace, float *bc) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -387,9 +364,9 @@ fz_begin_mask(fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace fz_try(ctx) { if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK) - push_clip_stack(dev, area, fz_device_container_stack_in_mask); + push_clip_stack(ctx, dev, area, fz_device_container_stack_in_mask); if (dev->begin_mask) - dev->begin_mask(dev, area, luminosity, colorspace, bc); + dev->begin_mask(ctx, dev, area, luminosity, colorspace, bc); } fz_catch(ctx) { @@ -400,10 +377,8 @@ fz_begin_mask(fz_device *dev, const fz_rect *area, int luminosity, fz_colorspace } void -fz_end_mask(fz_device *dev) +fz_end_mask(fz_context *ctx, fz_device *dev) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { /* Converts from mask to clip, so no change in stack depth */ @@ -417,7 +392,7 @@ fz_end_mask(fz_device *dev) fz_try(ctx) { if (dev->end_mask) - dev->end_mask(dev); + dev->end_mask(ctx, dev); } fz_catch(ctx) { @@ -428,10 +403,8 @@ fz_end_mask(fz_device *dev) } void -fz_begin_group(fz_device *dev, const fz_rect *area, int isolated, int knockout, int blendmode, float alpha) +fz_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *area, int isolated, int knockout, int blendmode, float alpha) { - fz_context *ctx = dev->ctx; - if (dev->error_depth) { dev->error_depth++; @@ -441,9 +414,9 @@ fz_begin_group(fz_device *dev, const fz_rect *area, int isolated, int knockout, fz_try(ctx) { if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK) - push_clip_stack(dev, area, fz_device_container_stack_is_group); + push_clip_stack(ctx, dev, area, fz_device_container_stack_is_group); if (dev->begin_group) - dev->begin_group(dev, area, isolated, knockout, blendmode, alpha); + dev->begin_group(ctx, dev, area, isolated, knockout, blendmode, alpha); } fz_catch(ctx) { @@ -454,32 +427,31 @@ fz_begin_group(fz_device *dev, const fz_rect *area, int isolated, int knockout, } void -fz_end_group(fz_device *dev) +fz_end_group(fz_context *ctx, fz_device *dev) { if (dev->error_depth) { dev->error_depth--; if (dev->error_depth == 0) - fz_throw(dev->ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); + fz_throw(ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); return; } if (dev->end_group) - dev->end_group(dev); + dev->end_group(ctx, dev); if (dev->hints & FZ_MAINTAIN_CONTAINER_STACK) - pop_clip_stack(dev); + pop_clip_stack(ctx, dev); } void -fz_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm) +fz_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm) { - (void)fz_begin_tile_id(dev, area, view, xstep, ystep, ctm, 0); + (void)fz_begin_tile_id(ctx, dev, area, view, xstep, ystep, ctm, 0); } int -fz_begin_tile_id(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_begin_tile_id(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - fz_context *ctx = dev->ctx; - int ret = 0; + int ret; if (dev->error_depth) { @@ -495,7 +467,7 @@ fz_begin_tile_id(fz_device *dev, const fz_rect *area, const fz_rect *view, float fz_try(ctx) { if (dev->begin_tile) - ret = dev->begin_tile(dev, area, view, xstep, ystep, ctm, id); + ret = dev->begin_tile(ctx, dev, area, view, xstep, ystep, ctm, id); } fz_catch(ctx) { @@ -507,15 +479,15 @@ fz_begin_tile_id(fz_device *dev, const fz_rect *area, const fz_rect *view, float } void -fz_end_tile(fz_device *dev) +fz_end_tile(fz_context *ctx, fz_device *dev) { if (dev->error_depth) { dev->error_depth--; if (dev->error_depth == 0) - fz_throw(dev->ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); + fz_throw(ctx, FZ_ERROR_GENERIC, "%s", dev->errmess); return; } if (dev->end_tile) - dev->end_tile(dev); + dev->end_tile(ctx, dev); } diff --git a/source/fitz/document.c b/source/fitz/document.c index 64de1bc0..63c9fd29 100644 --- a/source/fitz/document.c +++ b/source/fitz/document.c @@ -142,128 +142,142 @@ fz_open_document(fz_context *ctx, const char *filename) return NULL; } -fz_document * -fz_keep_document(fz_document *doc) +void * +fz_new_document(fz_context *ctx, int size) { - ++doc->refs; + fz_document *doc = fz_calloc(ctx, 1, size); + doc->refs = 1; return doc; } -void -fz_drop_document(fz_document *doc) +fz_document * +fz_keep_document(fz_context *ctx, fz_document *doc) { - if (doc && --doc->refs == 0 && doc->close) - doc->close(doc); + ++doc->refs; + return doc; } void -fz_rebind_document(fz_document *doc, fz_context *ctx) +fz_drop_document(fz_context *ctx, fz_document *doc) { - if (doc != NULL && doc->rebind != NULL) - doc->rebind(doc, ctx); + if (doc && --doc->refs == 0 && doc->close) + doc->close(ctx, doc); } int -fz_needs_password(fz_document *doc) +fz_needs_password(fz_context *ctx, fz_document *doc) { if (doc && doc->needs_password) - return doc->needs_password(doc); + return doc->needs_password(ctx, doc); return 0; } int -fz_authenticate_password(fz_document *doc, const char *password) +fz_authenticate_password(fz_context *ctx, fz_document *doc, const char *password) { if (doc && doc->authenticate_password) - return doc->authenticate_password(doc, password); + return doc->authenticate_password(ctx, doc, password); return 1; } fz_outline * -fz_load_outline(fz_document *doc) +fz_load_outline(fz_context *ctx, fz_document *doc) { if (doc && doc->load_outline) - return doc->load_outline(doc); + return doc->load_outline(ctx, doc); return NULL; } void -fz_layout_document(fz_document *doc, float w, float h, float em) +fz_layout_document(fz_context *ctx, fz_document *doc, float w, float h, float em) { if (doc && doc->layout) - doc->layout(doc, w, h, em); + doc->layout(ctx, doc, w, h, em); } int -fz_count_pages(fz_document *doc) +fz_count_pages(fz_context *ctx, fz_document *doc) { if (doc && doc->count_pages) - return doc->count_pages(doc); + return doc->count_pages(ctx, doc); return 0; } +int +fz_meta(fz_context *ctx, fz_document *doc, int key, void *ptr, int size) +{ + if (doc && doc->meta) + return doc->meta(ctx, doc, key, ptr, size); + return FZ_META_UNKNOWN_KEY; +} + +void +fz_write_document(fz_context *ctx, fz_document *doc, char *filename, fz_write_options *opts) +{ + if (doc && doc->write) + doc->write(ctx, doc, filename, opts); +} + fz_page * -fz_load_page(fz_document *doc, int number) +fz_load_page(fz_context *ctx, fz_document *doc, int number) { if (doc && doc->load_page) - return doc->load_page(doc, number); + return doc->load_page(ctx, doc, number); return NULL; } fz_link * -fz_load_links(fz_document *doc, fz_page *page) +fz_load_links(fz_context *ctx, fz_page *page) { - if (doc && doc->load_links && page) - return doc->load_links(doc, page); + if (page && page->load_links && page) + return page->load_links(ctx, page); return NULL; } fz_rect * -fz_bound_page(fz_document *doc, fz_page *page, fz_rect *r) +fz_bound_page(fz_context *ctx, fz_page *page, fz_rect *r) { - if (doc && doc->bound_page && page && r) - return doc->bound_page(doc, page, r); + if (page && page->bound_page && page && r) + return page->bound_page(ctx, page, r); if (r) *r = fz_empty_rect; return r; } fz_annot * -fz_first_annot(fz_document *doc, fz_page *page) +fz_first_annot(fz_context *ctx, fz_page *page) { - if (doc && doc->first_annot && page) - return doc->first_annot(doc, page); + if (page && page->first_annot && page) + return page->first_annot(ctx, page); return NULL; } fz_annot * -fz_next_annot(fz_document *doc, fz_annot *annot) +fz_next_annot(fz_context *ctx, fz_page *page, fz_annot *annot) { - if (doc && doc->next_annot && annot) - return doc->next_annot(doc, annot); + if (page && page->next_annot && annot) + return page->next_annot(ctx, page, annot); return NULL; } fz_rect * -fz_bound_annot(fz_document *doc, fz_annot *annot, fz_rect *rect) +fz_bound_annot(fz_context *ctx, fz_page *page, fz_annot *annot, fz_rect *rect) { - if (doc && doc->bound_annot && annot && rect) - return doc->bound_annot(doc, annot, rect); + if (page && page->bound_annot && annot && rect) + return page->bound_annot(ctx, page, annot, rect); if (rect) *rect = fz_empty_rect; return rect; } void -fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) +fz_run_page_contents(fz_context *ctx, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) { - if (doc && doc->run_page_contents && page) + if (page && page->run_page_contents && page) { - fz_context *ctx = dev->ctx; - fz_try(ctx) { - doc->run_page_contents(doc, page, dev, transform, cookie); + page->run_page_contents(ctx, page, dev, transform, cookie); } fz_catch(ctx) { @@ -274,15 +288,13 @@ fz_run_page_contents(fz_document *doc, fz_page *page, fz_device *dev, const fz_m } void -fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) +fz_run_annot(fz_context *ctx, fz_page *page, fz_annot *annot, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) { - if (doc && doc->run_annot && page && annot) + if (page && page->run_annot && page && annot) { - fz_context *ctx = dev->ctx; - fz_try(ctx) { - doc->run_annot(doc, page, annot, dev, transform, cookie); + page->run_annot(ctx, page, annot, dev, transform, cookie); } fz_catch(ctx) { @@ -293,25 +305,25 @@ fz_run_annot(fz_document *doc, fz_page *page, fz_annot *annot, fz_device *dev, c } void -fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) +fz_run_page(fz_context *ctx, fz_page *page, fz_device *dev, const fz_matrix *transform, fz_cookie *cookie) { fz_annot *annot; fz_rect mediabox; - fz_bound_page(doc, page, &mediabox); - fz_begin_page(dev, &mediabox, transform); + fz_bound_page(ctx, page, &mediabox); + fz_begin_page(ctx, dev, &mediabox, transform); - fz_run_page_contents(doc, page, dev, transform, cookie); + fz_run_page_contents(ctx, page, dev, transform, cookie); if (cookie && cookie->progress_max != -1) { int count = 1; - for (annot = fz_first_annot(doc, page); annot; annot = fz_next_annot(doc, annot)) + for (annot = fz_first_annot(ctx, page); annot; annot = fz_next_annot(ctx, page, annot)) count++; cookie->progress_max += count; } - for (annot = fz_first_annot(doc, page); annot; annot = fz_next_annot(doc, annot)) + for (annot = fz_first_annot(ctx, page); annot; annot = fz_next_annot(ctx, page, annot)) { /* Check the cookie for aborting */ if (cookie) @@ -321,43 +333,46 @@ fz_run_page(fz_document *doc, fz_page *page, fz_device *dev, const fz_matrix *tr cookie->progress++; } - fz_run_annot(doc, page, annot, dev, transform, cookie); + fz_run_annot(ctx, page, annot, dev, transform, cookie); } - fz_end_page(dev); + fz_end_page(ctx, dev); } -void -fz_free_page(fz_document *doc, fz_page *page) +void * +fz_new_page(fz_context *ctx, int size) { - if (doc && doc->free_page && page) - doc->free_page(doc, page); + fz_page *page = fz_calloc(ctx, 1, size); + page->refs = 1; + return page; } -int -fz_meta(fz_document *doc, int key, void *ptr, int size) +fz_page * +fz_keep_page(fz_context *ctx, fz_page *page) { - if (doc && doc->meta) - return doc->meta(doc, key, ptr, size); - return FZ_META_UNKNOWN_KEY; + if (page) + ++page->refs; + return page; +} + +void +fz_drop_page(fz_context *ctx, fz_page *page) +{ + if (page) { + if (--page->refs == 0 && page->drop_page_imp) + page->drop_page_imp(ctx, page); + } } fz_transition * -fz_page_presentation(fz_document *doc, fz_page *page, float *duration) +fz_page_presentation(fz_context *ctx, fz_page *page, float *duration) { float dummy; if (duration) *duration = 0; else duration = &dummy; - if (doc && doc->page_presentation && page) - return doc->page_presentation(doc, page, duration); + if (page && page->page_presentation && page) + return page->page_presentation(ctx, page, duration); return NULL; } - -void -fz_write_document(fz_document *doc, char *filename, fz_write_options *opts) -{ - if (doc && doc->write) - doc->write(doc, filename, opts); -} diff --git a/source/fitz/draw-device.c b/source/fitz/draw-device.c index 8701cd31..18ea53d9 100644 --- a/source/fitz/draw-device.c +++ b/source/fitz/draw-device.c @@ -38,7 +38,6 @@ struct fz_draw_state_s { struct fz_draw_device_s { fz_gel *gel; - fz_context *ctx; int flags; int top; fz_scale_cache *cache_x; @@ -77,11 +76,11 @@ static void dump_spaces(int x, const char *s) #endif #ifdef DUMP_STACK_CHANGES -#define STACK_PUSHED(A) stack_change(dev, ">" ## A) -#define STACK_POPPED(A) stack_change(dev, "<" ## A) -#define STACK_CONVERT(A) stack_change(dev, A) +#define STACK_PUSHED(A) stack_change(ctx, dev, ">" ## A) +#define STACK_POPPED(A) stack_change(ctx, dev, "<" ## A) +#define STACK_CONVERT(A) stack_change(ctx, dev, A) -static void stack_change(fz_draw_device *dev, char *s) +static void stack_change(fz_context *ctx, fz_draw_device *dev, char *s) { int depth = dev->top; int n; @@ -100,19 +99,19 @@ static void stack_change(fz_draw_device *dev, char *s) #endif -static void fz_grow_stack(fz_draw_device *dev) +static void fz_grow_stack(fz_context *ctx, fz_draw_device *dev) { int max = dev->stack_cap * 2; fz_draw_state *stack; if (dev->stack == &dev->init_stack[0]) { - stack = Memento_label(fz_malloc(dev->ctx, sizeof(*stack) * max), "draw device stack"); + stack = Memento_label(fz_malloc_array(ctx, max, sizeof *stack), "draw device stack"); memcpy(stack, dev->stack, sizeof(*stack) * dev->stack_cap); } else { - stack = fz_resize_array(dev->ctx, dev->stack, max, sizeof(*stack)); + stack = fz_resize_array(ctx, dev->stack, max, sizeof(*stack)); } dev->stack = stack; dev->stack_cap = max; @@ -122,22 +121,20 @@ static void fz_grow_stack(fz_draw_device *dev) * already having been initialised to contain the same thing. Simply * change any contents of state[1] that you want to and continue. */ static fz_draw_state * -push_stack(fz_draw_device *dev) +push_stack(fz_context *ctx, fz_draw_device *dev) { fz_draw_state *state; if (dev->top == dev->stack_cap-1) - fz_grow_stack(dev); + fz_grow_stack(ctx, dev); state = &dev->stack[dev->top]; dev->top++; memcpy(&state[1], state, sizeof(*state)); return state; } -static void emergency_pop_stack(fz_draw_device *dev, fz_draw_state *state) +static void emergency_pop_stack(fz_context *ctx, fz_draw_device *dev, fz_draw_state *state) { - fz_context *ctx = dev->ctx; - if (state[1].mask != state[0].mask) fz_drop_pixmap(ctx, state[1].mask); if (state[1].dest != state[0].dest) @@ -150,9 +147,8 @@ static void emergency_pop_stack(fz_draw_device *dev, fz_draw_state *state) } static fz_draw_state * -fz_knockout_begin(fz_draw_device *dev) +fz_knockout_begin(fz_context *ctx, fz_draw_device *dev) { - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *dest, *shape; fz_draw_state *state = &dev->stack[dev->top]; @@ -161,12 +157,12 @@ fz_knockout_begin(fz_draw_device *dev) if ((state->blendmode & FZ_BLEND_KNOCKOUT) == 0) return state; - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("knockout"); - fz_pixmap_bbox(dev->ctx, state->dest, &bbox); + fz_pixmap_bbox(ctx, state->dest, &bbox); fz_intersect_irect(&bbox, &state->scissor); - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); if (isolated) { @@ -197,8 +193,8 @@ fz_knockout_begin(fz_draw_device *dev) } else { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top-1, "Knockout begin\n"); @@ -211,12 +207,11 @@ fz_knockout_begin(fz_draw_device *dev) return &state[1]; } -static void fz_knockout_end(fz_draw_device *dev) +static void fz_knockout_end(fz_context *ctx, fz_draw_device *dev) { fz_draw_state *state; int blendmode; int isolated; - fz_context *ctx = dev->ctx; if (dev->top == 0) { @@ -233,12 +228,12 @@ static void fz_knockout_end(fz_draw_device *dev) #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Knockout end: blending "); + fz_dump_blend(ctx, state[1].dest, "Knockout end: blending "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); if (blendmode != 0) printf(" (blend %d)", blendmode); if (isolated != 0) @@ -254,26 +249,28 @@ static void fz_knockout_end(fz_draw_device *dev) * errors can cause the stack to get out of sync, and this saves our * bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) { if (state[0].shape) fz_paint_pixmap(state[0].shape, state[1].shape, 255); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif } static void -fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_draw_fill_path(fz_context *ctx, fz_device *devp, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; unsigned char colorbv[FZ_MAX_COLORS + 1]; @@ -284,48 +281,50 @@ fz_draw_fill_path(fz_device *devp, fz_path *path, int even_odd, const fz_matrix fz_colorspace *model = state->dest->colorspace; if (model == NULL) - model = fz_device_gray(dev->ctx); + model = fz_device_gray(ctx); if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (fz_is_empty_irect(&bbox)) return; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; - fz_scan_convert(dev->gel, even_odd, &bbox, state->dest, colorbv); + fz_scan_convert(ctx, gel, even_odd, &bbox, state->dest, colorbv); if (state->shape) { - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); colorbv[0] = alpha * 255; - fz_scan_convert(dev->gel, even_odd, &bbox, state->shape, colorbv); + fz_scan_convert(ctx, gel, even_odd, &bbox, state->shape, colorbv); } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_draw_stroke_path(fz_context *ctx, fz_device *devp, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; float linewidth = stroke->linewidth; @@ -337,81 +336,82 @@ fz_draw_stroke_path(fz_device *devp, fz_path *path, fz_stroke_state *stroke, con fz_colorspace *model = state->dest->colorspace; if (model == NULL) - model = fz_device_gray(dev->ctx); + model = fz_device_gray(ctx); if (linewidth * expansion < 0.1f) linewidth = 1 / expansion; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (fz_is_empty_irect(&bbox)) return; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; - fz_scan_convert(dev->gel, 0, &bbox, state->dest, colorbv); + fz_scan_convert(ctx, gel, 0, &bbox, state->dest, colorbv); if (state->shape) { - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); colorbv[0] = 255; - fz_scan_convert(dev->gel, 0, &bbox, state->shape, colorbv); + fz_scan_convert(ctx, gel, 0, &bbox, state->shape, colorbv); } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_draw_clip_path(fz_context *ctx, fz_device *devp, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; fz_irect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; - fz_context *ctx = dev->ctx; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); - fz_flatten_fill_path(dev->gel, path, ctm, flatness); - fz_sort_gel(dev->gel); + fz_reset_gel(ctx, gel, &state->scissor); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_sort_gel(ctx, gel); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip path"); model = state->dest->colorspace; - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (rect) { fz_irect bbox2; fz_intersect_irect(&bbox, fz_irect_from_rect(&bbox2, rect)); } - if (fz_is_empty_irect(&bbox) || fz_is_rect_gel(dev->gel)) + if (fz_is_empty_irect(&bbox) || fz_is_rect_gel(ctx, gel)) { state[1].scissor = bbox; state[1].mask = NULL; @@ -423,17 +423,17 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_ fz_try(ctx) { - state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].mask); - state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, state[1].dest); + state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].mask); + state[1].dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, state[1].dest); if (state[1].shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } - fz_scan_convert(dev->gel, even_odd, &bbox, state[1].mask, NULL); + fz_scan_convert(ctx, gel, even_odd, &bbox, state[1].mask, NULL); state[1].blendmode |= FZ_BLEND_ISOLATED; state[1].scissor = bbox; @@ -443,39 +443,40 @@ fz_draw_clip_path(fz_device *devp, fz_path *path, const fz_rect *rect, int even_ } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_draw_clip_stroke_path(fz_context *ctx, fz_device *devp, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; + fz_gel *gel = dev->gel; + float expansion = fz_matrix_expansion(ctm); float flatness = 0.3f / expansion; float linewidth = stroke->linewidth; fz_irect bbox; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model; - fz_context *ctx = dev->ctx; if (linewidth * expansion < 0.1f) linewidth = 1 / expansion; if (flatness < 0.001f) flatness = 0.001f; - fz_reset_gel(dev->gel, &state->scissor); + fz_reset_gel(ctx, gel, &state->scissor); if (stroke->dash_len > 0) - fz_flatten_dash_path(dev->gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(dev->gel, path, stroke, ctm, flatness, linewidth); - fz_sort_gel(dev->gel); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); + fz_sort_gel(ctx, gel); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip stroke"); model = state->dest->colorspace; - fz_intersect_irect(fz_bound_gel(dev->gel, &bbox), &state->scissor); + fz_intersect_irect(fz_bound_gel(ctx, gel, &bbox), &state->scissor); if (rect) { fz_irect bbox2; @@ -484,18 +485,18 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz fz_try(ctx) { - state[1].mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].mask); - state[1].dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, state[1].dest); + state[1].mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].mask); + state[1].dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, state[1].dest); if (state->shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } if (!fz_is_empty_irect(&bbox)) - fz_scan_convert(dev->gel, 0, &bbox, state[1].mask, NULL); + fz_scan_convert(ctx, gel, 0, &bbox, state[1].mask, NULL); state[1].blendmode |= FZ_BLEND_ISOLATED; state[1].scissor = bbox; @@ -505,7 +506,7 @@ fz_draw_clip_stroke_path(fz_device *devp, fz_path *path, const fz_rect *rect, fz } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } @@ -558,10 +559,11 @@ draw_glyph(unsigned char *colorbv, fz_pixmap *dst, fz_glyph *glyph, } static void -fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, +fz_draw_fill_text(fz_context *ctx, fz_device *devp, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + unsigned char colorbv[FZ_MAX_COLORS + 1]; unsigned char shapebv; float colorfv[FZ_MAX_COLORS]; @@ -572,9 +574,9 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -592,7 +594,7 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_glyph(dev->ctx, text->font, gid, &trm, model, &state->scissor); + glyph = fz_render_glyph(ctx, text->font, gid, &trm, model, &state->scissor); if (glyph) { fz_pixmap *pixmap = glyph->pixmap; @@ -611,33 +613,34 @@ fz_draw_fill_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, mat.e = x + pixmap->x; mat.f = y + pixmap->y; fz_paint_image(state->dest, &state->scissor, state->shape, pixmap, &mat, alpha * 255, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); } - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { - fz_draw_fill_path(devp, path, 0, ctm, colorspace, color, alpha); - fz_drop_path(dev->ctx, path); + fz_draw_fill_path(ctx, devp, path, 0, ctm, colorspace, color, alpha); + fz_drop_path(ctx, path); } else { - fz_warn(dev->ctx, "cannot render glyph"); + fz_warn(ctx, "cannot render glyph"); } } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, +fz_draw_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; + unsigned char colorbv[FZ_MAX_COLORS + 1]; float colorfv[FZ_MAX_COLORS]; fz_matrix tm, trm; @@ -647,9 +650,9 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -666,7 +669,7 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); + glyph = fz_render_stroked_glyph(ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -674,32 +677,31 @@ fz_draw_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, draw_glyph(colorbv, state->dest, glyph, x, y, &state->scissor); if (state->shape) draw_glyph(colorbv, state->shape, glyph, x, y, &state->scissor); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { - fz_draw_stroke_path(devp, path, stroke, ctm, colorspace, color, alpha); - fz_drop_path(dev->ctx, path); + fz_draw_stroke_path(ctx, devp, path, stroke, ctm, colorspace, color, alpha); + fz_drop_path(ctx, path); } else { - fz_warn(dev->ctx, "cannot render glyph"); + fz_warn(ctx, "cannot render glyph"); } } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_draw_clip_text(fz_context *ctx, fz_device *devp, fz_text *text, const fz_matrix *ctm, int accumulate) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; @@ -712,7 +714,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu /* If accumulate == 1 then this text object is the first (or only) in a sequence */ /* If accumulate == 2 then this text object is a continuation */ - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("clip text"); model = state->dest->colorspace; @@ -721,7 +723,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu /* make the mask the exact size needed */ fz_rect rect; - fz_irect_from_rect(&bbox, fz_bound_text(dev->ctx, text, NULL, ctm, &rect)); + fz_irect_from_rect(&bbox, fz_bound_text(ctx, text, NULL, ctm, &rect)); fz_intersect_irect(&bbox, &state->scissor); } else @@ -734,14 +736,14 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu { if (accumulate == 0 || accumulate == 1) { - mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); - dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); + dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } else shape = NULL; @@ -776,7 +778,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_glyph(dev->ctx, text->font, gid, &trm, model, &state->scissor); + glyph = fz_render_glyph(ctx, text->font, gid, &trm, model, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -784,11 +786,11 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu draw_glyph(NULL, mask, glyph, x, y, &bbox); if (state[1].shape) draw_glyph(NULL, state[1].shape, glyph, x, y, &bbox); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { fz_pixmap *old_dest; @@ -799,13 +801,13 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu state[1].mask = NULL; fz_try(ctx) { - fz_draw_fill_path(devp, path, 0, ctm, fz_device_gray(ctx), &white, 1); + fz_draw_fill_path(ctx, devp, path, 0, ctm, fz_device_gray(ctx), &white, 1); } fz_always(ctx) { state[1].mask = state[1].dest; state[1].dest = old_dest; - fz_drop_path(dev->ctx, path); + fz_drop_path(ctx, path); } fz_catch(ctx) { @@ -814,7 +816,7 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu } else { - fz_warn(dev->ctx, "cannot render glyph for clipping"); + fz_warn(ctx, "cannot render glyph for clipping"); } } } @@ -823,40 +825,39 @@ fz_draw_clip_text(fz_device *devp, fz_text *text, const fz_matrix *ctm, int accu fz_catch(ctx) { if (accumulate == 0 || accumulate == 1) - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); fz_rethrow(ctx); } } static void -fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_draw_clip_stroke_text(fz_context *ctx, fz_device *devp, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask, *dest, *shape; fz_matrix tm, trm; fz_glyph *glyph; int i, gid; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_colorspace *model = state->dest->colorspace; fz_rect rect; STACK_PUSHED("clip stroke text"); /* make the mask the exact size needed */ - fz_irect_from_rect(&bbox, fz_bound_text(dev->ctx, text, stroke, ctm, &rect)); + fz_irect_from_rect(&bbox, fz_bound_text(ctx, text, stroke, ctm, &rect)); fz_intersect_irect(&bbox, &state->scissor); fz_try(ctx) { - state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + state[1].mask = mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } else shape = state->shape; @@ -881,7 +882,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke tm.f = text->items[i].y; fz_concat(&trm, &tm, ctm); - glyph = fz_render_stroked_glyph(dev->ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); + glyph = fz_render_stroked_glyph(ctx, text->font, gid, &trm, ctm, stroke, &state->scissor); if (glyph) { int x = (int)trm.e; @@ -889,11 +890,11 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke draw_glyph(NULL, mask, glyph, x, y, &bbox); if (shape) draw_glyph(NULL, shape, glyph, x, y, &bbox); - fz_drop_glyph(dev->ctx, glyph); + fz_drop_glyph(ctx, glyph); } else { - fz_path *path = fz_outline_glyph(dev->ctx, text->font, gid, &tm); + fz_path *path = fz_outline_glyph(ctx, text->font, gid, &tm); if (path) { fz_pixmap *old_dest; @@ -905,13 +906,13 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke state[0].mask = NULL; fz_try(ctx) { - fz_draw_stroke_path(devp, path, stroke, ctm, fz_device_gray(ctx), &white, 1); + fz_draw_stroke_path(ctx, devp, path, stroke, ctm, fz_device_gray(ctx), &white, 1); } fz_always(ctx) { state[0].mask = state[0].dest; state[0].dest = old_dest; - fz_drop_path(dev->ctx, path); + fz_drop_path(ctx, path); } fz_catch(ctx) { @@ -920,7 +921,7 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke } else { - fz_warn(dev->ctx, "cannot render glyph for stroked clipping"); + fz_warn(ctx, "cannot render glyph for stroked clipping"); } } } @@ -928,17 +929,17 @@ fz_draw_clip_stroke_text(fz_device *devp, fz_text *text, fz_stroke_state *stroke } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_draw_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { } static void -fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_draw_fill_shade(fz_context *ctx, fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float alpha) { fz_draw_device *dev = devp->user; fz_rect bounds; @@ -949,7 +950,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; - fz_bound_shade(dev->ctx, shade, ctm, &bounds); + fz_bound_shade(ctx, shade, ctm, &bounds); scissor = state->scissor; fz_intersect_irect(fz_irect_from_rect(&bbox, &bounds), &scissor); @@ -958,24 +959,24 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float if (!model) { - fz_warn(dev->ctx, "cannot render shading directly to an alpha mask"); + fz_warn(ctx, "cannot render shading directly to an alpha mask"); return; } if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); dest = state->dest; shape = state->shape; if (alpha < 1) { - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); - fz_clear_pixmap(dev->ctx, dest); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); + fz_clear_pixmap(ctx, dest); if (shape) { - shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } } @@ -983,7 +984,7 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float { unsigned char *s; int x, y, n, i; - fz_convert_color(dev->ctx, model, colorfv, shade->colorspace, shade->background); + fz_convert_color(ctx, model, colorfv, shade->colorspace, shade->background); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = 255; @@ -1011,30 +1012,29 @@ fz_draw_fill_shade(fz_device *devp, fz_shade *shade, const fz_matrix *ctm, float } } - fz_paint_shade(dev->ctx, shade, ctm, dest, &bbox); + fz_paint_shade(ctx, shade, ctm, dest, &bbox); if (shape) - fz_clear_pixmap_rect_with_value(dev->ctx, shape, 255, &bbox); + fz_clear_pixmap_rect_with_value(ctx, shape, 255, &bbox); if (alpha < 1) { fz_paint_pixmap(state->dest, dest, alpha * 255); - fz_drop_pixmap(dev->ctx, dest); + fz_drop_pixmap(ctx, dest); if (shape) { fz_paint_pixmap(state->shape, shape, alpha * 255); - fz_drop_pixmap(dev->ctx, shape); + fz_drop_pixmap(ctx, shape); } } if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static fz_pixmap * -fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, const fz_irect *clip) +fz_transform_pixmap(fz_context *ctx, fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x, int y, int dx, int dy, int gridfit, const fz_irect *clip) { fz_pixmap *scaled; - fz_context *ctx = dev->ctx; if (ctm->a != 0 && ctm->b == 0 && ctm->c == 0 && ctm->d != 0) { @@ -1087,7 +1087,7 @@ fz_transform_pixmap(fz_draw_device *dev, fz_pixmap *image, fz_matrix *ctm, int x } static void -fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float alpha) +fz_draw_fill_image(fz_context *ctx, fz_device *devp, fz_image *image, const fz_matrix *ctm, float alpha) { fz_draw_device *dev = devp->user; fz_pixmap *converted = NULL; @@ -1096,7 +1096,6 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_pixmap *orig_pixmap; int after; int dx, dy; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_irect clip; @@ -1108,7 +1107,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float if (!model) { - fz_warn(dev->ctx, "cannot render image directly to an alpha mask"); + fz_warn(ctx, "cannot render image directly to an alpha mask"); return; } @@ -1128,7 +1127,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_try(ctx) { if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); after = 0; if (pixmap->colorspace == fz_device_gray(ctx)) @@ -1146,7 +1145,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float if (dx < pixmap->w && dy < pixmap->h && !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) @@ -1179,7 +1178,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float fz_paint_image(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, alpha * 255, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } fz_always(ctx) { @@ -1194,7 +1193,7 @@ fz_draw_fill_image(fz_device *devp, fz_image *image, const fz_matrix *ctm, float } static void -fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, +fz_draw_fill_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_draw_device *dev = devp->user; @@ -1205,7 +1204,6 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_pixmap *orig_pixmap; int dx, dy; int i; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_irect clip; @@ -1225,25 +1223,25 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_try(ctx) { if (state->blendmode & FZ_BLEND_KNOCKOUT) - state = fz_knockout_begin(dev); + state = fz_knockout_begin(ctx, dev); if (dx < pixmap->w && dy < pixmap->h) { int gridfit = alpha == 1.0f && !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap_cached(dev->ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); + scaled = fz_scale_pixmap_cached(ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); } if (scaled) pixmap = scaled; } - fz_convert_color(dev->ctx, model, colorfv, colorspace, color); + fz_convert_color(ctx, model, colorfv, colorspace, color); for (i = 0; i < model->n; i++) colorbv[i] = colorfv[i] * 255; colorbv[i] = alpha * 255; @@ -1251,14 +1249,14 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, fz_paint_image_with_color(state->dest, &state->scissor, state->shape, pixmap, &local_ctm, colorbv, !(devp->hints & FZ_DONT_INTERPOLATE_IMAGES)); if (scaled) - fz_drop_pixmap(dev->ctx, scaled); + fz_drop_pixmap(ctx, scaled); if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } fz_always(ctx) { - fz_drop_pixmap(dev->ctx, orig_pixmap); + fz_drop_pixmap(ctx, orig_pixmap); } fz_catch(ctx) { @@ -1267,10 +1265,9 @@ fz_draw_fill_image_mask(fz_device *devp, fz_image *image, const fz_matrix *ctm, } static void -fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_draw_clip_image_mask(fz_context *ctx, fz_device *devp, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_irect bbox; fz_pixmap *mask = NULL; fz_pixmap *dest = NULL; @@ -1279,7 +1276,7 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c fz_pixmap *pixmap = NULL; fz_pixmap *orig_pixmap = NULL; int dx, dy; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_colorspace *model = state->dest->colorspace; fz_irect clip; fz_matrix local_ctm = *ctm; @@ -1326,15 +1323,15 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c pixmap = fz_new_pixmap_from_image(ctx, image, dx, dy); orig_pixmap = pixmap; - state[1].mask = mask = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, mask); + state[1].mask = mask = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, mask); - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); - fz_clear_pixmap(dev->ctx, dest); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); + fz_clear_pixmap(ctx, dest); if (state->shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, shape); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, shape); } state[1].blendmode |= FZ_BLEND_ISOLATED; @@ -1343,14 +1340,14 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c if (dx < pixmap->w && dy < pixmap->h) { int gridfit = !(dev->flags & FZ_DRAWDEV_FLAGS_TYPE3); - scaled = fz_transform_pixmap(dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); + scaled = fz_transform_pixmap(ctx, dev, pixmap, &local_ctm, state->dest->x, state->dest->y, dx, dy, gridfit, &clip); if (!scaled) { if (dx < 1) dx = 1; if (dy < 1) dy = 1; - scaled = fz_scale_pixmap_cached(dev->ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); + scaled = fz_scale_pixmap_cached(ctx, pixmap, pixmap->x, pixmap->y, dx, dy, NULL, dev->cache_x, dev->cache_y); } if (scaled) pixmap = scaled; @@ -1364,15 +1361,14 @@ fz_draw_clip_image_mask(fz_device *devp, fz_image *image, const fz_rect *rect, c } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_pop_clip(fz_device *devp) +fz_draw_pop_clip(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1390,31 +1386,31 @@ fz_draw_pop_clip(fz_device *devp) { #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Clipping "); + fz_dump_blend(ctx, state[1].dest, "Clipping "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); - fz_dump_blend(dev->ctx, state[1].mask, " with "); + fz_dump_blend(ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[1].mask, " with "); #endif fz_paint_pixmap_with_mask(state[0].dest, state[1].dest, state[1].mask); if (state[0].shape != state[1].shape) { fz_paint_pixmap_with_mask(state[0].shape, state[1].shape, state[1].mask); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } /* The following tests should not be required, but just occasionally * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].mask != state[1].mask) - fz_drop_pixmap(dev->ctx, state[1].mask); + fz_drop_pixmap(ctx, state[1].mask); if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif } @@ -1427,21 +1423,20 @@ fz_draw_pop_clip(fz_device *devp) } static void -fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *colorfv) +fz_draw_begin_mask(fz_context *ctx, fz_device *devp, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *colorfv) { fz_draw_device *dev = devp->user; fz_pixmap *dest; fz_irect bbox; - fz_draw_state *state = push_stack(dev); + fz_draw_state *state = push_stack(ctx, dev); fz_pixmap *shape = state->shape; - fz_context *ctx = dev->ctx; STACK_PUSHED("mask"); fz_intersect_irect(fz_irect_from_rect(&bbox, rect), &state->scissor); fz_try(ctx) { - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, fz_device_gray(ctx), &bbox); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, fz_device_gray(ctx), &bbox); if (state->shape) { /* FIXME: If we ever want to support AIS true, then @@ -1458,16 +1453,16 @@ fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colo float bc; if (!colorspace) colorspace = fz_device_gray(ctx); - fz_convert_color(dev->ctx, fz_device_gray(ctx), &bc, colorspace, colorfv); - fz_clear_pixmap_with_value(dev->ctx, dest, bc * 255); + fz_convert_color(ctx, fz_device_gray(ctx), &bc, colorspace, colorfv); + fz_clear_pixmap_with_value(ctx, dest, bc * 255); if (shape) - fz_clear_pixmap_with_value(dev->ctx, shape, 255); + fz_clear_pixmap_with_value(ctx, shape, 255); } else { - fz_clear_pixmap(dev->ctx, dest); + fz_clear_pixmap(ctx, dest); if (shape) - fz_clear_pixmap(dev->ctx, shape); + fz_clear_pixmap(ctx, shape); } #ifdef DUMP_GROUP_BLENDS @@ -1478,18 +1473,17 @@ fz_draw_begin_mask(fz_device *devp, const fz_rect *rect, int luminosity, fz_colo } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_end_mask(fz_device *devp) +fz_draw_end_mask(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; fz_pixmap *temp, *dest; fz_irect bbox; int luminosity; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1508,21 +1502,21 @@ fz_draw_end_mask(fz_device *devp) fz_try(ctx) { /* convert to alpha mask */ - temp = fz_alpha_from_gray(dev->ctx, state[1].dest, luminosity); + temp = fz_alpha_from_gray(ctx, state[1].dest, luminosity); if (state[1].mask != state[0].mask) - fz_drop_pixmap(dev->ctx, state[1].mask); + fz_drop_pixmap(ctx, state[1].mask); state[1].mask = temp; if (state[1].dest != state[0].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); state[1].dest = NULL; if (state[1].shape != state[0].shape) - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); state[1].shape = NULL; /* create new dest scratch buffer */ fz_pixmap_bbox(ctx, temp, &bbox); - dest = fz_new_pixmap_with_bbox(dev->ctx, state->dest->colorspace, &bbox); - fz_clear_pixmap(dev->ctx, dest); + dest = fz_new_pixmap_with_bbox(ctx, state->dest->colorspace, &bbox); + fz_clear_pixmap(ctx, dest); /* push soft mask as clip mask */ state[1].dest = dest; @@ -1531,31 +1525,30 @@ fz_draw_end_mask(fz_device *devp) * clip mask when we pop. So create a new shape now. */ if (state[0].shape) { - state[1].shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); + fz_clear_pixmap(ctx, state[1].shape); } state[1].scissor = bbox; } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) +fz_draw_begin_group(fz_context *ctx, fz_device *devp, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) { fz_draw_device *dev = devp->user; fz_irect bbox; fz_pixmap *dest; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_begin(dev); + fz_knockout_begin(ctx, dev); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("group"); fz_intersect_irect(fz_irect_from_rect(&bbox, rect), &state->scissor); @@ -1570,11 +1563,11 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc if (isolated) { - fz_clear_pixmap(dev->ctx, dest); + fz_clear_pixmap(ctx, dest); } else { - fz_copy_pixmap_rect(dev->ctx, dest, state[0].dest, &bbox); + fz_copy_pixmap_rect(ctx, dest, state[0].dest, &bbox); } if (blendmode == 0 && alpha == 1.0 && isolated) @@ -1586,7 +1579,7 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc else { state[1].shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); - fz_clear_pixmap(dev->ctx, state[1].shape); + fz_clear_pixmap(ctx, state[1].shape); } state[1].alpha = alpha; @@ -1599,18 +1592,17 @@ fz_draw_begin_group(fz_device *devp, const fz_rect *rect, int isolated, int knoc } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } } static void -fz_draw_end_group(fz_device *devp) +fz_draw_end_group(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; int blendmode; int isolated; float alpha; - fz_context *ctx = dev->ctx; fz_draw_state *state; if (dev->top == 0) @@ -1626,12 +1618,12 @@ fz_draw_end_group(fz_device *devp) isolated = state[1].blendmode & FZ_BLEND_ISOLATED; #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Group end: blending "); + fz_dump_blend(ctx, state[1].dest, "Group end: blending "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); if (alpha != 1.0f) printf(" (alpha %g)", alpha); if (blendmode != 0) @@ -1650,22 +1642,22 @@ fz_draw_end_group(fz_device *devp) * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) { if (state[0].shape) fz_paint_pixmap(state[0].shape, state[1].shape, alpha * 255); - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); } #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif if (state[0].blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } typedef struct @@ -1683,7 +1675,7 @@ typedef struct } tile_record; static int -fz_make_hash_tile_key(fz_store_hash *hash, void *key_) +fz_make_hash_tile_key(fz_context *ctx, fz_store_hash *hash, void *key_) { tile_key *key = (tile_key *)key_; @@ -1723,7 +1715,7 @@ fz_drop_tile_key(fz_context *ctx, void *key_) } static int -fz_cmp_tile_key(void *k0_, void *k1_) +fz_cmp_tile_key(fz_context *ctx, void *k0_, void *k1_) { tile_key *k0 = (tile_key *)k0_; tile_key *k1 = (tile_key *)k1_; @@ -1733,7 +1725,7 @@ fz_cmp_tile_key(void *k0_, void *k1_) #ifndef NDEBUG static void -fz_debug_tile(FILE *out, void *key_) +fz_debug_tile(fz_context *ctx, FILE *out, void *key_) { tile_key *key = (tile_key *)key_; @@ -1789,13 +1781,12 @@ fz_tile_size(fz_context *ctx, tile_record *tile) } static int -fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_draw_begin_tile(fz_context *ctx, fz_device *devp, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { fz_draw_device *dev = devp->user; fz_pixmap *dest = NULL; fz_pixmap *shape; fz_irect bbox; - fz_context *ctx = dev->ctx; fz_draw_state *state = &dev->stack[dev->top]; fz_colorspace *model = state->dest->colorspace; fz_rect local_view = *view; @@ -1804,9 +1795,9 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl /* ctm maps from pattern space to device space */ if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_begin(dev); + fz_knockout_begin(ctx, dev); - state = push_stack(dev); + state = push_stack(ctx, dev); STACK_PUSHED("tile"); fz_irect_from_rect(&bbox, fz_transform_rect(&local_view, ctm)); /* We should never have a bbox that entirely covers our destination. @@ -1851,12 +1842,12 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl fz_try(ctx) { - state[1].dest = dest = fz_new_pixmap_with_bbox(dev->ctx, model, &bbox); + state[1].dest = dest = fz_new_pixmap_with_bbox(ctx, model, &bbox); fz_clear_pixmap(ctx, dest); shape = state[0].shape; if (shape) { - state[1].shape = shape = fz_new_pixmap_with_bbox(dev->ctx, NULL, &bbox); + state[1].shape = shape = fz_new_pixmap_with_bbox(ctx, NULL, &bbox); fz_clear_pixmap(ctx, shape); } state[1].blendmode |= FZ_BLEND_ISOLATED; @@ -1873,14 +1864,14 @@ fz_draw_begin_tile(fz_device *devp, const fz_rect *area, const fz_rect *view, fl } fz_catch(ctx) { - emergency_pop_stack(dev, state); + emergency_pop_stack(ctx, dev, state); } return 0; } static void -fz_draw_end_tile(fz_device *devp) +fz_draw_end_tile(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; float xstep, ystep; @@ -1888,7 +1879,6 @@ fz_draw_end_tile(fz_device *devp) fz_irect area, scissor; fz_rect scissor_tmp; int x0, y0, x1, y1, x, y; - fz_context *ctx = dev->ctx; fz_draw_state *state; tile_record *tile; tile_key *key; @@ -1940,12 +1930,12 @@ fz_draw_end_tile(fz_device *devp) #ifdef DUMP_GROUP_BLENDS dump_spaces(dev->top, ""); - fz_dump_blend(dev->ctx, state[1].dest, "Tiling "); + fz_dump_blend(ctx, state[1].dest, "Tiling "); if (state[1].shape) - fz_dump_blend(dev->ctx, state[1].shape, "/"); - fz_dump_blend(dev->ctx, state[0].dest, " onto "); + fz_dump_blend(ctx, state[1].shape, "/"); + fz_dump_blend(ctx, state[0].dest, " onto "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); #endif for (y = y0; y < y1; y++) @@ -2023,25 +2013,26 @@ fz_draw_end_tile(fz_device *devp) * errors can cause the stack to get out of sync, and this might save * our bacon. */ if (state[0].dest != state[1].dest) - fz_drop_pixmap(dev->ctx, state[1].dest); + fz_drop_pixmap(ctx, state[1].dest); if (state[0].shape != state[1].shape) - fz_drop_pixmap(dev->ctx, state[1].shape); + fz_drop_pixmap(ctx, state[1].shape); #ifdef DUMP_GROUP_BLENDS - fz_dump_blend(dev->ctx, state[0].dest, " to get "); + fz_dump_blend(ctx, state[0].dest, " to get "); if (state[0].shape) - fz_dump_blend(dev->ctx, state[0].shape, "/"); + fz_dump_blend(ctx, state[0].shape, "/"); printf("\n"); #endif if (state->blendmode & FZ_BLEND_KNOCKOUT) - fz_knockout_end(dev); + fz_knockout_end(ctx, dev); } static void -fz_draw_drop_user(fz_device *devp) +fz_draw_drop_user(fz_context *ctx, fz_device *devp) { fz_draw_device *dev = devp->user; - fz_context *ctx = dev->ctx; + fz_gel *gel = dev->gel; + /* pop and free the stacks */ if (dev->top > 0) fz_warn(ctx, "items left on stack in draw device: %d", dev->top+1); @@ -2064,7 +2055,7 @@ fz_draw_drop_user(fz_device *devp) fz_free(ctx, dev->stack); fz_drop_scale_cache(ctx, dev->cache_x); fz_drop_scale_cache(ctx, dev->cache_y); - fz_drop_gel(dev->gel); + fz_drop_gel(ctx, gel); fz_free(ctx, dev); } @@ -2079,7 +2070,6 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) { ddev->gel = fz_new_gel(ctx); ddev->flags = 0; - ddev->ctx = ctx; ddev->top = 0; ddev->cache_x = fz_new_scale_cache(ctx); ddev->cache_y = fz_new_scale_cache(ctx); @@ -2100,7 +2090,7 @@ fz_new_draw_device(fz_context *ctx, fz_pixmap *dest) { fz_drop_scale_cache(ctx, ddev->cache_x); fz_drop_scale_cache(ctx, ddev->cache_y); - fz_drop_gel(ddev->gel); + fz_drop_gel(ctx, ddev->gel); fz_free(ctx, ddev); fz_rethrow(ctx); } @@ -2166,18 +2156,18 @@ fz_bound_path_accurate(fz_context *ctx, fz_irect *bbox, const fz_irect *scissor, { fz_gel *gel = fz_new_gel(ctx); - fz_reset_gel(gel, scissor); + fz_reset_gel(ctx, gel, scissor); if (stroke) { if (stroke->dash_len > 0) - fz_flatten_dash_path(gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_dash_path(ctx, gel, path, stroke, ctm, flatness, linewidth); else - fz_flatten_stroke_path(gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); } else - fz_flatten_fill_path(gel, path, ctm, flatness); - fz_bound_gel(gel, bbox); - fz_drop_gel(gel); + fz_flatten_fill_path(ctx, gel, path, ctm, flatness); + fz_bound_gel(ctx, gel, bbox); + fz_drop_gel(ctx, gel); return bbox; } diff --git a/source/fitz/draw-edge.c b/source/fitz/draw-edge.c index e1fd5f37..a4c0d02e 100644 --- a/source/fitz/draw-edge.c +++ b/source/fitz/draw-edge.c @@ -165,7 +165,6 @@ struct fz_gel_s fz_edge *edges; int acap, alen; fz_edge **active; - fz_context *ctx; }; fz_gel * @@ -177,7 +176,6 @@ fz_new_gel(fz_context *ctx) fz_try(ctx) { gel->edges = NULL; - gel->ctx = ctx; gel->cap = 512; gel->len = 0; gel->edges = fz_malloc_array(ctx, gel->cap, sizeof(fz_edge)); @@ -204,9 +202,9 @@ fz_new_gel(fz_context *ctx) } void -fz_reset_gel(fz_gel *gel, const fz_irect *clip) +fz_reset_gel(fz_context *ctx, fz_gel *gel, const fz_irect *clip) { - fz_aa_context *ctxaa = gel->ctx->aa; + fz_aa_context *ctxaa = ctx->aa; if (fz_is_infinite_irect(clip)) { @@ -228,19 +226,19 @@ fz_reset_gel(fz_gel *gel, const fz_irect *clip) } void -fz_drop_gel(fz_gel *gel) +fz_drop_gel(fz_context *ctx, fz_gel *gel) { if (gel == NULL) return; - fz_free(gel->ctx, gel->active); - fz_free(gel->ctx, gel->edges); - fz_free(gel->ctx, gel); + fz_free(ctx, gel->active); + fz_free(ctx, gel->edges); + fz_free(ctx, gel); } fz_irect * -fz_bound_gel(const fz_gel *gel, fz_irect *bbox) +fz_bound_gel(fz_context *ctx, const fz_gel *gel, fz_irect *bbox) { - fz_aa_context *ctxaa = gel->ctx->aa; + fz_aa_context *ctxaa = ctx->aa; if (gel->len == 0) { *bbox = fz_empty_irect; @@ -256,9 +254,9 @@ fz_bound_gel(const fz_gel *gel, fz_irect *bbox) } fz_rect * -fz_gel_scissor(const fz_gel *gel, fz_rect *r) +fz_gel_scissor(fz_context *ctx, const fz_gel *gel, fz_rect *r) { - fz_aa_context *ctxaa = gel->ctx->aa; + fz_aa_context *ctxaa = ctx->aa; r->x0 = gel->clip.x0 / fz_aa_hscale; r->x1 = gel->clip.x1 / fz_aa_vscale; @@ -298,7 +296,7 @@ clip_lerp_x(int val, int m, int x0, int y0, int x1, int y1, int *out) } static void -fz_insert_gel_raw(fz_gel *gel, int x0, int y0, int x1, int y1) +fz_insert_gel_raw(fz_context *ctx, fz_gel *gel, int x0, int y0, int x1, int y1) { fz_edge *edge; int dx, dy; @@ -327,7 +325,7 @@ fz_insert_gel_raw(fz_gel *gel, int x0, int y0, int x1, int y1) if (gel->len + 1 == gel->cap) { int new_cap = gel->cap * 2; - gel->edges = fz_resize_array(gel->ctx, gel->edges, new_cap, sizeof(fz_edge)); + gel->edges = fz_resize_array(ctx, gel->edges, new_cap, sizeof(fz_edge)); gel->cap = new_cap; } @@ -364,11 +362,11 @@ fz_insert_gel_raw(fz_gel *gel, int x0, int y0, int x1, int y1) } void -fz_insert_gel(fz_gel *gel, float fx0, float fy0, float fx1, float fy1) +fz_insert_gel(fz_context *ctx, fz_gel *gel, float fx0, float fy0, float fx1, float fy1) { int x0, y0, x1, y1; int d, v; - fz_aa_context *ctxaa = gel->ctx->aa; + fz_aa_context *ctxaa = ctx->aa; fx0 = floorf(fx0 * fz_aa_hscale); fx1 = floorf(fx1 * fz_aa_hscale); @@ -399,12 +397,12 @@ fz_insert_gel(fz_gel *gel, float fx0, float fy0, float fx1, float fy1) x0 = x1 = gel->clip.x0; } if (d == LEAVE) { - fz_insert_gel_raw(gel, gel->clip.x0, v, gel->clip.x0, y1); + fz_insert_gel_raw(ctx, gel, gel->clip.x0, v, gel->clip.x0, y1); x1 = gel->clip.x0; y1 = v; } if (d == ENTER) { - fz_insert_gel_raw(gel, gel->clip.x0, y0, gel->clip.x0, v); + fz_insert_gel_raw(ctx, gel, gel->clip.x0, y0, gel->clip.x0, v); x0 = gel->clip.x0; y0 = v; } @@ -414,20 +412,21 @@ fz_insert_gel(fz_gel *gel, float fx0, float fy0, float fx1, float fy1) x0 = x1 = gel->clip.x1; } if (d == LEAVE) { - fz_insert_gel_raw(gel, gel->clip.x1, v, gel->clip.x1, y1); + fz_insert_gel_raw(ctx, gel, gel->clip.x1, v, gel->clip.x1, y1); x1 = gel->clip.x1; y1 = v; } if (d == ENTER) { - fz_insert_gel_raw(gel, gel->clip.x1, y0, gel->clip.x1, v); + fz_insert_gel_raw(ctx, gel, gel->clip.x1, y0, gel->clip.x1, v); x0 = gel->clip.x1; y0 = v; } - fz_insert_gel_raw(gel, x0, y0, x1, y1); + fz_insert_gel_raw(ctx, gel, x0, y0, x1, y1); } -static int cmpedge(const void *va, const void *vb) +static int +cmpedge(const void *va, const void *vb) { const fz_edge *a = va; const fz_edge *b = vb; @@ -435,7 +434,7 @@ static int cmpedge(const void *va, const void *vb) } void -fz_sort_gel(fz_gel *gel) +fz_sort_gel(fz_context *ctx, fz_gel *gel) { fz_edge *a = gel->edges; int n = gel->len; @@ -479,7 +478,7 @@ fz_sort_gel(fz_gel *gel) } int -fz_is_rect_gel(fz_gel *gel) +fz_is_rect_gel(fz_context *ctx, fz_gel *gel) { /* a rectangular path is converted into two vertical edges of identical height */ if (gel->len == 2) @@ -531,7 +530,7 @@ sort_active(fz_edge **a, int n) } static int -insert_active(fz_gel *gel, int y, int *e_) +insert_active(fz_context *ctx, fz_gel *gel, int y, int *e_) { int h_min = INT_MAX; int e = *e_; @@ -542,7 +541,7 @@ insert_active(fz_gel *gel, int y, int *e_) do { if (gel->alen + 1 == gel->acap) { int newcap = gel->acap + 64; - fz_edge **newactive = fz_resize_array(gel->ctx, gel->active, newcap, sizeof(fz_edge*)); + fz_edge **newactive = fz_resize_array(ctx, gel->active, newcap, sizeof(fz_edge*)); gel->active = newactive; gel->acap = newcap; } @@ -576,7 +575,7 @@ insert_active(fz_gel *gel, int y, int *e_) } static void -advance_active(fz_gel *gel, int inc) +advance_active(fz_context *ctx, fz_gel *gel, int inc) { fz_edge *edge; int i = 0; @@ -608,7 +607,8 @@ advance_active(fz_gel *gel, int inc) * Anti-aliased scan conversion. */ -static inline void add_span_aa(fz_aa_context *ctxaa, int *list, int x0, int x1, int xofs, int h) +static inline void +add_span_aa(fz_aa_context *ctxaa, int *list, int x0, int x1, int xofs, int h) { int x0pix, x0sub; int x1pix, x1sub; @@ -643,12 +643,13 @@ static inline void add_span_aa(fz_aa_context *ctxaa, int *list, int x0, int x1, } } -static inline void non_zero_winding_aa(fz_gel *gel, int *list, int xofs, int h) +static inline void +non_zero_winding_aa(fz_context *ctx, fz_gel *gel, int *list, int xofs, int h) { + fz_aa_context *ctxaa = ctx->aa; int winding = 0; int x = 0; int i; - fz_aa_context *ctxaa = gel->ctx->aa; for (i = 0; i < gel->alen; i++) { @@ -660,12 +661,13 @@ static inline void non_zero_winding_aa(fz_gel *gel, int *list, int xofs, int h) } } -static inline void even_odd_aa(fz_gel *gel, int *list, int xofs, int h) +static inline void +even_odd_aa(fz_context *ctx, fz_gel *gel, int *list, int xofs, int h) { + fz_aa_context *ctxaa = ctx->aa; int even = 0; int x = 0; int i; - fz_aa_context *ctxaa = gel->ctx->aa; for (i = 0; i < gel->alen; i++) { @@ -677,7 +679,8 @@ static inline void even_odd_aa(fz_gel *gel, int *list, int xofs, int h) } } -static inline void undelta_aa(fz_aa_context *ctxaa, unsigned char * restrict out, int * restrict in, int n) +static inline void +undelta_aa(fz_aa_context *ctxaa, unsigned char * restrict out, int * restrict in, int n) { int d = 0; while (n--) @@ -687,8 +690,8 @@ static inline void undelta_aa(fz_aa_context *ctxaa, unsigned char * restrict out } } -static inline void blit_aa(fz_pixmap *dst, int x, int y, - unsigned char *mp, int w, unsigned char *color) +static inline void +blit_aa(fz_pixmap *dst, int x, int y, unsigned char *mp, int w, unsigned char *color) { unsigned char *dp; dp = dst->samples + (unsigned int)(( (y - dst->y) * dst->w + (x - dst->x) ) * dst->n); @@ -699,15 +702,13 @@ static inline void blit_aa(fz_pixmap *dst, int x, int y, } static void -fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, - fz_pixmap *dst, unsigned char *color) +fz_scan_convert_aa(fz_context *ctx, fz_gel *gel, int eofill, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { + fz_aa_context *ctxaa = ctx->aa; unsigned char *alphas; int *deltas; int y, e; int yd, yc; - fz_context *ctx = gel->ctx; - fz_aa_context *ctxaa = ctx->aa; int height, h0, rh; int xmin = fz_idiv(gel->bbox.x0, fz_aa_hscale); @@ -761,7 +762,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, /* height = The number of subscanlines with identical edge * positions (i.e. 1 if we have any non vertical edges). */ - height = insert_active(gel, y, &e); + height = insert_active(ctx, gel, y, &e); h0 = height; if (h0 >= rh) { @@ -783,7 +784,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, h0 = 0; } height -= h0; - advance_active(gel, height); + advance_active(ctx, gel, height); y += height; } @@ -808,7 +809,7 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, /* height = The number of subscanlines with identical edge * positions (i.e. 1 if we have any non vertical edges). */ - height = insert_active(gel, y, &e); + height = insert_active(ctx, gel, y, &e); h0 = height; if (h0 > rh) { @@ -818,9 +819,9 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, * have more sub scanlines than will fit into * it. */ if (eofill) - even_odd_aa(gel, deltas, xofs, rh); + even_odd_aa(ctx, gel, deltas, xofs, rh); else - non_zero_winding_aa(gel, deltas, xofs, rh); + non_zero_winding_aa(ctx, gel, deltas, xofs, rh); undelta_aa(ctxaa, alphas, deltas, skipx + clipn); blit_aa(dst, xmin + skipx, yd, alphas + skipx, clipn, color); memset(deltas, 0, (skipx + clipn) * sizeof(int)); @@ -835,9 +836,9 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, * scanlines. */ h0 -= fz_aa_vscale; if (eofill) - even_odd_aa(gel, deltas, xofs, fz_aa_vscale); + even_odd_aa(ctx, gel, deltas, xofs, fz_aa_vscale); else - non_zero_winding_aa(gel, deltas, xofs, fz_aa_vscale); + non_zero_winding_aa(ctx, gel, deltas, xofs, fz_aa_vscale); undelta_aa(ctxaa, alphas, deltas, skipx + clipn); do { @@ -860,11 +861,11 @@ fz_scan_convert_aa(fz_gel *gel, int eofill, const fz_irect *clip, } } if (eofill) - even_odd_aa(gel, deltas, xofs, h0); + even_odd_aa(ctx, gel, deltas, xofs, h0); else - non_zero_winding_aa(gel, deltas, xofs, h0); + non_zero_winding_aa(ctx, gel, deltas, xofs, h0); advance: - advance_active(gel, height); + advance_active(ctx, gel, height); y += height; } @@ -883,8 +884,8 @@ clip_ended: * Sharp (not anti-aliased) scan conversion */ -static inline void blit_sharp(int x0, int x1, int y, - const fz_irect *clip, fz_pixmap *dst, unsigned char *color) +static inline void +blit_sharp(int x0, int x1, int y, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { unsigned char *dp; x0 = fz_clampi(x0, dst->x, dst->x + dst->w); @@ -899,8 +900,8 @@ static inline void blit_sharp(int x0, int x1, int y, } } -static inline void non_zero_winding_sharp(fz_gel *gel, int y, - const fz_irect *clip, fz_pixmap *dst, unsigned char *color) +static inline void +non_zero_winding_sharp(fz_context *ctx, fz_gel *gel, int y, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { int winding = 0; int x = 0; @@ -915,8 +916,8 @@ static inline void non_zero_winding_sharp(fz_gel *gel, int y, } } -static inline void even_odd_sharp(fz_gel *gel, int y, - const fz_irect *clip, fz_pixmap *dst, unsigned char *color) +static inline void +even_odd_sharp(fz_context *ctx, fz_gel *gel, int y, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { int even = 0; int x = 0; @@ -932,7 +933,8 @@ static inline void even_odd_sharp(fz_gel *gel, int y, } static void -fz_scan_convert_sharp(fz_gel *gel, int eofill, const fz_irect *clip, +fz_scan_convert_sharp(fz_context *ctx, + fz_gel *gel, int eofill, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { int e = 0; @@ -946,7 +948,7 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, const fz_irect *clip, { while (gel->alen > 0 || e < gel->len) { - height = insert_active(gel, y, &e); + height = insert_active(ctx, gel, y, &e); y += height; if (y >= clip->y0) { @@ -959,7 +961,7 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, const fz_irect *clip, /* Now process as lines within the clip region */ while (gel->alen > 0 || e < gel->len) { - height = insert_active(gel, y, &e); + height = insert_active(ctx, gel, y, &e); if (gel->alen == 0) y += height; @@ -973,31 +975,30 @@ fz_scan_convert_sharp(fz_gel *gel, int eofill, const fz_irect *clip, while (h--) { if (eofill) - even_odd_sharp(gel, y, clip, dst, color); + even_odd_sharp(ctx, gel, y, clip, dst, color); else - non_zero_winding_sharp(gel, y, clip, dst, color); + non_zero_winding_sharp(ctx, gel, y, clip, dst, color); y++; } } if (y >= clip->y1) break; - advance_active(gel, height); + advance_active(ctx, gel, height); } } void -fz_scan_convert(fz_gel *gel, int eofill, const fz_irect *clip, - fz_pixmap *dst, unsigned char *color) +fz_scan_convert(fz_context *ctx, fz_gel *gel, int eofill, const fz_irect *clip, fz_pixmap *dst, unsigned char *color) { - fz_aa_context *ctxaa = gel->ctx->aa; + fz_aa_context *ctxaa = ctx->aa; fz_irect local_clip; if (fz_is_empty_irect(fz_intersect_irect(fz_pixmap_bbox_no_ctx(dst, &local_clip), clip))) return; if (fz_aa_bits > 0) - fz_scan_convert_aa(gel, eofill, &local_clip, dst, color); + fz_scan_convert_aa(ctx, gel, eofill, &local_clip, dst, color); else - fz_scan_convert_sharp(gel, eofill, &local_clip, dst, color); + fz_scan_convert_sharp(ctx, gel, eofill, &local_clip, dst, color); } diff --git a/source/fitz/draw-glyph.c b/source/fitz/draw-glyph.c index bb2de291..e7f8af30 100644 --- a/source/fitz/draw-glyph.c +++ b/source/fitz/draw-glyph.c @@ -131,7 +131,7 @@ fz_keep_glyph_cache(fz_context *ctx) } float -fz_subpixel_adjust(fz_matrix *ctm, fz_matrix *subpix_ctm, unsigned char *qe, unsigned char *qf) +fz_subpixel_adjust(fz_context *ctx, fz_matrix *ctm, fz_matrix *subpix_ctm, unsigned char *qe, unsigned char *qf) { float size = fz_matrix_expansion(ctm); int q; @@ -182,7 +182,7 @@ fz_render_stroked_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm, if (stroke->dash_len > 0) return NULL; - (void)fz_subpixel_adjust(trm, &subpix_trm, &qe, &qf); + (void)fz_subpixel_adjust(ctx, trm, &subpix_trm, &qe, &qf); return fz_render_ft_stroked_glyph(ctx, font, gid, &subpix_trm, ctm, stroke); } return fz_render_glyph(ctx, font, gid, trm, NULL, scissor); @@ -198,7 +198,7 @@ fz_render_stroked_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, fz_matri if (stroke->dash_len > 0) return NULL; - (void)fz_subpixel_adjust(trm, &subpix_trm, &qe, &qf); + (void)fz_subpixel_adjust(ctx, trm, &subpix_trm, &qe, &qf); return fz_render_ft_stroked_glyph_pixmap(ctx, font, gid, &subpix_trm, ctm, stroke); } return fz_render_glyph_pixmap(ctx, font, gid, trm, NULL, scissor); @@ -258,7 +258,7 @@ fz_render_glyph(fz_context *ctx, fz_font *font, int gid, fz_matrix *ctm, fz_colo fz_var(val); memset(&key, 0, sizeof key); - size = fz_subpixel_adjust(ctm, &subpix_ctm, &key.e, &key.f); + size = fz_subpixel_adjust(ctx, ctm, &subpix_ctm, &key.e, &key.f); if (size <= MAX_GLYPH_SIZE) { scissor = &fz_infinite_irect; @@ -412,7 +412,7 @@ fz_render_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, fz_matrix *ctm, fz_pixmap *val; unsigned char qe, qf; fz_matrix subpix_ctm; - float size = fz_subpixel_adjust(ctm, &subpix_ctm, &qe, &qf); + float size = fz_subpixel_adjust(ctx, ctm, &subpix_ctm, &qe, &qf); if (size <= MAX_GLYPH_SIZE) { diff --git a/source/fitz/draw-imp.h b/source/fitz/draw-imp.h index b5f4690d..ed457d34 100644 --- a/source/fitz/draw-imp.h +++ b/source/fitz/draw-imp.h @@ -8,19 +8,19 @@ typedef struct fz_gel_s fz_gel; fz_gel *fz_new_gel(fz_context *ctx); -void fz_insert_gel(fz_gel *gel, float x0, float y0, float x1, float y1); -void fz_reset_gel(fz_gel *gel, const fz_irect *clip); -void fz_sort_gel(fz_gel *gel); -fz_irect *fz_bound_gel(const fz_gel *gel, fz_irect *bbox); -void fz_drop_gel(fz_gel *gel); -int fz_is_rect_gel(fz_gel *gel); -fz_rect *fz_gel_scissor(const fz_gel *gel, fz_rect *rect); - -void fz_scan_convert(fz_gel *gel, int eofill, const fz_irect *clip, fz_pixmap *pix, unsigned char *colorbv); - -void fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness); -void fz_flatten_stroke_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth); -void fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth); +void fz_insert_gel(fz_context *ctx, fz_gel *gel, float x0, float y0, float x1, float y1); +void fz_reset_gel(fz_context *ctx, fz_gel *gel, const fz_irect *clip); +void fz_sort_gel(fz_context *ctx, fz_gel *gel); +fz_irect *fz_bound_gel(fz_context *ctx, const fz_gel *gel, fz_irect *bbox); +void fz_drop_gel(fz_context *ctx, fz_gel *gel); +int fz_is_rect_gel(fz_context *ctx, fz_gel *gel); +fz_rect *fz_gel_scissor(fz_context *ctx, const fz_gel *gel, fz_rect *rect); + +void fz_scan_convert(fz_context *ctx, fz_gel *gel, int eofill, const fz_irect *clip, fz_pixmap *pix, unsigned char *colorbv); + +void fz_flatten_fill_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness); +void fz_flatten_stroke_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth); +void fz_flatten_dash_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth); fz_irect *fz_bound_path_accurate(fz_context *ctx, fz_irect *bbox, const fz_irect *scissor, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth); diff --git a/source/fitz/draw-mesh.c b/source/fitz/draw-mesh.c index 8b0d80a3..03cffd06 100644 --- a/source/fitz/draw-mesh.c +++ b/source/fitz/draw-mesh.c @@ -157,7 +157,6 @@ fz_paint_triangle(fz_pixmap *pix, float *v[3], int n, const fz_irect *bbox) struct paint_tri_data { - fz_context *ctx; fz_shade *shade; fz_pixmap *dest; const fz_irect *bbox; @@ -165,7 +164,7 @@ struct paint_tri_data }; static void -prepare_vertex(void *arg, fz_vertex *v, const float *input) +prepare_vertex(fz_context *ctx, void *arg, fz_vertex *v, const float *input) { struct paint_tri_data *ptd = (struct paint_tri_data *)arg; fz_shade *shade = ptd->shade; @@ -177,14 +176,14 @@ prepare_vertex(void *arg, fz_vertex *v, const float *input) output[0] = input[0] * 255; else { - ptd->cc.convert(&ptd->cc, output, input); + ptd->cc.convert(ctx, &ptd->cc, output, input); for (i = 0; i < dest->colorspace->n; i++) output[i] *= 255; } } static void -do_paint_tri(void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex *cv) +do_paint_tri(fz_context *ctx, void *arg, fz_vertex *av, fz_vertex *bv, fz_vertex *cv) { struct paint_tri_data *ptd = (struct paint_tri_data *)arg; float *vertices[3]; @@ -219,10 +218,10 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_pixmap if (shade->use_function) { fz_color_converter cc; - fz_lookup_color_converter(&cc, ctx, dest->colorspace, shade->colorspace); + fz_lookup_color_converter(ctx, &cc, dest->colorspace, shade->colorspace); for (i = 0; i < 256; i++) { - cc.convert(&cc, color, shade->function[i]); + cc.convert(ctx, &cc, color, shade->function[i]); for (k = 0; k < dest->colorspace->n; k++) clut[i][k] = color[k] * 255; clut[i][k] = shade->function[i][shade->colorspace->n] * 255; @@ -236,7 +235,6 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_pixmap temp = dest; } - ptd.ctx = ctx; ptd.dest = temp; ptd.shade = shade; ptd.bbox = bbox; @@ -264,7 +262,7 @@ fz_paint_shade(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz_pixmap } fz_always(ctx) { - fz_fin_cached_color_converter(&ptd.cc); + fz_fin_cached_color_converter(ctx, &ptd.cc); } fz_catch(ctx) { diff --git a/source/fitz/draw-path.c b/source/fitz/draw-path.c index d184fad2..8ad0b334 100644 --- a/source/fitz/draw-path.c +++ b/source/fitz/draw-path.c @@ -4,17 +4,17 @@ #define MAX_DEPTH 8 static void -line(fz_gel *gel, const fz_matrix *ctm, float x0, float y0, float x1, float y1) +line(fz_context *ctx, fz_gel *gel, const fz_matrix *ctm, float x0, float y0, float x1, float y1) { float tx0 = ctm->a * x0 + ctm->c * y0 + ctm->e; float ty0 = ctm->b * x0 + ctm->d * y0 + ctm->f; float tx1 = ctm->a * x1 + ctm->c * y1 + ctm->e; float ty1 = ctm->b * x1 + ctm->d * y1 + ctm->f; - fz_insert_gel(gel, tx0, ty0, tx1, ty1); + fz_insert_gel(ctx, gel, tx0, ty0, tx1, ty1); } static void -bezier(fz_gel *gel, const fz_matrix *ctm, float flatness, +bezier(fz_context *ctx, fz_gel *gel, const fz_matrix *ctm, float flatness, float xa, float ya, float xb, float yb, float xc, float yc, @@ -35,7 +35,7 @@ bezier(fz_gel *gel, const fz_matrix *ctm, float flatness, dmax = fz_max(dmax, fz_abs(yd - yc)); if (dmax < flatness || depth >= MAX_DEPTH) { - line(gel, ctm, xa, ya, xd, yd); + line(ctx, gel, ctm, xa, ya, xd, yd); return; } @@ -63,12 +63,12 @@ bezier(fz_gel *gel, const fz_matrix *ctm, float flatness, xabcd *= 0.125f; yabcd *= 0.125f; - bezier(gel, ctm, flatness, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1); - bezier(gel, ctm, flatness, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1); + bezier(ctx, gel, ctm, flatness, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1); + bezier(ctx, gel, ctm, flatness, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1); } void -fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness) +fz_flatten_fill_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_matrix *ctm, float flatness) { float x1, y1, x2, y2, x3, y3; float cx = 0; @@ -84,7 +84,7 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float fla case FZ_MOVETO: /* implicit closepath before moveto */ if (cx != bx || cy != by) - line(gel, ctm, cx, cy, bx, by); + line(ctx, gel, ctm, cx, cy, bx, by); x1 = path->coords[k++]; y1 = path->coords[k++]; cx = bx = x1; @@ -94,7 +94,7 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float fla case FZ_LINETO: x1 = path->coords[k++]; y1 = path->coords[k++]; - line(gel, ctm, cx, cy, x1, y1); + line(ctx, gel, ctm, cx, cy, x1, y1); cx = x1; cy = y1; break; @@ -106,13 +106,13 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float fla y2 = path->coords[k++]; x3 = path->coords[k++]; y3 = path->coords[k++]; - bezier(gel, ctm, flatness, cx, cy, x1, y1, x2, y2, x3, y3, 0); + bezier(ctx, gel, ctm, flatness, cx, cy, x1, y1, x2, y2, x3, y3, 0); cx = x3; cy = y3; break; case FZ_CLOSE_PATH: - line(gel, ctm, cx, cy, bx, by); + line(ctx, gel, ctm, cx, cy, bx, by); cx = bx; cy = by; break; @@ -120,7 +120,7 @@ fz_flatten_fill_path(fz_gel *gel, fz_path *path, const fz_matrix *ctm, float fla } if (cx != bx || cy != by) - line(gel, ctm, cx, cy, bx, by); + line(ctx, gel, ctm, cx, cy, bx, by); } struct sctx @@ -150,17 +150,17 @@ struct sctx }; static void -fz_add_line(struct sctx *s, float x0, float y0, float x1, float y1) +fz_add_line(fz_context *ctx, struct sctx *s, float x0, float y0, float x1, float y1) { float tx0 = s->ctm->a * x0 + s->ctm->c * y0 + s->ctm->e; float ty0 = s->ctm->b * x0 + s->ctm->d * y0 + s->ctm->f; float tx1 = s->ctm->a * x1 + s->ctm->c * y1 + s->ctm->e; float ty1 = s->ctm->b * x1 + s->ctm->d * y1 + s->ctm->f; - fz_insert_gel(s->gel, tx0, ty0, tx1, ty1); + fz_insert_gel(ctx, s->gel, tx0, ty0, tx1, ty1); } static void -fz_add_arc(struct sctx *s, +fz_add_arc(fz_context *ctx, struct sctx *s, float xc, float yc, float x0, float y0, float x1, float y1) @@ -195,28 +195,28 @@ fz_add_arc(struct sctx *s, theta = th0 + (th1 - th0) * i / n; nx = cosf(theta) * r; ny = sinf(theta) * r; - fz_add_line(s, xc + ox, yc + oy, xc + nx, yc + ny); + fz_add_line(ctx, s, xc + ox, yc + oy, xc + nx, yc + ny); ox = nx; oy = ny; } - fz_add_line(s, xc + ox, yc + oy, xc + x1, yc + y1); + fz_add_line(ctx, s, xc + ox, yc + oy, xc + x1, yc + y1); } static void -fz_add_line_stroke(struct sctx *s, fz_point a, fz_point b) +fz_add_line_stroke(fz_context *ctx, struct sctx *s, fz_point a, fz_point b) { float dx = b.x - a.x; float dy = b.y - a.y; float scale = s->linewidth / sqrtf(dx * dx + dy * dy); float dlx = dy * scale; float dly = -dx * scale; - fz_add_line(s, a.x - dlx, a.y - dly, b.x - dlx, b.y - dly); - fz_add_line(s, b.x + dlx, b.y + dly, a.x + dlx, a.y + dly); + fz_add_line(ctx, s, a.x - dlx, a.y - dly, b.x - dlx, b.y - dly); + fz_add_line(ctx, s, b.x + dlx, b.y + dly, a.x + dlx, a.y + dly); } static void -fz_add_line_join(struct sctx *s, fz_point a, fz_point b, fz_point c, int join_under) +fz_add_line_join(fz_context *ctx, struct sctx *s, fz_point a, fz_point b, fz_point c, int join_under) { float miterlimit = s->miterlimit; float linewidth = s->linewidth; @@ -284,12 +284,12 @@ fz_add_line_join(struct sctx *s, fz_point a, fz_point b, fz_point c, int join_un if (join_under) { - fz_add_line(s, b.x + dlx1, b.y + dly1, b.x + dlx0, b.y + dly0); + fz_add_line(ctx, s, b.x + dlx1, b.y + dly1, b.x + dlx0, b.y + dly0); } else { - fz_add_line(s, b.x + dlx1, b.y + dly1, b.x, b.y); - fz_add_line(s, b.x, b.y, b.x + dlx0, b.y + dly0); + fz_add_line(ctx, s, b.x + dlx1, b.y + dly1, b.x, b.y); + fz_add_line(ctx, s, b.x, b.y, b.x + dlx0, b.y + dly0); } /* XPS miter joins are clipped at miterlength, rather than simply @@ -312,9 +312,9 @@ fz_add_line_join(struct sctx *s, fz_point a, fz_point b, fz_point c, int join_un t1x = b.x - dmx + k * (dmx - dlx1); t1y = b.y - dmy + k * (dmy - dly1); - fz_add_line(s, b.x - dlx0, b.y - dly0, t0x, t0y); - fz_add_line(s, t0x, t0y, t1x, t1y); - fz_add_line(s, t1x, t1y, b.x - dlx1, b.y - dly1); + fz_add_line(ctx, s, b.x - dlx0, b.y - dly0, t0x, t0y); + fz_add_line(ctx, s, t0x, t0y, t1x, t1y); + fz_add_line(ctx, s, t1x, t1y, b.x - dlx1, b.y - dly1); } } else if (linejoin == FZ_LINEJOIN_MITER) @@ -327,23 +327,23 @@ fz_add_line_join(struct sctx *s, fz_point a, fz_point b, fz_point c, int join_un dmx *= scale; dmy *= scale; - fz_add_line(s, b.x - dlx0, b.y - dly0, b.x - dmx, b.y - dmy); - fz_add_line(s, b.x - dmx, b.y - dmy, b.x - dlx1, b.y - dly1); + fz_add_line(ctx, s, b.x - dlx0, b.y - dly0, b.x - dmx, b.y - dmy); + fz_add_line(ctx, s, b.x - dmx, b.y - dmy, b.x - dlx1, b.y - dly1); } if (linejoin == FZ_LINEJOIN_BEVEL) { - fz_add_line(s, b.x - dlx0, b.y - dly0, b.x - dlx1, b.y - dly1); + fz_add_line(ctx, s, b.x - dlx0, b.y - dly0, b.x - dlx1, b.y - dly1); } if (linejoin == FZ_LINEJOIN_ROUND) { - fz_add_arc(s, b.x, b.y, -dlx0, -dly0, -dlx1, -dly1); + fz_add_arc(ctx, s, b.x, b.y, -dlx0, -dly0, -dlx1, -dly1); } } static void -fz_add_line_cap(struct sctx *s, fz_point a, fz_point b, fz_linecap linecap) +fz_add_line_cap(fz_context *ctx, struct sctx *s, fz_point a, fz_point b, fz_linecap linecap) { float flatness = s->flatness; float linewidth = s->linewidth; @@ -356,7 +356,7 @@ fz_add_line_cap(struct sctx *s, fz_point a, fz_point b, fz_linecap linecap) float dly = -dx * scale; if (linecap == FZ_LINECAP_BUTT) - fz_add_line(s, b.x - dlx, b.y - dly, b.x + dlx, b.y + dly); + fz_add_line(ctx, s, b.x - dlx, b.y - dly, b.x + dlx, b.y + dly); if (linecap == FZ_LINECAP_ROUND) { @@ -371,20 +371,20 @@ fz_add_line_cap(struct sctx *s, fz_point a, fz_point b, fz_linecap linecap) float sth = sinf(theta); float nx = b.x - dlx * cth - dly * sth; float ny = b.y - dly * cth + dlx * sth; - fz_add_line(s, ox, oy, nx, ny); + fz_add_line(ctx, s, ox, oy, nx, ny); ox = nx; oy = ny; } - fz_add_line(s, ox, oy, b.x + dlx, b.y + dly); + fz_add_line(ctx, s, ox, oy, b.x + dlx, b.y + dly); } if (linecap == FZ_LINECAP_SQUARE) { - fz_add_line(s, b.x - dlx, b.y - dly, + fz_add_line(ctx, s, b.x - dlx, b.y - dly, b.x - dlx - dly, b.y - dly + dlx); - fz_add_line(s, b.x - dlx - dly, b.y - dly + dlx, + fz_add_line(ctx, s, b.x - dlx - dly, b.y - dly + dlx, b.x + dlx - dly, b.y + dly + dlx); - fz_add_line(s, b.x + dlx - dly, b.y + dly + dlx, + fz_add_line(ctx, s, b.x + dlx - dly, b.y + dly + dlx, b.x + dlx, b.y + dly); } @@ -392,13 +392,13 @@ fz_add_line_cap(struct sctx *s, fz_point a, fz_point b, fz_linecap linecap) { float mx = -dly; float my = dlx; - fz_add_line(s, b.x - dlx, b.y - dly, b.x + mx, b.y + my); - fz_add_line(s, b.x + mx, b.y + my, b.x + dlx, b.y + dly); + fz_add_line(ctx, s, b.x - dlx, b.y - dly, b.x + mx, b.y + my); + fz_add_line(ctx, s, b.x + mx, b.y + my, b.x + dlx, b.y + dly); } } static void -fz_add_line_dot(struct sctx *s, fz_point a) +fz_add_line_dot(fz_context *ctx, struct sctx *s, fz_point a) { float flatness = s->flatness; float linewidth = s->linewidth; @@ -414,30 +414,30 @@ fz_add_line_dot(struct sctx *s, fz_point a) float sth = sinf(theta); float nx = a.x - cth * linewidth; float ny = a.y + sth * linewidth; - fz_add_line(s, ox, oy, nx, ny); + fz_add_line(ctx, s, ox, oy, nx, ny); ox = nx; oy = ny; } - fz_add_line(s, ox, oy, a.x - linewidth, a.y); + fz_add_line(ctx, s, ox, oy, a.x - linewidth, a.y); } static void -fz_stroke_flush(struct sctx *s, fz_linecap start_cap, fz_linecap end_cap) +fz_stroke_flush(fz_context *ctx, struct sctx *s, fz_linecap start_cap, fz_linecap end_cap) { if (s->sn == 2) { - fz_add_line_cap(s, s->beg[1], s->beg[0], start_cap); - fz_add_line_cap(s, s->seg[0], s->seg[1], end_cap); + fz_add_line_cap(ctx, s, s->beg[1], s->beg[0], start_cap); + fz_add_line_cap(ctx, s, s->seg[0], s->seg[1], end_cap); } else if (s->dot) { - fz_add_line_dot(s, s->beg[0]); + fz_add_line_dot(ctx, s, s->beg[0]); } } static void -fz_stroke_moveto(struct sctx *s, fz_point cur) +fz_stroke_moveto(fz_context *ctx, struct sctx *s, fz_point cur) { s->seg[0] = cur; s->beg[0] = cur; @@ -447,7 +447,7 @@ fz_stroke_moveto(struct sctx *s, fz_point cur) } static void -fz_stroke_lineto(struct sctx *s, fz_point cur, int from_bezier) +fz_stroke_lineto(fz_context *ctx, struct sctx *s, fz_point cur, int from_bezier) { float dx = cur.x - s->seg[s->sn-1].x; float dy = cur.y - s->seg[s->sn-1].y; @@ -459,11 +459,11 @@ fz_stroke_lineto(struct sctx *s, fz_point cur, int from_bezier) return; } - fz_add_line_stroke(s, s->seg[s->sn-1], cur); + fz_add_line_stroke(ctx, s, s->seg[s->sn-1], cur); if (s->sn == 2) { - fz_add_line_join(s, s->seg[0], s->seg[1], cur, s->from_bezier & from_bezier); + fz_add_line_join(ctx, s, s->seg[0], s->seg[1], cur, s->from_bezier & from_bezier); s->seg[0] = s->seg[1]; s->seg[1] = cur; } @@ -477,19 +477,19 @@ fz_stroke_lineto(struct sctx *s, fz_point cur, int from_bezier) } static void -fz_stroke_closepath(struct sctx *s) +fz_stroke_closepath(fz_context *ctx, struct sctx *s) { if (s->sn == 2) { - fz_stroke_lineto(s, s->beg[0], 0); + fz_stroke_lineto(ctx, s, s->beg[0], 0); if (s->seg[1].x == s->beg[0].x && s->seg[1].y == s->beg[0].y) - fz_add_line_join(s, s->seg[0], s->beg[0], s->beg[1], 0); + fz_add_line_join(ctx, s, s->seg[0], s->beg[0], s->beg[1], 0); else - fz_add_line_join(s, s->seg[1], s->beg[0], s->beg[1], 0); + fz_add_line_join(ctx, s, s->seg[1], s->beg[0], s->beg[1], 0); } else if (s->dot) { - fz_add_line_dot(s, s->beg[0]); + fz_add_line_dot(ctx, s, s->beg[0]); } s->seg[0] = s->beg[0]; @@ -499,7 +499,7 @@ fz_stroke_closepath(struct sctx *s) } static void -fz_stroke_bezier(struct sctx *s, +fz_stroke_bezier(fz_context *ctx, struct sctx *s, float xa, float ya, float xb, float yb, float xc, float yc, @@ -523,7 +523,7 @@ fz_stroke_bezier(struct sctx *s, fz_point p; p.x = xd; p.y = yd; - fz_stroke_lineto(s, p, 1); + fz_stroke_lineto(ctx, s, p, 1); return; } @@ -551,12 +551,12 @@ fz_stroke_bezier(struct sctx *s, xabcd *= 0.125f; yabcd *= 0.125f; - fz_stroke_bezier(s, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1); - fz_stroke_bezier(s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1); + fz_stroke_bezier(ctx, s, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1); + fz_stroke_bezier(ctx, s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1); } void -fz_flatten_stroke_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth) +fz_flatten_stroke_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth) { struct sctx s; fz_point p0, p1, p2, p3; @@ -594,15 +594,15 @@ fz_flatten_stroke_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke case FZ_MOVETO: p1.x = path->coords[k++]; p1.y = path->coords[k++]; - fz_stroke_flush(&s, stroke->start_cap, stroke->end_cap); - fz_stroke_moveto(&s, p1); + fz_stroke_flush(ctx, &s, stroke->start_cap, stroke->end_cap); + fz_stroke_moveto(ctx, &s, p1); p0 = p1; break; case FZ_LINETO: p1.x = path->coords[k++]; p1.y = path->coords[k++]; - fz_stroke_lineto(&s, p1, 0); + fz_stroke_lineto(ctx, &s, p1, 0); p0 = p1; break; @@ -613,21 +613,21 @@ fz_flatten_stroke_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke p2.y = path->coords[k++]; p3.x = path->coords[k++]; p3.y = path->coords[k++]; - fz_stroke_bezier(&s, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, 0); + fz_stroke_bezier(ctx, &s, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, 0); p0 = p3; break; case FZ_CLOSE_PATH: - fz_stroke_closepath(&s); + fz_stroke_closepath(ctx, &s); break; } } - fz_stroke_flush(&s, stroke->start_cap, stroke->end_cap); + fz_stroke_flush(ctx, &s, stroke->start_cap, stroke->end_cap); } static void -fz_dash_moveto(struct sctx *s, fz_point a, fz_linecap start_cap, fz_linecap end_cap) +fz_dash_moveto(fz_context *ctx, struct sctx *s, fz_point a, fz_linecap start_cap, fz_linecap end_cap) { s->toggle = 1; s->offset = 0; @@ -646,14 +646,14 @@ fz_dash_moveto(struct sctx *s, fz_point a, fz_linecap start_cap, fz_linecap end_ if (s->toggle) { - fz_stroke_flush(s, s->cap, end_cap); + fz_stroke_flush(ctx, s, s->cap, end_cap); s->cap = start_cap; - fz_stroke_moveto(s, a); + fz_stroke_moveto(ctx, s, a); } } static void -fz_dash_lineto(struct sctx *s, fz_point b, int dash_cap, int from_bezier) +fz_dash_lineto(fz_context *ctx, struct sctx *s, fz_point b, int dash_cap, int from_bezier) { float dx, dy, d; float total, used, ratio, tail; @@ -736,13 +736,13 @@ a_moved_vertically: /* d and dy have the same sign */ /* Update the position in the dash array */ if (s->toggle) { - fz_stroke_lineto(s, a, from_bezier); + fz_stroke_lineto(ctx, s, a, from_bezier); } else { - fz_stroke_flush(s, s->cap, dash_cap); + fz_stroke_flush(ctx, s, s->cap, dash_cap); s->cap = dash_cap; - fz_stroke_moveto(s, a); + fz_stroke_moveto(ctx, s, a); } used += s->phase; n = used/s->dash_total; @@ -759,13 +759,13 @@ a_moved_vertically: /* d and dy have the same sign */ } if (s->toggle) { - fz_stroke_lineto(s, a, from_bezier); + fz_stroke_lineto(ctx, s, a, from_bezier); } else { - fz_stroke_flush(s, s->cap, dash_cap); + fz_stroke_flush(ctx, s, s->cap, dash_cap); s->cap = dash_cap; - fz_stroke_moveto(s, a); + fz_stroke_moveto(ctx, s, a); } s->phase = used; used = 0; @@ -819,13 +819,13 @@ b_moved_vertically: /* d and dy have the same sign */ if (s->toggle) { - fz_stroke_lineto(s, m, from_bezier); + fz_stroke_lineto(ctx, s, m, from_bezier); } else { - fz_stroke_flush(s, s->cap, dash_cap); + fz_stroke_flush(ctx, s, s->cap, dash_cap); s->cap = dash_cap; - fz_stroke_moveto(s, m); + fz_stroke_moveto(ctx, s, m); } s->toggle = !s->toggle; @@ -843,7 +843,7 @@ b_moved_vertically: /* d and dy have the same sign */ if (s->toggle) { - fz_stroke_lineto(s, b, from_bezier); + fz_stroke_lineto(ctx, s, b, from_bezier); } } else @@ -853,13 +853,13 @@ adjust_for_tail: /* Update the position in the dash array */ if (s->toggle) { - fz_stroke_lineto(s, old_b, from_bezier); + fz_stroke_lineto(ctx, s, old_b, from_bezier); } else { - fz_stroke_flush(s, s->cap, dash_cap); + fz_stroke_flush(ctx, s, s->cap, dash_cap); s->cap = dash_cap; - fz_stroke_moveto(s, old_b); + fz_stroke_moveto(ctx, s, old_b); } tail += s->phase; n = tail/s->dash_total; @@ -876,20 +876,20 @@ adjust_for_tail: } if (s->toggle) { - fz_stroke_lineto(s, old_b, from_bezier); + fz_stroke_lineto(ctx, s, old_b, from_bezier); } else { - fz_stroke_flush(s, s->cap, dash_cap); + fz_stroke_flush(ctx, s, s->cap, dash_cap); s->cap = dash_cap; - fz_stroke_moveto(s, old_b); + fz_stroke_moveto(ctx, s, old_b); } s->phase = tail; } } static void -fz_dash_bezier(struct sctx *s, +fz_dash_bezier(fz_context *ctx, struct sctx *s, float xa, float ya, float xb, float yb, float xc, float yc, @@ -914,7 +914,7 @@ fz_dash_bezier(struct sctx *s, fz_point p; p.x = xd; p.y = yd; - fz_dash_lineto(s, p, dash_cap, 1); + fz_dash_lineto(ctx, s, p, dash_cap, 1); return; } @@ -942,12 +942,12 @@ fz_dash_bezier(struct sctx *s, xabcd *= 0.125f; yabcd *= 0.125f; - fz_dash_bezier(s, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1, dash_cap); - fz_dash_bezier(s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1, dash_cap); + fz_dash_bezier(ctx, s, xa, ya, xab, yab, xabc, yabc, xabcd, yabcd, depth + 1, dash_cap); + fz_dash_bezier(ctx, s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd, depth + 1, dash_cap); } void -fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth) +fz_flatten_dash_path(fz_context *ctx, fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, const fz_matrix *ctm, float flatness, float linewidth) { struct sctx s; fz_point p0, p1, p2, p3, beg; @@ -982,7 +982,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, phase_len += stroke->dash_list[i]; if (stroke->dash_len > 0 && phase_len == 0) return; - fz_gel_scissor(gel, &s.rect); + fz_gel_scissor(ctx, gel, &s.rect); if (fz_try_invert_matrix(&inv, ctm)) return; fz_transform_rect(&s.rect, &inv); @@ -994,7 +994,7 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, max_expand = fz_matrix_max_expansion(ctm); if (phase_len < 0.01f || phase_len * max_expand < 0.5f) { - fz_flatten_stroke_path(gel, path, stroke, ctm, flatness, linewidth); + fz_flatten_stroke_path(ctx, gel, path, stroke, ctm, flatness, linewidth); return; } s.dash_total = phase_len; @@ -1009,14 +1009,14 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, case FZ_MOVETO: p1.x = path->coords[k++]; p1.y = path->coords[k++]; - fz_dash_moveto(&s, p1, stroke->start_cap, stroke->end_cap); + fz_dash_moveto(ctx, &s, p1, stroke->start_cap, stroke->end_cap); beg = p0 = p1; break; case FZ_LINETO: p1.x = path->coords[k++]; p1.y = path->coords[k++]; - fz_dash_lineto(&s, p1, stroke->dash_cap, 0); + fz_dash_lineto(ctx, &s, p1, stroke->dash_cap, 0); p0 = p1; break; @@ -1027,16 +1027,16 @@ fz_flatten_dash_path(fz_gel *gel, fz_path *path, const fz_stroke_state *stroke, p2.y = path->coords[k++]; p3.x = path->coords[k++]; p3.y = path->coords[k++]; - fz_dash_bezier(&s, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, 0, stroke->dash_cap); + fz_dash_bezier(ctx, &s, p0.x, p0.y, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, 0, stroke->dash_cap); p0 = p3; break; case FZ_CLOSE_PATH: - fz_dash_lineto(&s, beg, stroke->dash_cap, 0); + fz_dash_lineto(ctx, &s, beg, stroke->dash_cap, 0); p0 = p1 = beg; break; } } - fz_stroke_flush(&s, s.cap, stroke->end_cap); + fz_stroke_flush(ctx, &s, s.cap, stroke->end_cap); } diff --git a/source/fitz/draw-unpack.c b/source/fitz/draw-unpack.c index d862ea2a..806fe448 100644 --- a/source/fitz/draw-unpack.c +++ b/source/fitz/draw-unpack.c @@ -47,7 +47,7 @@ init_get1_tables(void) } void -fz_unpack_tile(fz_pixmap *dst, unsigned char * restrict src, int n, int depth, int stride, int scale) +fz_unpack_tile(fz_context *ctx, fz_pixmap *dst, unsigned char * restrict src, int n, int depth, int stride, int scale) { int pad, x, y, k; int w = dst->w; @@ -172,7 +172,7 @@ fz_unpack_tile(fz_pixmap *dst, unsigned char * restrict src, int n, int depth, i /* Apply decode array */ void -fz_decode_indexed_tile(fz_pixmap *pix, float *decode, int maxval) +fz_decode_indexed_tile(fz_context *ctx, fz_pixmap *pix, float *decode, int maxval) { int add[FZ_MAX_COLORS]; int mul[FZ_MAX_COLORS]; @@ -207,7 +207,7 @@ fz_decode_indexed_tile(fz_pixmap *pix, float *decode, int maxval) } void -fz_decode_tile(fz_pixmap *pix, float *decode) +fz_decode_tile(fz_context *ctx, fz_pixmap *pix, float *decode) { int add[FZ_MAX_COLORS]; int mul[FZ_MAX_COLORS]; diff --git a/source/fitz/filter-basic.c b/source/fitz/filter-basic.c index 1b4eaefb..eb9e838e 100644 --- a/source/fitz/filter-basic.c +++ b/source/fitz/filter-basic.c @@ -3,9 +3,9 @@ /* Pretend we have a filter that just copies data forever */ fz_stream * -fz_open_copy(fz_stream *chain) +fz_open_copy(fz_context *ctx, fz_stream *chain) { - return fz_keep_stream(chain); + return fz_keep_stream(ctx, chain); } /* Null filter copies a specified amount of data */ @@ -19,15 +19,15 @@ struct null_filter }; static int -next_null(fz_stream *stm, int max) +next_null(fz_context *ctx, fz_stream *stm, int max) { struct null_filter *state = stm->state; int n; if (state->remain == 0) return EOF; - fz_seek(state->chain, state->offset, 0); - n = fz_available(state->chain, max); + fz_seek(ctx, state->chain, state->offset, 0); + n = fz_available(ctx, state->chain, max); if (n > state->remain) n = state->remain; if (n > sizeof(state->buffer)) @@ -50,21 +50,13 @@ close_null(fz_context *ctx, void *state_) struct null_filter *state = (struct null_filter *)state_; fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_null(fz_stream *s) -{ - struct null_filter *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_null(fz_stream *chain, int len, int offset) +fz_open_null(fz_context *ctx, fz_stream *chain, int len, int offset) { struct null_filter *state; - fz_context *ctx = chain->ctx; if (len < 0) len = 0; @@ -77,11 +69,11 @@ fz_open_null(fz_stream *chain, int len, int offset) } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_null, close_null, rebind_null); + return fz_new_stream(ctx, state, next_null, close_null); } /* Concat filter concatenates several streams into one */ @@ -97,7 +89,7 @@ struct concat_filter }; static int -next_concat(fz_stream *stm, int max) +next_concat(fz_context *ctx, fz_stream *stm, int max) { struct concat_filter *state = (struct concat_filter *)stm->state; int n; @@ -107,7 +99,7 @@ next_concat(fz_stream *stm, int max) /* Read the next block of underlying data. */ if (stm->wp == state->chain[state->current]->wp) state->chain[state->current]->rp = stm->wp; - n = fz_available(state->chain[state->current], max); + n = fz_available(ctx, state->chain[state->current], max); if (n) { stm->rp = state->chain[state->current]->rp; @@ -123,7 +115,7 @@ next_concat(fz_stream *stm, int max) break; } state->current++; - fz_drop_stream(state->chain[state->current-1]); + fz_drop_stream(ctx, state->chain[state->current-1]); if (state->pad) { stm->rp = (&state->ws_buf)+1; @@ -147,26 +139,11 @@ close_concat(fz_context *ctx, void *state_) for (i = state->current; i < state->count; i++) { - fz_drop_stream(state->chain[i]); + fz_drop_stream(ctx, state->chain[i]); } fz_free(ctx, state); } -static fz_stream * -rebind_concat(fz_stream *s) -{ - struct concat_filter *state = s->state; - int i; - - if (state->current >= state->count) - return NULL; - for (i = state->current; i < state->count-1; i++) - { - fz_rebind_stream(state->chain[i], s->ctx); - } - return state->chain[i]; -} - fz_stream * fz_open_concat(fz_context *ctx, int len, int pad) { @@ -179,16 +156,16 @@ fz_open_concat(fz_context *ctx, int len, int pad) state->pad = pad; state->ws_buf = 32; - return fz_new_stream(ctx, state, next_concat, close_concat, rebind_concat); + return fz_new_stream(ctx, state, next_concat, close_concat); } void -fz_concat_push(fz_stream *concat, fz_stream *chain) +fz_concat_push(fz_context *ctx, fz_stream *concat, fz_stream *chain) { struct concat_filter *state = (struct concat_filter *)concat->state; if (state->count == state->max) - fz_throw(concat->ctx, FZ_ERROR_GENERIC, "Concat filter size exceeded"); + fz_throw(ctx, FZ_ERROR_GENERIC, "Concat filter size exceeded"); state->chain[state->count++] = chain; } @@ -230,7 +207,7 @@ static inline int unhex(int a) } static int -next_ahxd(fz_stream *stm, int max) +next_ahxd(fz_context *ctx, fz_stream *stm, int max) { fz_ahxd *state = stm->state; unsigned char *p = state->buffer; @@ -248,7 +225,7 @@ next_ahxd(fz_stream *stm, int max) if (state->eod) break; - c = fz_read_byte(state->chain); + c = fz_read_byte(ctx, state->chain); if (c < 0) break; @@ -275,7 +252,7 @@ next_ahxd(fz_stream *stm, int max) } else if (!iswhite(c)) { - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "bad data in ahxd: '%c'", c); + fz_throw(ctx, FZ_ERROR_GENERIC, "bad data in ahxd: '%c'", c); } } stm->rp = state->buffer; @@ -293,21 +270,13 @@ close_ahxd(fz_context *ctx, void *state_) fz_ahxd *state = (fz_ahxd *)state_; fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_ahxd(fz_stream *s) -{ - fz_ahxd *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_ahxd(fz_stream *chain) +fz_open_ahxd(fz_context *ctx, fz_stream *chain) { fz_ahxd *state; - fz_context *ctx = chain->ctx; fz_try(ctx) { @@ -317,11 +286,11 @@ fz_open_ahxd(fz_stream *chain) } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_ahxd, close_ahxd, rebind_ahxd); + return fz_new_stream(ctx, state, next_ahxd, close_ahxd); } /* ASCII 85 Decode */ @@ -336,7 +305,7 @@ struct fz_a85d_s }; static int -next_a85d(fz_stream *stm, int max) +next_a85d(fz_context *ctx, fz_stream *stm, int max) { fz_a85d *state = stm->state; unsigned char *p = state->buffer; @@ -354,7 +323,7 @@ next_a85d(fz_stream *stm, int max) ep = p + max; while (p < ep) { - c = fz_read_byte(state->chain); + c = fz_read_byte(ctx, state->chain); if (c < 0) break; @@ -389,9 +358,9 @@ next_a85d(fz_stream *stm, int max) else if (c == '~') { - c = fz_read_byte(state->chain); + c = fz_read_byte(ctx, state->chain); if (c != '>') - fz_warn(stm->ctx, "bad eod marker in a85d"); + fz_warn(ctx, "bad eod marker in a85d"); switch (count) { case 0: @@ -400,7 +369,7 @@ next_a85d(fz_stream *stm, int max) /* Specifically illegal in the spec, but adobe * and gs both cope. See normal_87.pdf for a * case where this matters. */ - fz_warn(stm->ctx, "partial final byte in a85d"); + fz_warn(ctx, "partial final byte in a85d"); break; case 2: word = word * (85 * 85 * 85) + 0xffffff; @@ -424,7 +393,7 @@ next_a85d(fz_stream *stm, int max) else if (!iswhite(c)) { - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "bad data in a85d: '%c'", c); + fz_throw(ctx, FZ_ERROR_GENERIC, "bad data in a85d: '%c'", c); } } @@ -445,21 +414,13 @@ close_a85d(fz_context *ctx, void *state_) fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_a85d(fz_stream *s) -{ - fz_a85d *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_a85d(fz_stream *chain) +fz_open_a85d(fz_context *ctx, fz_stream *chain) { fz_a85d *state; - fz_context *ctx = chain->ctx; fz_try(ctx) { @@ -469,11 +430,11 @@ fz_open_a85d(fz_stream *chain) } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_a85d, close_a85d, rebind_a85d); + return fz_new_stream(ctx, state, next_a85d, close_a85d); } /* Run Length Decode */ @@ -488,7 +449,7 @@ struct fz_rld_s }; static int -next_rld(fz_stream *stm, int max) +next_rld(fz_context *ctx, fz_stream *stm, int max) { fz_rld *state = stm->state; unsigned char *p = state->buffer; @@ -508,7 +469,7 @@ next_rld(fz_stream *stm, int max) if (state->n == 0) { - state->run = fz_read_byte(state->chain); + state->run = fz_read_byte(ctx, state->chain); if (state->run < 0) { state->run = 128; @@ -519,9 +480,9 @@ next_rld(fz_stream *stm, int max) if (state->run > 128) { state->n = 257 - state->run; - state->c = fz_read_byte(state->chain); + state->c = fz_read_byte(ctx, state->chain); if (state->c < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "premature end of data in run length decode"); + fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in run length decode"); } } @@ -529,9 +490,9 @@ next_rld(fz_stream *stm, int max) { while (p < ep && state->n) { - int c = fz_read_byte(state->chain); + int c = fz_read_byte(ctx, state->chain); if (c < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "premature end of data in run length decode"); + fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in run length decode"); *p++ = c; state->n--; } @@ -564,21 +525,13 @@ close_rld(fz_context *ctx, void *state_) fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_rld(fz_stream *s) -{ - fz_rld *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_rld(fz_stream *chain) +fz_open_rld(fz_context *ctx, fz_stream *chain) { fz_rld *state; - fz_context *ctx = chain->ctx; fz_try(ctx) { @@ -590,11 +543,11 @@ fz_open_rld(fz_stream *chain) } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_rld, close_rld, rebind_rld); + return fz_new_stream(ctx, state, next_rld, close_rld); } /* RC4 Filter */ @@ -609,10 +562,10 @@ struct fz_arc4c_s }; static int -next_arc4(fz_stream *stm, int max) +next_arc4(fz_context *ctx, fz_stream *stm, int max) { fz_arc4c *state = stm->state; - int n = fz_available(state->chain, max); + int n = fz_available(ctx, state->chain, max); if (n == 0) return EOF; @@ -635,21 +588,13 @@ close_arc4(fz_context *ctx, void *state_) fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_arc4c(fz_stream *s) -{ - fz_arc4c *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_arc4(fz_stream *chain, unsigned char *key, unsigned keylen) +fz_open_arc4(fz_context *ctx, fz_stream *chain, unsigned char *key, unsigned keylen) { fz_arc4c *state; - fz_context *ctx = chain->ctx; fz_try(ctx) { @@ -659,11 +604,11 @@ fz_open_arc4(fz_stream *chain, unsigned char *key, unsigned keylen) } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_arc4, close_arc4, rebind_arc4c); + return fz_new_stream(ctx, state, next_arc4, close_arc4); } /* AES Filter */ @@ -682,7 +627,7 @@ struct fz_aesd_s }; static int -next_aesd(fz_stream *stm, int max) +next_aesd(fz_context *ctx, fz_stream *stm, int max) { fz_aesd *state = stm->state; unsigned char *p = state->buffer; @@ -694,9 +639,9 @@ next_aesd(fz_stream *stm, int max) while (state->ivcount < 16) { - int c = fz_read_byte(state->chain); + int c = fz_read_byte(ctx, state->chain); if (c < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "premature end in aes filter"); + fz_throw(ctx, FZ_ERROR_GENERIC, "premature end in aes filter"); state->iv[state->ivcount++] = c; } @@ -705,22 +650,22 @@ next_aesd(fz_stream *stm, int max) while (p < ep) { - int n = fz_read(state->chain, state->bp, 16); + int n = fz_read(ctx, state->chain, state->bp, 16); if (n == 0) break; else if (n < 16) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "partial block in aes filter"); + fz_throw(ctx, FZ_ERROR_GENERIC, "partial block in aes filter"); aes_crypt_cbc(&state->aes, AES_DECRYPT, 16, state->iv, state->bp, state->bp); state->rp = state->bp; state->wp = state->bp + 16; /* strip padding at end of file */ - if (fz_is_eof(state->chain)) + if (fz_is_eof(ctx, state->chain)) { int pad = state->bp[15]; if (pad < 1 || pad > 16) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "aes padding out of range: %d", pad); + fz_throw(ctx, FZ_ERROR_GENERIC, "aes padding out of range: %d", pad); state->wp -= pad; } @@ -745,21 +690,13 @@ close_aesd(fz_context *ctx, void *state_) fz_stream *chain = state->chain; fz_free(ctx, state); - fz_drop_stream(chain); -} - -static fz_stream * -rebind_aesd(fz_stream *s) -{ - fz_aesd *state = s->state; - return state->chain; + fz_drop_stream(ctx, chain); } fz_stream * -fz_open_aesd(fz_stream *chain, unsigned char *key, unsigned keylen) +fz_open_aesd(fz_context *ctx, fz_stream *chain, unsigned char *key, unsigned keylen) { fz_aesd *state = NULL; - fz_context *ctx = chain->ctx; fz_var(state); @@ -776,9 +713,9 @@ fz_open_aesd(fz_stream *chain, unsigned char *key, unsigned keylen) fz_catch(ctx) { fz_free(ctx, state); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_aesd, close_aesd, rebind_aesd); + return fz_new_stream(ctx, state, next_aesd, close_aesd); } diff --git a/source/fitz/filter-dct.c b/source/fitz/filter-dct.c index 9495b899..0d24de88 100644 --- a/source/fitz/filter-dct.c +++ b/source/fitz/filter-dct.c @@ -109,13 +109,13 @@ static boolean fill_input_buffer(j_decompress_ptr cinfo) { struct jpeg_source_mgr *src = cinfo->src; fz_dctd *state = JZ_DCT_STATE_FROM_CINFO(cinfo); + fz_context *ctx = state->ctx; fz_stream *curr_stm = state->curr_stm; - fz_context *ctx = curr_stm->ctx; curr_stm->rp = curr_stm->wp; fz_try(ctx) { - src->bytes_in_buffer = fz_available(curr_stm, 1); + src->bytes_in_buffer = fz_available(ctx, curr_stm, 1); } fz_catch(ctx) { @@ -151,7 +151,7 @@ static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) } static int -next_dctd(fz_stream *stm, int max) +next_dctd(fz_context *ctx, fz_stream *stm, int max) { fz_dctd *state = stm->state; j_decompress_ptr cinfo = &state->cinfo; @@ -166,7 +166,7 @@ next_dctd(fz_stream *stm, int max) { if (cinfo->src) state->curr_stm->rp = state->curr_stm->wp - cinfo->src->bytes_in_buffer; - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "jpeg error: %s", state->msg); + fz_throw(ctx, FZ_ERROR_GENERIC, "jpeg error: %s", state->msg); } if (!state->init) @@ -183,8 +183,8 @@ next_dctd(fz_stream *stm, int max) state->init = 1; /* Skip over any stray returns at the start of the stream */ - while ((c = fz_peek_byte(state->chain)) == '\n' || c == '\r') - (void)fz_read_byte(state->chain); + while ((c = fz_peek_byte(ctx, state->chain)) == '\n' || c == '\r') + (void)fz_read_byte(ctx, state->chain); cinfo->src = &state->srcmgr; cinfo->src->init_source = init_source; @@ -244,7 +244,7 @@ next_dctd(fz_stream *stm, int max) jpeg_start_decompress(cinfo); state->stride = cinfo->output_width * cinfo->output_components; - state->scanline = fz_malloc(state->ctx, state->stride); + state->scanline = fz_malloc(ctx, state->stride); state->rp = state->scanline; state->wp = state->scanline; } @@ -308,30 +308,22 @@ skip: fz_dct_mem_term(state); fz_free(ctx, state->scanline); - fz_drop_stream(state->chain); - fz_drop_stream(state->jpegtables); + fz_drop_stream(ctx, state->chain); + fz_drop_stream(ctx, state->jpegtables); fz_free(ctx, state); } -static fz_stream * -rebind_dctd(fz_stream *s) -{ - fz_dctd *state = s->state; - return state->chain; -} - /* Default: color_transform = -1 (unset), l2factor = 0, jpegtables = NULL */ fz_stream * -fz_open_dctd(fz_stream *chain, int color_transform, int l2factor, fz_stream *jpegtables) +fz_open_dctd(fz_context *ctx, fz_stream *chain, int color_transform, int l2factor, fz_stream *jpegtables) { - fz_context *ctx = chain->ctx; fz_dctd *state = NULL; fz_var(state); fz_try(ctx) { - state = fz_malloc_struct(chain->ctx, fz_dctd); + state = fz_malloc_struct(ctx, fz_dctd); state->ctx = ctx; state->chain = chain; state->jpegtables = jpegtables; @@ -344,10 +336,10 @@ fz_open_dctd(fz_stream *chain, int color_transform, int l2factor, fz_stream *jpe fz_catch(ctx) { fz_free(ctx, state); - fz_drop_stream(chain); - fz_drop_stream(jpegtables); + fz_drop_stream(ctx, chain); + fz_drop_stream(ctx, jpegtables); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_dctd, close_dctd, rebind_dctd); + return fz_new_stream(ctx, state, next_dctd, close_dctd); } diff --git a/source/fitz/filter-fax.c b/source/fitz/filter-fax.c index 134c2ae5..f0a58160 100644 --- a/source/fitz/filter-fax.c +++ b/source/fitz/filter-fax.c @@ -321,7 +321,6 @@ enum struct fz_faxd_s { - fz_context *ctx; fz_stream *chain; int k; @@ -355,14 +354,14 @@ static inline void eat_bits(fz_faxd *fax, int nbits) } static int -fill_bits(fz_faxd *fax) +fill_bits(fz_context *ctx, fz_faxd *fax) { /* The longest length of bits we'll ever need is 13. Never read more * than we need to avoid unnecessary overreading of the end of the * stream. */ while (fax->bidx > (32-13)) { - int c = fz_read_byte(fax->chain); + int c = fz_read_byte(ctx, fax->chain); if (c == EOF) return EOF; fax->bidx -= 8; @@ -372,7 +371,7 @@ fill_bits(fz_faxd *fax) } static int -get_code(fz_faxd *fax, const cfd_node *table, int initialbits) +get_code(fz_context *ctx, fz_faxd *fax, const cfd_node *table, int initialbits) { unsigned int word = fax->word; int tidx = word >> (32 - initialbits); @@ -402,9 +401,9 @@ dec1d(fz_context *ctx, fz_faxd *fax) fax->a = 0; if (fax->c) - code = get_code(fax, cf_black_decode, cfd_black_initial_bits); + code = get_code(ctx, fax, cf_black_decode, cfd_black_initial_bits); else - code = get_code(fax, cf_white_decode, cfd_white_initial_bits); + code = get_code(ctx, fax, cf_white_decode, cfd_white_initial_bits); if (code == UNCOMPRESSED) fz_throw(ctx, FZ_ERROR_GENERIC, "uncompressed data in faxd"); @@ -441,9 +440,9 @@ dec2d(fz_context *ctx, fz_faxd *fax) fax->a = 0; if (fax->c) - code = get_code(fax, cf_black_decode, cfd_black_initial_bits); + code = get_code(ctx, fax, cf_black_decode, cfd_black_initial_bits); else - code = get_code(fax, cf_white_decode, cfd_white_initial_bits); + code = get_code(ctx, fax, cf_white_decode, cfd_white_initial_bits); if (code == UNCOMPRESSED) fz_throw(ctx, FZ_ERROR_GENERIC, "uncompressed data in faxd"); @@ -471,7 +470,7 @@ dec2d(fz_context *ctx, fz_faxd *fax) return; } - code = get_code(fax, cf_2d_decode, cfd_2d_initial_bits); + code = get_code(ctx, fax, cf_2d_decode, cfd_2d_initial_bits); switch (code) { @@ -556,9 +555,8 @@ dec2d(fz_context *ctx, fz_faxd *fax) } static int -next_faxd(fz_stream *stm, int max) +next_faxd(fz_context *ctx, fz_stream *stm, int max) { - fz_context *ctx = stm->ctx; fz_faxd *fax = stm->state; unsigned char *p = fax->buffer; unsigned char *ep; @@ -569,11 +567,11 @@ next_faxd(fz_stream *stm, int max) ep = p + max; if (fax->stage == STATE_INIT && fax->end_of_line) { - fill_bits(fax); + fill_bits(ctx, fax); if ((fax->word >> (32 - 12)) != 1) { fz_warn(ctx, "faxd stream doesn't start with EOL"); - while (!fill_bits(fax) && (fax->word >> (32 - 12)) != 1) + while (!fill_bits(ctx, fax) && (fax->word >> (32 - 12)) != 1) eat_bits(fax, 1); } if ((fax->word >> (32 - 12)) != 1) @@ -591,7 +589,7 @@ next_faxd(fz_stream *stm, int max) loop: - if (fill_bits(fax)) + if (fill_bits(ctx, fax)) { if (fax->bidx > 31) { @@ -776,28 +774,20 @@ close_faxd(fz_context *ctx, void *state_) /* if we read any extra bytes, try to put them back */ i = (32 - fax->bidx) / 8; while (i--) - fz_unread_byte(fax->chain); + fz_unread_byte(ctx, fax->chain); - fz_drop_stream(fax->chain); + fz_drop_stream(ctx, fax->chain); fz_free(ctx, fax->ref); fz_free(ctx, fax->dst); fz_free(ctx, fax); } -static fz_stream * -rebind_faxd(fz_stream *s) -{ - fz_faxd *state = s->state; - return state->chain; -} - /* Default: columns = 1728, end_of_block = 1, the rest = 0 */ fz_stream * -fz_open_faxd(fz_stream *chain, +fz_open_faxd(fz_context *ctx, fz_stream *chain, int k, int end_of_line, int encoded_byte_align, int columns, int rows, int end_of_block, int black_is_1) { - fz_context *ctx = chain->ctx; fz_faxd *fax = NULL; fz_var(fax); @@ -848,9 +838,9 @@ fz_open_faxd(fz_stream *chain, fz_free(ctx, fax->ref); } fz_free(ctx, fax); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, fax, next_faxd, close_faxd, rebind_faxd); + return fz_new_stream(ctx, fax, next_faxd, close_faxd); } diff --git a/source/fitz/filter-flate.c b/source/fitz/filter-flate.c index 764e819a..46ff6970 100644 --- a/source/fitz/filter-flate.c +++ b/source/fitz/filter-flate.c @@ -22,7 +22,7 @@ static void zfree(void *opaque, void *ptr) } static int -next_flated(fz_stream *stm, int required) +next_flated(fz_context *ctx, fz_stream *stm, int required) { fz_flate *state = stm->state; fz_stream *chain = state->chain; @@ -39,7 +39,7 @@ next_flated(fz_stream *stm, int required) while (zp->avail_out > 0) { - zp->avail_in = fz_available(chain, 1); + zp->avail_in = fz_available(ctx, chain, 1); zp->next_in = chain->rp; code = inflate(zp, Z_SYNC_FLUSH); @@ -52,23 +52,23 @@ next_flated(fz_stream *stm, int required) } else if (code == Z_BUF_ERROR) { - fz_warn(stm->ctx, "premature end of data in flate filter"); + fz_warn(ctx, "premature end of data in flate filter"); break; } else if (code == Z_DATA_ERROR && zp->avail_in == 0) { - fz_warn(stm->ctx, "ignoring zlib error: %s", zp->msg); + fz_warn(ctx, "ignoring zlib error: %s", zp->msg); break; } else if (code == Z_DATA_ERROR && !strcmp(zp->msg, "incorrect data check")) { - fz_warn(stm->ctx, "ignoring zlib error: %s", zp->msg); + fz_warn(ctx, "ignoring zlib error: %s", zp->msg); chain->rp = chain->wp; break; } else if (code != Z_OK) { - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "zlib error: %s", zp->msg); + fz_throw(ctx, FZ_ERROR_GENERIC, "zlib error: %s", zp->msg); } } @@ -93,23 +93,15 @@ close_flated(fz_context *ctx, void *state_) if (code != Z_OK) fz_warn(ctx, "zlib error: inflateEnd: %s", state->z.msg); - fz_drop_stream(state->chain); + fz_drop_stream(ctx, state->chain); fz_free(ctx, state); } -static fz_stream * -rebind_flated(fz_stream *s) -{ - fz_flate *state = s->state; - return state->chain; -} - fz_stream * -fz_open_flated(fz_stream *chain, int window_bits) +fz_open_flated(fz_context *ctx, fz_stream *chain, int window_bits) { fz_flate *state = NULL; int code = Z_OK; - fz_context *ctx = chain->ctx; fz_var(code); fz_var(state); @@ -134,8 +126,8 @@ fz_open_flated(fz_stream *chain, int window_bits) if (state && code == Z_OK) inflateEnd(&state->z); fz_free(ctx, state); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_flated, close_flated, rebind_flated); + return fz_new_stream(ctx, state, next_flated, close_flated); } diff --git a/source/fitz/filter-jbig2.c b/source/fitz/filter-jbig2.c index 0e624da6..8aec1d67 100644 --- a/source/fitz/filter-jbig2.c +++ b/source/fitz/filter-jbig2.c @@ -35,12 +35,12 @@ close_jbig2d(fz_context *ctx, void *state_) if (state->gctx) fz_drop_jbig2_globals(ctx, state->gctx); jbig2_ctx_free(state->ctx); - fz_drop_stream(state->chain); + fz_drop_stream(ctx, state->chain); fz_free(ctx, state); } static int -next_jbig2d(fz_stream *stm, int len) +next_jbig2d(fz_context *ctx, fz_stream *stm, int len) { fz_jbig2d *state = stm->state; unsigned char tmp[4096]; @@ -58,7 +58,7 @@ next_jbig2d(fz_stream *stm, int len) { while (1) { - n = fz_read(state->chain, tmp, sizeof tmp); + n = fz_read(ctx, state->chain, tmp, sizeof tmp); if (n == 0) break; jbig2_data_in(state->ctx, tmp, n); @@ -68,7 +68,7 @@ next_jbig2d(fz_stream *stm, int len) state->page = jbig2_page_out(state->ctx); if (!state->page) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "jbig2_page_out failed"); + fz_throw(ctx, FZ_ERROR_GENERIC, "jbig2_page_out failed"); } s = state->page->data; @@ -86,13 +86,6 @@ next_jbig2d(fz_stream *stm, int len) return *stm->rp++; } -static fz_stream * -rebind_jbig2d(fz_stream *s) -{ - fz_jbig2d *state = s->state; - return state->chain; -} - static int error_callback(void *data, const char *msg, Jbig2Severity severity, int32_t seg_idx) { @@ -127,16 +120,15 @@ fz_drop_jbig2_globals_imp(fz_context *ctx, fz_storable *globals_) } fz_stream * -fz_open_jbig2d(fz_stream *chain, fz_jbig2_globals *globals) +fz_open_jbig2d(fz_context *ctx, fz_stream *chain, fz_jbig2_globals *globals) { fz_jbig2d *state = NULL; - fz_context *ctx = chain->ctx; fz_var(state); fz_try(ctx) { - state = fz_malloc_struct(chain->ctx, fz_jbig2d); + state = fz_malloc_struct(ctx, fz_jbig2d); state->ctx = NULL; state->gctx = globals; state->chain = chain; @@ -153,9 +145,9 @@ fz_open_jbig2d(fz_stream *chain, fz_jbig2_globals *globals) jbig2_ctx_free(state->ctx); } fz_free(ctx, state); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_jbig2d, close_jbig2d, rebind_jbig2d); + return fz_new_stream(ctx, state, next_jbig2d, close_jbig2d); } diff --git a/source/fitz/filter-leech.c b/source/fitz/filter-leech.c index 67a43a29..90e28565 100644 --- a/source/fitz/filter-leech.c +++ b/source/fitz/filter-leech.c @@ -11,18 +11,18 @@ struct fz_leech_s }; static int -next_leech(fz_stream *stm, int max) +next_leech(fz_context *ctx, fz_stream *stm, int max) { fz_leech *state = stm->state; fz_buffer *buffer = state->buffer; - int n = fz_available(state->chain, max); + int n = fz_available(ctx, state->chain, max); if (n > max) n = max; while (buffer->cap < buffer->len + n) { - fz_grow_buffer(stm->ctx, state->buffer); + fz_grow_buffer(ctx, state->buffer); } memcpy(buffer->data + buffer->len, state->chain->rp, n); stm->rp = buffer->data + buffer->len; @@ -40,22 +40,14 @@ close_leech(fz_context *ctx, void *state_) { fz_leech *state = (fz_leech *)state_; - fz_drop_stream(state->chain); + fz_drop_stream(ctx, state->chain); fz_free(ctx, state); } -static fz_stream * -rebind_leech(fz_stream *s) -{ - fz_leech *state = s->state; - return state->chain; -} - fz_stream * -fz_open_leecher(fz_stream *chain, fz_buffer *buffer) +fz_open_leecher(fz_context *ctx, fz_stream *chain, fz_buffer *buffer) { fz_leech *state = NULL; - fz_context *ctx = chain->ctx; fz_var(state); @@ -68,8 +60,8 @@ fz_open_leecher(fz_stream *chain, fz_buffer *buffer) fz_catch(ctx) { fz_free(ctx, state); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_leech, close_leech, rebind_leech); + return fz_new_stream(ctx, state, next_leech, close_leech); } diff --git a/source/fitz/filter-lzw.c b/source/fitz/filter-lzw.c index 4f8fdd31..257c6c86 100644 --- a/source/fitz/filter-lzw.c +++ b/source/fitz/filter-lzw.c @@ -46,7 +46,7 @@ struct fz_lzwd_s }; static int -next_lzwd(fz_stream *stm, int len) +next_lzwd(fz_context *ctx, fz_stream *stm, int len) { fz_lzwd *lzw = stm->state; lzw_code *table = lzw->table; @@ -73,9 +73,9 @@ next_lzwd(fz_stream *stm, int len) if (lzw->eod) return EOF; - code = fz_read_bits(lzw->chain, code_bits); + code = fz_read_bits(ctx, lzw->chain, code_bits); - if (fz_is_eof_bits(lzw->chain)) + if (fz_is_eof_bits(ctx, lzw->chain)) { lzw->eod = 1; break; @@ -89,7 +89,7 @@ next_lzwd(fz_stream *stm, int len) if (next_code > NUM_CODES && code != LZW_CLEAR) { - fz_warn(stm->ctx, "missing clear code in lzw decode"); + fz_warn(ctx, "missing clear code in lzw decode"); code = LZW_CLEAR; } @@ -109,12 +109,12 @@ next_lzwd(fz_stream *stm, int len) else if (next_code == NUM_CODES) { /* TODO: Ghostscript checks for a following LZW_CLEAR before tolerating */ - fz_warn(stm->ctx, "tolerating a single out of range code in lzw decode"); + fz_warn(ctx, "tolerating a single out of range code in lzw decode"); next_code++; } else if (code > next_code || next_code >= NUM_CODES) { - fz_warn(stm->ctx, "out of range code encountered in lzw decode"); + fz_warn(ctx, "out of range code encountered in lzw decode"); } else { @@ -127,7 +127,7 @@ next_lzwd(fz_stream *stm, int len) else if (code == next_code) table[next_code].value = table[next_code].first_char; else - fz_warn(stm->ctx, "out of range code encountered in lzw decode"); + fz_warn(ctx, "out of range code encountered in lzw decode"); next_code ++; @@ -188,23 +188,15 @@ static void close_lzwd(fz_context *ctx, void *state_) { fz_lzwd *lzw = (fz_lzwd *)state_; - fz_sync_bits(lzw->chain); - fz_drop_stream(lzw->chain); + fz_sync_bits(ctx, lzw->chain); + fz_drop_stream(ctx, lzw->chain); fz_free(ctx, lzw); } -static fz_stream * -rebind_lzwd(fz_stream *s) -{ - fz_lzwd *state = s->state; - return state->chain; -} - /* Default: early_change = 1 */ fz_stream * -fz_open_lzwd(fz_stream *chain, int early_change) +fz_open_lzwd(fz_context *ctx, fz_stream *chain, int early_change) { - fz_context *ctx = chain->ctx; fz_lzwd *lzw = NULL; int i; @@ -243,9 +235,9 @@ fz_open_lzwd(fz_stream *chain, int early_change) fz_catch(ctx) { fz_free(ctx, lzw); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, lzw, next_lzwd, close_lzwd, rebind_lzwd); + return fz_new_stream(ctx, lzw, next_lzwd, close_lzwd); } diff --git a/source/fitz/filter-predict.c b/source/fitz/filter-predict.c index a5c93bfd..3136c651 100644 --- a/source/fitz/filter-predict.c +++ b/source/fitz/filter-predict.c @@ -157,7 +157,7 @@ fz_predict_png(fz_predict *state, unsigned char *out, unsigned char *in, int len } static int -next_predict(fz_stream *stm, int len) +next_predict(fz_context *ctx, fz_stream *stm, int len) { fz_predict *state = stm->state; unsigned char *buf = state->buffer; @@ -175,7 +175,7 @@ next_predict(fz_stream *stm, int len) while (p < ep) { - n = fz_read(state->chain, state->in, state->stride + ispng); + n = fz_read(ctx, state->chain, state->in, state->stride + ispng); if (n == 0) break; @@ -209,25 +209,17 @@ static void close_predict(fz_context *ctx, void *state_) { fz_predict *state = (fz_predict *)state_; - fz_drop_stream(state->chain); + fz_drop_stream(ctx, state->chain); fz_free(ctx, state->in); fz_free(ctx, state->out); fz_free(ctx, state->ref); fz_free(ctx, state); } -static fz_stream * -rebind_predict(fz_stream *s) -{ - fz_predict *state = s->state; - return state->chain; -} - /* Default values: predictor = 1, columns = 1, colors = 1, bpc = 8 */ fz_stream * -fz_open_predict(fz_stream *chain, int predictor, int columns, int colors, int bpc) +fz_open_predict(fz_context *ctx, fz_stream *chain, int predictor, int columns, int colors, int bpc) { - fz_context *ctx = chain->ctx; fz_predict *state = NULL; fz_var(state); @@ -288,9 +280,9 @@ fz_open_predict(fz_stream *chain, int predictor, int columns, int colors, int bp fz_free(ctx, state->out); } fz_free(ctx, state); - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } - return fz_new_stream(ctx, state, next_predict, close_predict, rebind_predict); + return fz_new_stream(ctx, state, next_predict, close_predict); } diff --git a/source/fitz/font.c b/source/fitz/font.c index 08379b0f..e35f01fa 100644 --- a/source/fitz/font.c +++ b/source/fitz/font.c @@ -89,7 +89,7 @@ free_resources(fz_context *ctx, fz_font *font) if (font->t3resources) { - font->t3freeres(font->t3doc, font->t3resources); + font->t3freeres(ctx, font->t3doc, font->t3resources); font->t3resources = NULL; } @@ -1063,9 +1063,9 @@ fz_prepare_t3_glyph(fz_context *ctx, fz_font *font, int gid, int nested_depth) FZ_DEVFLAG_LINEJOIN_UNDEFINED | FZ_DEVFLAG_MITERLIMIT_UNDEFINED | FZ_DEVFLAG_LINEWIDTH_UNDEFINED; - font->t3run(font->t3doc, font->t3resources, contents, dev, &fz_identity, NULL, 0); + font->t3run(ctx, font->t3doc, font->t3resources, contents, dev, &fz_identity, NULL, 0); font->t3flags[gid] = dev->flags; - fz_drop_device(dev); + fz_drop_device(ctx, dev); } static fz_rect * @@ -1087,11 +1087,11 @@ fz_bound_t3_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, dev = fz_new_bbox_device(ctx, bounds); fz_try(ctx) { - fz_run_display_list(list, dev, &ctm, &fz_infinite_rect, NULL); + fz_run_display_list(ctx, list, dev, &ctm, &fz_infinite_rect, NULL); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); } fz_catch(ctx) { @@ -1117,7 +1117,7 @@ fz_run_t3_glyph(fz_context *ctx, fz_font *font, int gid, const fz_matrix *trm, f return; fz_concat(&ctm, &font->t3matrix, trm); - fz_run_display_list(list, dev, &ctm, &fz_infinite_rect, NULL); + fz_run_display_list(ctx, list, dev, &ctm, &fz_infinite_rect, NULL); } fz_pixmap * @@ -1168,7 +1168,7 @@ fz_render_t3_glyph_pixmap(fz_context *ctx, fz_font *font, int gid, const fz_matr } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); } fz_catch(ctx) { @@ -1230,7 +1230,7 @@ fz_render_t3_glyph_direct(fz_context *ctx, fz_device *dev, fz_font *font, int gi } fz_concat(&ctm, &font->t3matrix, trm); - font->t3run(font->t3doc, font->t3resources, contents, dev, &ctm, gstate, nested_depth); + font->t3run(ctx, font->t3doc, font->t3resources, contents, dev, &ctm, gstate, nested_depth); } #ifndef NDEBUG diff --git a/source/fitz/function.c b/source/fitz/function.c index 2623ff3d..5dbe9f9c 100644 --- a/source/fitz/function.c +++ b/source/fitz/function.c @@ -45,7 +45,7 @@ fz_drop_function(fz_context *ctx, fz_function *func) } unsigned int -fz_function_size(fz_function *func) +fz_function_size(fz_context *ctx, fz_function *func) { return (func ? func->size : 0); } diff --git a/source/fitz/image.c b/source/fitz/image.c index e7096ab4..4c82e2c7 100644 --- a/source/fitz/image.c +++ b/source/fitz/image.c @@ -31,7 +31,7 @@ struct fz_image_key_s { }; static int -fz_make_hash_image_key(fz_store_hash *hash, void *key_) +fz_make_hash_image_key(fz_context *ctx, fz_store_hash *hash, void *key_) { fz_image_key *key = (fz_image_key *)key_; @@ -71,7 +71,7 @@ fz_drop_image_key(fz_context *ctx, void *key_) } static int -fz_cmp_image_key(void *k0_, void *k1_) +fz_cmp_image_key(fz_context *ctx, void *k0_, void *k1_) { fz_image_key *k0 = (fz_image_key *)k0_; fz_image_key *k1 = (fz_image_key *)k1_; @@ -81,7 +81,7 @@ fz_cmp_image_key(void *k0_, void *k1_) #ifndef NDEBUG static void -fz_debug_image(FILE *out, void *key_) +fz_debug_image(fz_context *ctx, FILE *out, void *key_) { fz_image_key *key = (fz_image_key *)key_; @@ -169,7 +169,7 @@ fz_decomp_image_from_stream(fz_context *ctx, fz_stream *stm, fz_image *image, in samples = fz_malloc_array(ctx, h, stride); - len = fz_read(stm, samples, h * stride); + len = fz_read(ctx, stm, samples, h * stride); /* Pad truncated images */ if (len < stride * h) @@ -188,7 +188,7 @@ fz_decomp_image_from_stream(fz_context *ctx, fz_stream *stm, fz_image *image, in p[i] = ~p[i]; } - fz_unpack_tile(tile, samples, image->n, image->bpc, stride, indexed); + fz_unpack_tile(ctx, tile, samples, image->n, image->bpc, stride, indexed); fz_free(ctx, samples); samples = NULL; @@ -200,14 +200,14 @@ fz_decomp_image_from_stream(fz_context *ctx, fz_stream *stm, fz_image *image, in if (indexed) { fz_pixmap *conv; - fz_decode_indexed_tile(tile, image->decode, (1 << image->bpc) - 1); + fz_decode_indexed_tile(ctx, tile, image->decode, (1 << image->bpc) - 1); conv = fz_expand_indexed_pixmap(ctx, tile); fz_drop_pixmap(ctx, tile); tile = conv; } else { - fz_decode_tile(tile, image->decode); + fz_decode_tile(ctx, tile, image->decode); } /* pre-blended matte color */ @@ -216,7 +216,7 @@ fz_decomp_image_from_stream(fz_context *ctx, fz_stream *stm, fz_image *image, in } fz_always(ctx) { - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); } fz_catch(ctx) { @@ -336,7 +336,7 @@ fz_image_get_pixmap(fz_context *ctx, fz_image *image, int w, int h) native_l2factor = l2factor; stm = fz_open_image_decomp_stream_from_buffer(ctx, image->buffer, &native_l2factor); - indexed = fz_colorspace_is_indexed(image->colorspace); + indexed = fz_colorspace_is_indexed(ctx, image->colorspace); tile = fz_decomp_image_from_stream(ctx, stm, image, indexed, l2factor, native_l2factor); /* CMYK JPEGs in XPS documents have to be inverted */ @@ -403,12 +403,11 @@ fz_new_image_from_pixmap(fz_context *ctx, fz_pixmap *pixmap, fz_image *mask) image->get_pixmap = fz_image_get_pixmap; image->xres = pixmap->xres; image->yres = pixmap->yres; - image->tile = pixmap; + image->tile = fz_keep_pixmap(ctx, pixmap); image->mask = mask; } fz_catch(ctx) { - fz_drop_pixmap(ctx, pixmap); fz_drop_image(ctx, mask); fz_rethrow(ctx); } @@ -445,7 +444,7 @@ fz_new_image(fz_context *ctx, int w, int h, int bpc, fz_colorspace *colorspace, memcpy(image->decode, decode, sizeof(float)*image->n*2); else { - float maxval = fz_colorspace_is_indexed(colorspace) ? (1 << bpc) - 1 : 1; + float maxval = fz_colorspace_is_indexed(ctx, colorspace) ? (1 << bpc) - 1 : 1; int i; for (i = 0; i < image->n; i++) { diff --git a/source/fitz/list-device.c b/source/fitz/list-device.c index c6e8011f..f56bc879 100644 --- a/source/fitz/list-device.c +++ b/source/fitz/list-device.c @@ -229,9 +229,8 @@ fz_free_display_node(fz_context *ctx, fz_display_node *node) } static void -fz_list_begin_page(fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm) +fz_list_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; fz_display_node *node = fz_new_display_node(ctx, FZ_CMD_BEGIN_PAGE, ctm, NULL, NULL, 0); node->rect = *mediabox; fz_transform_rect(&node->rect, ctm); @@ -239,24 +238,22 @@ fz_list_begin_page(fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm } static void -fz_list_end_page(fz_device *dev) +fz_list_end_page(fz_context *ctx, fz_device *dev) { - fz_context *ctx = dev->ctx; fz_display_node *node = fz_new_display_node(ctx, FZ_CMD_END_PAGE, &fz_identity, NULL, NULL, 0); fz_append_display_node(dev->user, node); } static void -fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_list_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_FILL_PATH, ctm, colorspace, color, alpha); fz_try(ctx) { - fz_bound_path(dev->ctx, path, NULL, ctm, &node->rect); - node->item.path = fz_keep_path(dev->ctx, path); + fz_bound_path(ctx, path, NULL, ctm, &node->rect); + node->item.path = fz_keep_path(ctx, path); node->flag = even_odd; } fz_catch(ctx) @@ -268,17 +265,16 @@ fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix * } static void -fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, +fz_list_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_STROKE_PATH, ctm, colorspace, color, alpha); fz_try(ctx) { - fz_bound_path(dev->ctx, path, stroke, ctm, &node->rect); - node->item.path = fz_keep_path(dev->ctx, path); - node->stroke = fz_keep_stroke_state(dev->ctx, stroke); + fz_bound_path(ctx, path, stroke, ctm, &node->rect); + node->item.path = fz_keep_path(ctx, path); + node->stroke = fz_keep_stroke_state(ctx, stroke); } fz_catch(ctx) { @@ -289,17 +285,16 @@ fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, } static void -fz_list_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_list_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_CLIP_PATH, ctm, NULL, NULL, 0); fz_try(ctx) { - fz_bound_path(dev->ctx, path, NULL, ctm, &node->rect); + fz_bound_path(ctx, path, NULL, ctm, &node->rect); if (rect) fz_intersect_rect(&node->rect, rect); - node->item.path = fz_keep_path(dev->ctx, path); + node->item.path = fz_keep_path(ctx, path); node->flag = even_odd; } fz_catch(ctx) @@ -311,18 +306,17 @@ fz_list_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_o } static void -fz_list_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_list_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_CLIP_STROKE_PATH, ctm, NULL, NULL, 0); fz_try(ctx) { - fz_bound_path(dev->ctx, path, stroke, ctm, &node->rect); + fz_bound_path(ctx, path, stroke, ctm, &node->rect); if (rect) fz_intersect_rect(&node->rect, rect); - node->item.path = fz_keep_path(dev->ctx, path); - node->stroke = fz_keep_stroke_state(dev->ctx, stroke); + node->item.path = fz_keep_path(ctx, path); + node->stroke = fz_keep_stroke_state(ctx, stroke); } fz_catch(ctx) { @@ -333,16 +327,15 @@ fz_list_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_ } static void -fz_list_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_list_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_FILL_TEXT, ctm, colorspace, color, alpha); fz_try(ctx) { - fz_bound_text(dev->ctx, text, NULL, ctm, &node->rect); - node->item.text = fz_keep_text(dev->ctx, text); + fz_bound_text(ctx, text, NULL, ctm, &node->rect); + node->item.text = fz_keep_text(ctx, text); } fz_catch(ctx) { @@ -353,18 +346,17 @@ fz_list_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, } static void -fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_list_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_STROKE_TEXT, ctm, colorspace, color, alpha); node->item.text = NULL; fz_try(ctx) { - fz_bound_text(dev->ctx, text, stroke, ctm, &node->rect); - node->item.text = fz_keep_text(dev->ctx, text); - node->stroke = fz_keep_stroke_state(dev->ctx, stroke); + fz_bound_text(ctx, text, stroke, ctm, &node->rect); + node->item.text = fz_keep_text(ctx, text); + node->stroke = fz_keep_stroke_state(ctx, stroke); } fz_catch(ctx) { @@ -375,15 +367,14 @@ fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, cons } static void -fz_list_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_list_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_CLIP_TEXT, ctm, NULL, NULL, 0); fz_try(ctx) { - fz_bound_text(dev->ctx, text, NULL, ctm, &node->rect); - node->item.text = fz_keep_text(dev->ctx, text); + fz_bound_text(ctx, text, NULL, ctm, &node->rect); + node->item.text = fz_keep_text(ctx, text); node->flag = accumulate; /* when accumulating, be conservative about culling */ if (accumulate) @@ -398,16 +389,15 @@ fz_list_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accum } static void -fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_list_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_CLIP_STROKE_TEXT, ctm, NULL, NULL, 0); fz_try(ctx) { - fz_bound_text(dev->ctx, text, stroke, ctm, &node->rect); - node->item.text = fz_keep_text(dev->ctx, text); - node->stroke = fz_keep_stroke_state(dev->ctx, stroke); + fz_bound_text(ctx, text, stroke, ctm, &node->rect); + node->item.text = fz_keep_text(ctx, text); + node->stroke = fz_keep_stroke_state(ctx, stroke); } fz_catch(ctx) { @@ -418,15 +408,14 @@ fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, } static void -fz_list_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_list_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_IGNORE_TEXT, ctm, NULL, NULL, 0); fz_try(ctx) { - fz_bound_text(dev->ctx, text, NULL, ctm, &node->rect); - node->item.text = fz_keep_text(dev->ctx, text); + fz_bound_text(ctx, text, NULL, ctm, &node->rect); + node->item.text = fz_keep_text(ctx, text); } fz_catch(ctx) { @@ -437,18 +426,17 @@ fz_list_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) } static void -fz_list_pop_clip(fz_device *dev) +fz_list_pop_clip(fz_context *ctx, fz_device *dev) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_POP_CLIP, &fz_identity, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_POP_CLIP, &fz_identity, NULL, NULL, 0); fz_append_display_node(dev->user, node); } static void -fz_list_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_list_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { fz_display_node *node; - fz_context *ctx = dev->ctx; node = fz_new_display_node(ctx, FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha); fz_bound_shade(ctx, shade, ctm, &node->rect); node->item.shade = fz_keep_shade(ctx, shade); @@ -456,64 +444,64 @@ fz_list_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float } static void -fz_list_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +fz_list_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha); + node = fz_new_display_node(ctx, FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha); node->rect = fz_unit_rect; fz_transform_rect(&node->rect, ctm); - node->item.image = fz_keep_image(dev->ctx, image); + node->item.image = fz_keep_image(ctx, image); fz_append_display_node(dev->user, node); } static void -fz_list_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_list_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha); + node = fz_new_display_node(ctx, FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha); node->rect = fz_unit_rect; fz_transform_rect(&node->rect, ctm); - node->item.image = fz_keep_image(dev->ctx, image); + node->item.image = fz_keep_image(ctx, image); fz_append_display_node(dev->user, node); } static void -fz_list_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_list_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0); node->rect = fz_unit_rect; fz_transform_rect(&node->rect, ctm); if (rect) fz_intersect_rect(&node->rect, rect); - node->item.image = fz_keep_image(dev->ctx, image); + node->item.image = fz_keep_image(ctx, image); fz_append_display_node(dev->user, node); } static void -fz_list_begin_mask(fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color) +fz_list_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *rect, int luminosity, fz_colorspace *colorspace, float *color) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_MASK, &fz_identity, colorspace, color, 0); + node = fz_new_display_node(ctx, FZ_CMD_BEGIN_MASK, &fz_identity, colorspace, color, 0); node->rect = *rect; node->flag = luminosity; fz_append_display_node(dev->user, node); } static void -fz_list_end_mask(fz_device *dev) +fz_list_end_mask(fz_context *ctx, fz_device *dev) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_END_MASK, &fz_identity, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_END_MASK, &fz_identity, NULL, NULL, 0); fz_append_display_node(dev->user, node); } static void -fz_list_begin_group(fz_device *dev, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) +fz_list_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *rect, int isolated, int knockout, int blendmode, float alpha) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_GROUP, &fz_identity, NULL, NULL, alpha); + node = fz_new_display_node(ctx, FZ_CMD_BEGIN_GROUP, &fz_identity, NULL, NULL, alpha); node->rect = *rect; node->item.blendmode = blendmode; node->flag |= isolated ? ISOLATED : 0; @@ -522,19 +510,19 @@ fz_list_begin_group(fz_device *dev, const fz_rect *rect, int isolated, int knock } static void -fz_list_end_group(fz_device *dev) +fz_list_end_group(fz_context *ctx, fz_device *dev) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_END_GROUP, &fz_identity, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_END_GROUP, &fz_identity, NULL, NULL, 0); fz_append_display_node(dev->user, node); } static int -fz_list_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_list_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { /* We ignore id here, as we will pass on our own id */ fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0); node->rect = *area; node->color[0] = xstep; node->color[1] = ystep; @@ -547,10 +535,10 @@ fz_list_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, flo } static void -fz_list_end_tile(fz_device *dev) +fz_list_end_tile(fz_context *ctx, fz_device *dev) { fz_display_node *node; - node = fz_new_display_node(dev->ctx, FZ_CMD_END_TILE, &fz_identity, NULL, NULL, 0); + node = fz_new_display_node(ctx, FZ_CMD_END_TILE, &fz_identity, NULL, NULL, 0); fz_append_display_node(dev->user, node); } @@ -665,14 +653,13 @@ skip_to_end_tile(fz_display_node *node, int *progress) } void -fz_run_display_list(fz_display_list *list, fz_device *dev, const fz_matrix *top_ctm, const fz_rect *scissor, fz_cookie *cookie) +fz_run_display_list(fz_context *ctx, fz_display_list *list, fz_device *dev, const fz_matrix *top_ctm, const fz_rect *scissor, fz_cookie *cookie) { fz_display_node *node; fz_matrix ctm; int clipped = 0; int tiled = 0; int progress = 0; - fz_context *ctx = dev->ctx; if (!scissor) scissor = &fz_infinite_rect; @@ -753,75 +740,75 @@ visible: switch (node->cmd) { case FZ_CMD_BEGIN_PAGE: - fz_begin_page(dev, &node_rect, &ctm); + fz_begin_page(ctx, dev, &node_rect, &ctm); break; case FZ_CMD_END_PAGE: - fz_end_page(dev); + fz_end_page(ctx, dev); break; case FZ_CMD_FILL_PATH: - fz_fill_path(dev, node->item.path, node->flag, &ctm, + fz_fill_path(ctx, dev, node->item.path, node->flag, &ctm, node->colorspace, node->color, node->alpha); break; case FZ_CMD_STROKE_PATH: - fz_stroke_path(dev, node->item.path, node->stroke, &ctm, + fz_stroke_path(ctx, dev, node->item.path, node->stroke, &ctm, node->colorspace, node->color, node->alpha); break; case FZ_CMD_CLIP_PATH: - fz_clip_path(dev, node->item.path, &node_rect, node->flag, &ctm); + fz_clip_path(ctx, dev, node->item.path, &node_rect, node->flag, &ctm); break; case FZ_CMD_CLIP_STROKE_PATH: - fz_clip_stroke_path(dev, node->item.path, &node_rect, node->stroke, &ctm); + fz_clip_stroke_path(ctx, dev, node->item.path, &node_rect, node->stroke, &ctm); break; case FZ_CMD_FILL_TEXT: - fz_fill_text(dev, node->item.text, &ctm, + fz_fill_text(ctx, dev, node->item.text, &ctm, node->colorspace, node->color, node->alpha); break; case FZ_CMD_STROKE_TEXT: - fz_stroke_text(dev, node->item.text, node->stroke, &ctm, + fz_stroke_text(ctx, dev, node->item.text, node->stroke, &ctm, node->colorspace, node->color, node->alpha); break; case FZ_CMD_CLIP_TEXT: - fz_clip_text(dev, node->item.text, &ctm, node->flag); + fz_clip_text(ctx, dev, node->item.text, &ctm, node->flag); break; case FZ_CMD_CLIP_STROKE_TEXT: - fz_clip_stroke_text(dev, node->item.text, node->stroke, &ctm); + fz_clip_stroke_text(ctx, dev, node->item.text, node->stroke, &ctm); break; case FZ_CMD_IGNORE_TEXT: - fz_ignore_text(dev, node->item.text, &ctm); + fz_ignore_text(ctx, dev, node->item.text, &ctm); break; case FZ_CMD_FILL_SHADE: if ((dev->hints & FZ_IGNORE_SHADE) == 0) - fz_fill_shade(dev, node->item.shade, &ctm, node->alpha); + fz_fill_shade(ctx, dev, node->item.shade, &ctm, node->alpha); break; case FZ_CMD_FILL_IMAGE: if ((dev->hints & FZ_IGNORE_IMAGE) == 0) - fz_fill_image(dev, node->item.image, &ctm, node->alpha); + fz_fill_image(ctx, dev, node->item.image, &ctm, node->alpha); break; case FZ_CMD_FILL_IMAGE_MASK: if ((dev->hints & FZ_IGNORE_IMAGE) == 0) - fz_fill_image_mask(dev, node->item.image, &ctm, + fz_fill_image_mask(ctx, dev, node->item.image, &ctm, node->colorspace, node->color, node->alpha); break; case FZ_CMD_CLIP_IMAGE_MASK: if ((dev->hints & FZ_IGNORE_IMAGE) == 0) - fz_clip_image_mask(dev, node->item.image, &node_rect, &ctm); + fz_clip_image_mask(ctx, dev, node->item.image, &node_rect, &ctm); break; case FZ_CMD_POP_CLIP: - fz_pop_clip(dev); + fz_pop_clip(ctx, dev); break; case FZ_CMD_BEGIN_MASK: - fz_begin_mask(dev, &node_rect, node->flag, node->colorspace, node->color); + fz_begin_mask(ctx, dev, &node_rect, node->flag, node->colorspace, node->color); break; case FZ_CMD_END_MASK: - fz_end_mask(dev); + fz_end_mask(ctx, dev); break; case FZ_CMD_BEGIN_GROUP: - fz_begin_group(dev, &node_rect, + fz_begin_group(ctx, dev, &node_rect, (node->flag & ISOLATED) != 0, (node->flag & KNOCKOUT) != 0, node->item.blendmode, node->alpha); break; case FZ_CMD_END_GROUP: - fz_end_group(dev); + fz_end_group(ctx, dev); break; case FZ_CMD_BEGIN_TILE: { @@ -832,14 +819,14 @@ visible: tile_rect.y0 = node->color[3]; tile_rect.x1 = node->color[4]; tile_rect.y1 = node->color[5]; - cached = fz_begin_tile_id(dev, &node->rect, &tile_rect, node->color[0], node->color[1], &ctm, node->flag); + cached = fz_begin_tile_id(ctx, dev, &node->rect, &tile_rect, node->color[0], node->color[1], &ctm, node->flag); if (cached) node = skip_to_end_tile(node, &progress); break; } case FZ_CMD_END_TILE: tiled--; - fz_end_tile(dev); + fz_end_tile(ctx, dev); break; } } diff --git a/source/fitz/load-png.c b/source/fitz/load-png.c index d897b5be..1cca89c0 100644 --- a/source/fitz/load-png.c +++ b/source/fitz/load-png.c @@ -4,7 +4,6 @@ struct info { - fz_context *ctx; unsigned int width, height, depth, n; int interlace, indexed; unsigned int size; @@ -162,7 +161,7 @@ static const unsigned int adam7_iy[7] = { 0, 0, 4, 0, 2, 0, 1 }; static const unsigned int adam7_dy[7] = { 8, 8, 8, 4, 4, 2, 2 }; static void -png_deinterlace_passes(struct info *info, unsigned int *w, unsigned int *h, unsigned int *ofs) +png_deinterlace_passes(fz_context *ctx, struct info *info, unsigned int *w, unsigned int *h, unsigned int *ofs) { int p, bpp = info->depth * info->n; ofs[0] = 0; @@ -180,7 +179,7 @@ png_deinterlace_passes(struct info *info, unsigned int *w, unsigned int *h, unsi } static void -png_deinterlace(struct info *info, unsigned int *passw, unsigned int *passh, unsigned int *passofs) +png_deinterlace(fz_context *ctx, struct info *info, unsigned int *passw, unsigned int *passh, unsigned int *passofs) { unsigned int n = info->n; unsigned int depth = info->depth; @@ -188,7 +187,7 @@ png_deinterlace(struct info *info, unsigned int *passw, unsigned int *passh, uns unsigned char *output; unsigned int p, x, y, k; - output = fz_malloc_array(info->ctx, info->height, stride); + output = fz_malloc_array(ctx, info->height, stride); for (p = 0; p < 7; p++) { @@ -214,17 +213,17 @@ png_deinterlace(struct info *info, unsigned int *passw, unsigned int *passh, uns } } - fz_free(info->ctx, info->samples); + fz_free(ctx, info->samples); info->samples = output; } static void -png_read_ihdr(struct info *info, unsigned char *p, unsigned int size) +png_read_ihdr(fz_context *ctx, struct info *info, unsigned char *p, unsigned int size) { int color, compression, filter; if (size != 13) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "IHDR chunk is the wrong size"); + fz_throw(ctx, FZ_ERROR_GENERIC, "IHDR chunk is the wrong size"); info->width = getuint(p + 0); info->height = getuint(p + 4); @@ -236,21 +235,21 @@ png_read_ihdr(struct info *info, unsigned char *p, unsigned int size) info->interlace = p[12]; if (info->width <= 0) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "image width must be > 0"); + fz_throw(ctx, FZ_ERROR_GENERIC, "image width must be > 0"); if (info->height <= 0) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "image height must be > 0"); + fz_throw(ctx, FZ_ERROR_GENERIC, "image height must be > 0"); if (info->depth != 1 && info->depth != 2 && info->depth != 4 && info->depth != 8 && info->depth != 16) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "image bit depth must be one of 1, 2, 4, 8, 16"); + fz_throw(ctx, FZ_ERROR_GENERIC, "image bit depth must be one of 1, 2, 4, 8, 16"); if (color == 2 && info->depth < 8) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "illegal bit depth for truecolor"); + fz_throw(ctx, FZ_ERROR_GENERIC, "illegal bit depth for truecolor"); if (color == 3 && info->depth > 8) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "illegal bit depth for indexed"); + fz_throw(ctx, FZ_ERROR_GENERIC, "illegal bit depth for indexed"); if (color == 4 && info->depth < 8) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "illegal bit depth for grayscale with alpha"); + fz_throw(ctx, FZ_ERROR_GENERIC, "illegal bit depth for grayscale with alpha"); if (color == 6 && info->depth < 8) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "illegal bit depth for truecolor with alpha"); + fz_throw(ctx, FZ_ERROR_GENERIC, "illegal bit depth for truecolor with alpha"); info->indexed = 0; if (color == 0) /* gray */ @@ -267,25 +266,25 @@ png_read_ihdr(struct info *info, unsigned char *p, unsigned int size) info->n = 1; } else - fz_throw(info->ctx, FZ_ERROR_GENERIC, "unknown color type"); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown color type"); if (compression != 0) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "unknown compression method"); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown compression method"); if (filter != 0) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "unknown filter method"); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown filter method"); if (info->interlace != 0 && info->interlace != 1) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "interlace method not supported"); + fz_throw(ctx, FZ_ERROR_GENERIC, "interlace method not supported"); } static void -png_read_plte(struct info *info, unsigned char *p, unsigned int size) +png_read_plte(fz_context *ctx, struct info *info, unsigned char *p, unsigned int size) { int n = size / 3; int i; if (n > 256) { - fz_warn(info->ctx, "too many samples in palette"); + fz_warn(ctx, "too many samples in palette"); n = 256; } @@ -306,7 +305,7 @@ png_read_plte(struct info *info, unsigned char *p, unsigned int size) } static void -png_read_trns(struct info *info, unsigned char *p, unsigned int size) +png_read_trns(fz_context *ctx, struct info *info, unsigned char *p, unsigned int size) { unsigned int i; @@ -316,7 +315,7 @@ png_read_trns(struct info *info, unsigned char *p, unsigned int size) { if (size > 256) { - fz_warn(info->ctx, "too many samples in transparency table"); + fz_warn(ctx, "too many samples in transparency table"); size = 256; } for (i = 0; i < size; i++) @@ -328,14 +327,14 @@ png_read_trns(struct info *info, unsigned char *p, unsigned int size) else { if (size != info->n * 2) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "tRNS chunk is the wrong size"); + fz_throw(ctx, FZ_ERROR_GENERIC, "tRNS chunk is the wrong size"); for (i = 0; i < info->n; i++) info->trns[i] = (p[i * 2] << 8 | p[i * 2 + 1]) & ((1 << info->depth) - 1); } } static void -png_read_idat(struct info *info, unsigned char *p, unsigned int size, z_stream *stm) +png_read_idat(fz_context *ctx, struct info *info, unsigned char *p, unsigned int size, z_stream *stm) { int code; @@ -344,20 +343,20 @@ png_read_idat(struct info *info, unsigned char *p, unsigned int size, z_stream * code = inflate(stm, Z_SYNC_FLUSH); if (code != Z_OK && code != Z_STREAM_END) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "zlib error: %s", stm->msg); + fz_throw(ctx, FZ_ERROR_GENERIC, "zlib error: %s", stm->msg); if (stm->avail_in != 0) { if (stm->avail_out == 0) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "ran out of output before input"); - fz_throw(info->ctx, FZ_ERROR_GENERIC, "inflate did not consume buffer (%d remaining)", stm->avail_in); + fz_throw(ctx, FZ_ERROR_GENERIC, "ran out of output before input"); + fz_throw(ctx, FZ_ERROR_GENERIC, "inflate did not consume buffer (%d remaining)", stm->avail_in); } } static void -png_read_phys(struct info *info, unsigned char *p, unsigned int size) +png_read_phys(fz_context *ctx, struct info *info, unsigned char *p, unsigned int size) { if (size != 9) - fz_throw(info->ctx, FZ_ERROR_GENERIC, "pHYs chunk is the wrong size"); + fz_throw(ctx, FZ_ERROR_GENERIC, "pHYs chunk is the wrong size"); if (p[8] == 1) { info->xres = (getuint(p) * 254 + 5000) / 10000; @@ -373,7 +372,6 @@ png_read_image(fz_context *ctx, struct info *info, unsigned char *p, unsigned in z_stream stm; memset(info, 0, sizeof (struct info)); - info->ctx = ctx; memset(info->palette, 255, sizeof(info->palette)); info->xres = 96; info->yres = 96; @@ -393,7 +391,7 @@ png_read_image(fz_context *ctx, struct info *info, unsigned char *p, unsigned in fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in png image"); if (!memcmp(p + 4, "IHDR", 4)) - png_read_ihdr(info, p + 8, size); + png_read_ihdr(ctx, info, p + 8, size); else fz_throw(ctx, FZ_ERROR_GENERIC, "png file must start with IHDR chunk"); @@ -408,7 +406,7 @@ png_read_image(fz_context *ctx, struct info *info, unsigned char *p, unsigned in } else { - png_deinterlace_passes(info, passw, passh, passofs); + png_deinterlace_passes(ctx, info, passw, passh, passofs); info->size = passofs[7]; } @@ -439,13 +437,13 @@ png_read_image(fz_context *ctx, struct info *info, unsigned char *p, unsigned in fz_throw(ctx, FZ_ERROR_GENERIC, "premature end of data in png image"); if (!memcmp(p + 4, "PLTE", 4)) - png_read_plte(info, p + 8, size); + png_read_plte(ctx, info, p + 8, size); if (!memcmp(p + 4, "tRNS", 4)) - png_read_trns(info, p + 8, size); + png_read_trns(ctx, info, p + 8, size); if (!memcmp(p + 4, "pHYs", 4)) - png_read_phys(info, p + 8, size); + png_read_phys(ctx, info, p + 8, size); if (!memcmp(p + 4, "IDAT", 4)) - png_read_idat(info, p + 8, size, &stm); + png_read_idat(ctx, info, p + 8, size, &stm); if (!memcmp(p + 4, "IEND", 4)) break; @@ -480,7 +478,7 @@ png_read_image(fz_context *ctx, struct info *info, unsigned char *p, unsigned in if (!info->interlace) png_predict(info->samples, info->width, info->height, info->n, info->depth); else - png_deinterlace(info, passw, passh, passofs); + png_deinterlace(ctx, info, passw, passh, passofs); } fz_catch(ctx) { @@ -513,7 +511,7 @@ png_expand_palette(fz_context *ctx, struct info *info, fz_pixmap *src) } } - fz_drop_pixmap(info->ctx, src); + fz_drop_pixmap(ctx, src); return dst; } @@ -564,14 +562,14 @@ fz_load_png(fz_context *ctx, unsigned char *p, int total) } fz_catch(ctx) { - fz_free(png.ctx, png.samples); + fz_free(ctx, png.samples); fz_rethrow_message(ctx, "out of memory loading png"); } image->xres = png.xres; image->yres = png.yres; - fz_unpack_tile(image, png.samples, png.n, png.depth, stride, png.indexed); + fz_unpack_tile(ctx, image, png.samples, png.n, png.depth, stride, png.indexed); if (png.indexed) image = png_expand_palette(ctx, &png, image); @@ -579,9 +577,9 @@ fz_load_png(fz_context *ctx, unsigned char *p, int total) png_mask_transparency(&png, image); if (png.transparency || png.n == 2 || png.n == 4) - fz_premultiply_pixmap(png.ctx, image); + fz_premultiply_pixmap(ctx, image); - fz_free(png.ctx, png.samples); + fz_free(ctx, png.samples); return image; } @@ -602,5 +600,5 @@ fz_load_png_info(fz_context *ctx, unsigned char *p, int total, int *wp, int *hp, *hp = png.height; *xresp = png.xres; *yresp = png.xres; - fz_free(png.ctx, png.samples); + fz_free(ctx, png.samples); } diff --git a/source/fitz/load-tiff.c b/source/fitz/load-tiff.c index 77fb816d..c783784a 100644 --- a/source/fitz/load-tiff.c +++ b/source/fitz/load-tiff.c @@ -11,8 +11,6 @@ struct tiff { - fz_context *ctx; - /* "file" */ unsigned char *bp, *rp, *ep; @@ -142,63 +140,63 @@ static const unsigned char bitrev[256] = }; static void -fz_decode_tiff_uncompressed(struct tiff *tiff, fz_stream *stm, unsigned char *wp, int wlen) +fz_decode_tiff_uncompressed(fz_context *ctx, struct tiff *tiff, fz_stream *stm, unsigned char *wp, int wlen) { - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static void -fz_decode_tiff_packbits(struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) +fz_decode_tiff_packbits(fz_context *ctx, struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) { - fz_stream *stm = fz_open_rld(chain); - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + fz_stream *stm = fz_open_rld(ctx, chain); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static void -fz_decode_tiff_lzw(struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) +fz_decode_tiff_lzw(fz_context *ctx, struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) { - fz_stream *stm = fz_open_lzwd(chain, 1); - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + fz_stream *stm = fz_open_lzwd(ctx, chain, 1); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static void -fz_decode_tiff_flate(struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) +fz_decode_tiff_flate(fz_context *ctx, struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) { - fz_stream *stm = fz_open_flated(chain, 15); - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + fz_stream *stm = fz_open_flated(ctx, chain, 15); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static void -fz_decode_tiff_fax(struct tiff *tiff, int comp, fz_stream *chain, unsigned char *wp, int wlen) +fz_decode_tiff_fax(fz_context *ctx, struct tiff *tiff, int comp, fz_stream *chain, unsigned char *wp, int wlen) { fz_stream *stm; int black_is_1 = tiff->photometric == 0; int k = comp == 4 ? -1 : 0; int encoded_byte_align = comp == 2; - stm = fz_open_faxd(chain, + stm = fz_open_faxd(ctx, chain, k, 0, encoded_byte_align, tiff->imagewidth, tiff->imagelength, 0, black_is_1); - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static void -fz_decode_tiff_jpeg(struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) +fz_decode_tiff_jpeg(fz_context *ctx, struct tiff *tiff, fz_stream *chain, unsigned char *wp, int wlen) { fz_stream *stm; fz_stream *jpegtables = NULL; int color_transform = -1; /* unset */ if (tiff->jpegtables && (int)tiff->jpegtableslen > 0) - jpegtables = fz_open_memory(tiff->ctx, tiff->jpegtables, (int)tiff->jpegtableslen); + jpegtables = fz_open_memory(ctx, tiff->jpegtables, (int)tiff->jpegtableslen); if (tiff->photometric == 2 /* RGB */ || tiff->photometric == 3 /* RGBPal */) color_transform = 0; - stm = fz_open_dctd(chain, color_transform, 0, jpegtables); - fz_read(stm, wp, wlen); - fz_drop_stream(stm); + stm = fz_open_dctd(ctx, chain, color_transform, 0, jpegtables); + fz_read(ctx, stm, wp, wlen); + fz_drop_stream(ctx, stm); } static inline int getcomp(unsigned char *line, int x, int bpc) @@ -276,7 +274,7 @@ fz_invert_tiff(unsigned char *line, int width, int comps, int bits, int alpha) } static void -fz_expand_tiff_colormap(struct tiff *tiff) +fz_expand_tiff_colormap(fz_context *ctx, struct tiff *tiff) { int maxval = 1 << tiff->bitspersample; unsigned char *samples; @@ -289,17 +287,17 @@ fz_expand_tiff_colormap(struct tiff *tiff) /* image can be with or without extrasamples: comps is 1 or 2 */ if (tiff->samplesperpixel != 1 && tiff->samplesperpixel != 2) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "invalid number of samples for RGBPal"); + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of samples for RGBPal"); if (tiff->bitspersample != 1 && tiff->bitspersample != 4 && tiff->bitspersample != 8) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "invalid number of bits for RGBPal"); + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of bits for RGBPal"); if (tiff->colormaplen < (unsigned)maxval * 3) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "insufficient colormap data"); + fz_throw(ctx, FZ_ERROR_GENERIC, "insufficient colormap data"); stride = tiff->imagewidth * (tiff->samplesperpixel + 2); - samples = fz_malloc(tiff->ctx, stride * tiff->imagelength); + samples = fz_malloc(ctx, stride * tiff->imagelength); for (y = 0; y < tiff->imagelength; y++) { @@ -330,12 +328,12 @@ fz_expand_tiff_colormap(struct tiff *tiff) tiff->samplesperpixel += 2; tiff->bitspersample = 8; tiff->stride = stride; - fz_free(tiff->ctx, tiff->samples); + fz_free(ctx, tiff->samples); tiff->samples = samples; } static void -fz_decode_tiff_strips(struct tiff *tiff) +fz_decode_tiff_strips(fz_context *ctx, struct tiff *tiff) { fz_stream *stm; @@ -354,40 +352,40 @@ fz_decode_tiff_strips(struct tiff *tiff) unsigned i; if (!tiff->rowsperstrip || !tiff->stripoffsets || !tiff->stripbytecounts) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "no image data in tiff; maybe it is tiled"); + fz_throw(ctx, FZ_ERROR_GENERIC, "no image data in tiff; maybe it is tiled"); if (tiff->stripoffsetslen < (tiff->imagelength - 1) / tiff->rowsperstrip + 1 || tiff->stripbytecountslen < (tiff->imagelength - 1) / tiff->rowsperstrip + 1) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "insufficient strip offset data"); + fz_throw(ctx, FZ_ERROR_GENERIC, "insufficient strip offset data"); if (tiff->planar != 1) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "image data is not in chunky format"); + fz_throw(ctx, FZ_ERROR_GENERIC, "image data is not in chunky format"); tiff->stride = (tiff->imagewidth * tiff->samplesperpixel * tiff->bitspersample + 7) / 8; switch (tiff->photometric) { case 0: /* WhiteIsZero -- inverted */ - tiff->colorspace = fz_device_gray(tiff->ctx); + tiff->colorspace = fz_device_gray(ctx); break; case 1: /* BlackIsZero */ - tiff->colorspace = fz_device_gray(tiff->ctx); + tiff->colorspace = fz_device_gray(ctx); break; case 2: /* RGB */ - tiff->colorspace = fz_device_rgb(tiff->ctx); + tiff->colorspace = fz_device_rgb(ctx); break; case 3: /* RGBPal */ - tiff->colorspace = fz_device_rgb(tiff->ctx); + tiff->colorspace = fz_device_rgb(ctx); break; case 5: /* CMYK */ - tiff->colorspace = fz_device_cmyk(tiff->ctx); + tiff->colorspace = fz_device_cmyk(ctx); break; case 6: /* YCbCr */ /* it's probably a jpeg ... we let jpeg convert to rgb */ - tiff->colorspace = fz_device_rgb(tiff->ctx); + tiff->colorspace = fz_device_rgb(ctx); break; default: - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "unknown photometric: %d", tiff->photometric); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown photometric: %d", tiff->photometric); } switch (tiff->resolutionunit) @@ -412,7 +410,7 @@ fz_decode_tiff_strips(struct tiff *tiff) tiff->yresolution = 96; } - tiff->samples = fz_malloc_array(tiff->ctx, tiff->imagelength, tiff->stride); + tiff->samples = fz_malloc_array(ctx, tiff->imagelength, tiff->stride); memset(tiff->samples, 0x55, tiff->imagelength * tiff->stride); wp = tiff->samples; @@ -428,7 +426,7 @@ fz_decode_tiff_strips(struct tiff *tiff) wlen = tiff->samples + (unsigned int)(tiff->stride * tiff->imagelength) - wp; if (rp + rlen > tiff->ep) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "strip extends beyond the end of the file"); + fz_throw(ctx, FZ_ERROR_GENERIC, "strip extends beyond the end of the file"); /* the bits are in un-natural order */ if (tiff->fillorder == 2) @@ -436,39 +434,39 @@ fz_decode_tiff_strips(struct tiff *tiff) rp[i] = bitrev[rp[i]]; /* the strip decoders will close this */ - stm = fz_open_memory(tiff->ctx, rp, rlen); + stm = fz_open_memory(ctx, rp, rlen); switch (tiff->compression) { case 1: - fz_decode_tiff_uncompressed(tiff, stm, wp, wlen); + fz_decode_tiff_uncompressed(ctx, tiff, stm, wp, wlen); break; case 2: - fz_decode_tiff_fax(tiff, 2, stm, wp, wlen); + fz_decode_tiff_fax(ctx, tiff, 2, stm, wp, wlen); break; case 3: - fz_decode_tiff_fax(tiff, 3, stm, wp, wlen); + fz_decode_tiff_fax(ctx, tiff, 3, stm, wp, wlen); break; case 4: - fz_decode_tiff_fax(tiff, 4, stm, wp, wlen); + fz_decode_tiff_fax(ctx, tiff, 4, stm, wp, wlen); break; case 5: - fz_decode_tiff_lzw(tiff, stm, wp, wlen); + fz_decode_tiff_lzw(ctx, tiff, stm, wp, wlen); break; case 6: - fz_warn(tiff->ctx, "deprecated JPEG in TIFF compression not fully supported"); + fz_warn(ctx, "deprecated JPEG in TIFF compression not fully supported"); /* fall through */ case 7: - fz_decode_tiff_jpeg(tiff, stm, wp, wlen); + fz_decode_tiff_jpeg(ctx, tiff, stm, wp, wlen); break; case 8: - fz_decode_tiff_flate(tiff, stm, wp, wlen); + fz_decode_tiff_flate(ctx, tiff, stm, wp, wlen); break; case 32773: - fz_decode_tiff_packbits(tiff, stm, wp, wlen); + fz_decode_tiff_packbits(ctx, tiff, stm, wp, wlen); break; default: - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "unknown TIFF compression: %d", tiff->compression); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown TIFF compression: %d", tiff->compression); } /* scramble the bits back into original order */ @@ -493,7 +491,7 @@ fz_decode_tiff_strips(struct tiff *tiff) /* RGBPal */ if (tiff->photometric == 3 && tiff->colormap) - fz_expand_tiff_colormap(tiff); + fz_expand_tiff_colormap(ctx, tiff); /* WhiteIsZero .. invert */ if (tiff->photometric == 0) @@ -584,7 +582,7 @@ fz_read_tiff_tag_value(unsigned *p, struct tiff *tiff, unsigned type, unsigned o } static void -fz_read_tiff_tag(struct tiff *tiff, unsigned offset) +fz_read_tiff_tag(fz_context *ctx, struct tiff *tiff, unsigned offset) { unsigned tag; unsigned type; @@ -662,7 +660,7 @@ fz_read_tiff_tag(struct tiff *tiff, unsigned offset) break; case ICCProfile: - tiff->profile = fz_malloc(tiff->ctx, count); + tiff->profile = fz_malloc(ctx, count); /* ICC profile data type is set to UNDEFINED. * TBYTE reading not correct in fz_read_tiff_tag_value */ fz_read_tiff_bytes(tiff->profile, tiff, value, count); @@ -675,19 +673,19 @@ fz_read_tiff_tag(struct tiff *tiff, unsigned offset) break; case StripOffsets: - tiff->stripoffsets = fz_malloc_array(tiff->ctx, count, sizeof(unsigned)); + tiff->stripoffsets = fz_malloc_array(ctx, count, sizeof(unsigned)); fz_read_tiff_tag_value(tiff->stripoffsets, tiff, type, value, count); tiff->stripoffsetslen = count; break; case StripByteCounts: - tiff->stripbytecounts = fz_malloc_array(tiff->ctx, count, sizeof(unsigned)); + tiff->stripbytecounts = fz_malloc_array(ctx, count, sizeof(unsigned)); fz_read_tiff_tag_value(tiff->stripbytecounts, tiff, type, value, count); tiff->stripbytecountslen = count; break; case ColorMap: - tiff->colormap = fz_malloc_array(tiff->ctx, count, sizeof(unsigned)); + tiff->colormap = fz_malloc_array(ctx, count, sizeof(unsigned)); fz_read_tiff_tag_value(tiff->colormap, tiff, type, value, count); tiff->colormaplen = count; break; @@ -696,10 +694,10 @@ fz_read_tiff_tag(struct tiff *tiff, unsigned offset) case TileLength: case TileOffsets: case TileByteCounts: - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "tiled tiffs not supported"); + fz_throw(ctx, FZ_ERROR_GENERIC, "tiled tiffs not supported"); default: - /* fz_warn(tiff->ctx, "unknown tag: %d t=%d n=%d", tag, type, count); */ + /* fz_warn(ctx, "unknown tag: %d t=%d n=%d", tag, type, count); */ break; } } @@ -722,7 +720,6 @@ fz_decode_tiff_header(fz_context *ctx, struct tiff *tiff, unsigned char *buf, in unsigned version; memset(tiff, 0, sizeof(struct tiff)); - tiff->ctx = ctx; tiff->bp = buf; tiff->rp = buf; tiff->ep = buf + len; @@ -748,12 +745,12 @@ fz_decode_tiff_header(fz_context *ctx, struct tiff *tiff, unsigned char *buf, in tiff->order = TII; tiff->order = readshort(tiff); if (tiff->order != TII && tiff->order != TMM) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "not a TIFF file, wrong magic marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "not a TIFF file, wrong magic marker"); /* check version */ version = readshort(tiff); if (version != 42) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "not a TIFF file, wrong version marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "not a TIFF file, wrong version marker"); /* get offset of IFD */ tiff->ifd_offset = readlong(tiff); @@ -767,12 +764,12 @@ fz_next_ifd(fz_context *ctx, struct tiff *tiff, unsigned offset) tiff->rp = tiff->bp + offset; if (tiff->rp <= tiff->bp || tiff->rp > tiff->ep) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "invalid IFD offset %u", offset); + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid IFD offset %u", offset); count = readshort(tiff); if (count * 12 > (unsigned)(tiff->ep - tiff->rp)) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "overlarge IFD entry count %u", count); + fz_throw(ctx, FZ_ERROR_GENERIC, "overlarge IFD entry count %u", count); tiff->rp += count * 12; offset = readlong(tiff); @@ -790,13 +787,13 @@ fz_seek_ifd(fz_context *ctx, struct tiff *tiff, int subimage) offset = fz_next_ifd(ctx, tiff, offset); if (offset == 0) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "subimage index %i out of range", subimage); + fz_throw(ctx, FZ_ERROR_GENERIC, "subimage index %i out of range", subimage); } tiff->rp = tiff->bp + offset; if (tiff->rp < tiff->bp || tiff->rp > tiff->ep) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "invalid IFD offset %u", tiff->ifd_offset); + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid IFD offset %u", tiff->ifd_offset); } static void @@ -811,12 +808,12 @@ fz_decode_tiff_ifd(fz_context *ctx, struct tiff *tiff) count = readshort(tiff); if (count * 12 > (unsigned)(tiff->ep - tiff->rp)) - fz_throw(tiff->ctx, FZ_ERROR_GENERIC, "overlarge IFD entry count %u", count); + fz_throw(ctx, FZ_ERROR_GENERIC, "overlarge IFD entry count %u", count); offset += 2; for (i = 0; i < count; i++) { - fz_read_tiff_tag(tiff, offset); + fz_read_tiff_tag(ctx, tiff, offset); offset += 12; } } @@ -838,7 +835,7 @@ fz_load_tiff_subimage(fz_context *ctx, unsigned char *buf, int len, int subimage if (tiff.rowsperstrip > tiff.imagelength) tiff.rowsperstrip = tiff.imagelength; - fz_decode_tiff_strips(&tiff); + fz_decode_tiff_strips(ctx, &tiff); /* Byte swap 16-bit images to big endian if necessary */ if (tiff.bitspersample == 16) @@ -846,11 +843,11 @@ fz_load_tiff_subimage(fz_context *ctx, unsigned char *buf, int len, int subimage fz_swap_tiff_byte_order(tiff.samples, tiff.imagewidth * tiff.imagelength * tiff.samplesperpixel); /* Expand into fz_pixmap struct */ - image = fz_new_pixmap(tiff.ctx, tiff.colorspace, tiff.imagewidth, tiff.imagelength); + image = fz_new_pixmap(ctx, tiff.colorspace, tiff.imagewidth, tiff.imagelength); image->xres = tiff.xresolution; image->yres = tiff.yresolution; - fz_unpack_tile(image, tiff.samples, tiff.samplesperpixel, tiff.bitspersample, tiff.stride, 0); + fz_unpack_tile(ctx, image, tiff.samples, tiff.samplesperpixel, tiff.bitspersample, tiff.stride, 0); /* We should only do this on non-pre-multiplied images, but files in the wild are bad */ if (tiff.extrasamples /* == 2 */) @@ -858,8 +855,8 @@ fz_load_tiff_subimage(fz_context *ctx, unsigned char *buf, int len, int subimage /* CMYK is a subtractive colorspace, we want additive for premul alpha */ if (image->n == 5) { - fz_pixmap *rgb = fz_new_pixmap(tiff.ctx, fz_device_rgb(ctx), image->w, image->h); - fz_convert_pixmap(tiff.ctx, rgb, image); + fz_pixmap *rgb = fz_new_pixmap(ctx, fz_device_rgb(ctx), image->w, image->h); + fz_convert_pixmap(ctx, rgb, image); rgb->xres = image->xres; rgb->yres = image->yres; fz_drop_pixmap(ctx, image); diff --git a/source/fitz/outline.c b/source/fitz/outline.c index 7a019883..07a27001 100644 --- a/source/fitz/outline.c +++ b/source/fitz/outline.c @@ -15,20 +15,20 @@ fz_drop_outline(fz_context *ctx, fz_outline *outline) } static void -do_debug_outline_xml(fz_output *out, fz_outline *outline, int level) +fz_debug_outline_xml_imp(fz_context *ctx, fz_output *out, fz_outline *outline, int level) { while (outline) { - fz_printf(out, "<outline title=\"%s\" page=\"%d\"", outline->title, outline->dest.kind == FZ_LINK_GOTO ? outline->dest.ld.gotor.page + 1 : 0); + fz_printf(ctx, out, "<outline title=\"%s\" page=\"%d\"", outline->title, outline->dest.kind == FZ_LINK_GOTO ? outline->dest.ld.gotor.page + 1 : 0); if (outline->down) { - fz_printf(out, ">\n"); - do_debug_outline_xml(out, outline->down, level + 1); - fz_printf(out, "</outline>\n"); + fz_printf(ctx, out, ">\n"); + fz_debug_outline_xml_imp(ctx, out, outline->down, level + 1); + fz_printf(ctx, out, "</outline>\n"); } else { - fz_printf(out, " />\n"); + fz_printf(ctx, out, " />\n"); } outline = outline->next; } @@ -37,20 +37,20 @@ do_debug_outline_xml(fz_output *out, fz_outline *outline, int level) void fz_print_outline_xml(fz_context *ctx, fz_output *out, fz_outline *outline) { - do_debug_outline_xml(out, outline, 0); + fz_debug_outline_xml_imp(ctx, out, outline, 0); } static void -do_debug_outline(fz_output *out, fz_outline *outline, int level) +fz_print_outline_imp(fz_context *ctx, fz_output *out, fz_outline *outline, int level) { int i; while (outline) { for (i = 0; i < level; i++) - fz_printf(out, "\t"); - fz_printf(out, "%s\t%d\n", outline->title, outline->dest.kind == FZ_LINK_GOTO ? outline->dest.ld.gotor.page + 1 : 0); + fz_printf(ctx, out, "\t"); + fz_printf(ctx, out, "%s\t%d\n", outline->title, outline->dest.kind == FZ_LINK_GOTO ? outline->dest.ld.gotor.page + 1 : 0); if (outline->down) - do_debug_outline(out, outline->down, level + 1); + fz_print_outline_imp(ctx, out, outline->down, level + 1); outline = outline->next; } } @@ -58,5 +58,5 @@ do_debug_outline(fz_output *out, fz_outline *outline, int level) void fz_print_outline(fz_context *ctx, fz_output *out, fz_outline *outline) { - do_debug_outline(out, outline, 0); + fz_print_outline_imp(ctx, out, outline, 0); } diff --git a/source/fitz/output-pcl.c b/source/fitz/output-pcl.c index 90695eb7..a6dcc23b 100644 --- a/source/fitz/output-pcl.c +++ b/source/fitz/output-pcl.c @@ -302,7 +302,7 @@ make_init(fz_pcl_options *pcl, char *buf, unsigned long len, const char *str, in } static void -pcl_header(fz_output *out, fz_pcl_options *pcl, int num_copies, int xres) +pcl_header(fz_context *ctx, fz_output *out, fz_pcl_options *pcl, int num_copies, int xres) { char odd_page_init[80]; char even_page_init[80]; @@ -313,12 +313,12 @@ pcl_header(fz_output *out, fz_pcl_options *pcl, int num_copies, int xres) if (pcl->page_count == 0) { if (pcl->features & HACK__IS_A_LJET4PJL) - fz_puts(out, "\033%-12345X@PJL\r\n@PJL ENTER LANGUAGE = PCL\r\n"); - fz_puts(out, "\033E"); /* reset printer */ + fz_puts(ctx, out, "\033%-12345X@PJL\r\n@PJL ENTER LANGUAGE = PCL\r\n"); + fz_puts(ctx, out, "\033E"); /* reset printer */ /* If the printer supports it, set the paper size */ /* based on the actual requested size. */ if (pcl->features & PCL_CAN_SET_PAPER_SIZE) - fz_printf(out, "\033&l%dA", pcl->paper_size); + fz_printf(ctx, out, "\033&l%dA", pcl->paper_size); /* If printer can duplex, set duplex mode appropriately. */ if (pcl->features & PCL_HAS_DUPLEX) { @@ -327,17 +327,17 @@ pcl_header(fz_output *out, fz_pcl_options *pcl, int num_copies, int xres) if (pcl->duplex) { if (!pcl->tumble) - fz_puts(out, "\033&l1S"); + fz_puts(ctx, out, "\033&l1S"); else - fz_puts(out, "\033&l2S"); + fz_puts(ctx, out, "\033&l2S"); } else - fz_puts(out, "\033&l0S"); + fz_puts(ctx, out, "\033&l0S"); } else { /* default to duplex for this printer */ - fz_puts(out, "\033&l1S"); + fz_puts(ctx, out, "\033&l1S"); } } } @@ -360,58 +360,55 @@ pcl_header(fz_output *out, fz_pcl_options *pcl, int num_copies, int xres) { if (pcl->page_count != 0 && (pcl->features & PCL_CAN_SET_PAPER_SIZE)) { - fz_printf(out, "\033&l%dA", pcl->paper_size); + fz_printf(ctx, out, "\033&l%dA", pcl->paper_size); } - fz_puts(out, "\033&l0o0l0E"); - fz_puts(out, pcl->odd_page_init); + fz_puts(ctx, out, "\033&l0o0l0E"); + fz_puts(ctx, out, pcl->odd_page_init); } else - fz_puts(out, pcl->even_page_init); + fz_puts(ctx, out, pcl->even_page_init); } else { if (pcl->features & PCL_CAN_SET_PAPER_SIZE) { - fz_printf(out, "\033&l%dA", pcl->paper_size); + fz_printf(ctx, out, "\033&l%dA", pcl->paper_size); } - fz_puts(out, "\033&l0o0l0E"); - fz_puts(out, pcl->odd_page_init); + fz_puts(ctx, out, "\033&l0o0l0E"); + fz_puts(ctx, out, pcl->odd_page_init); } - fz_printf(out, "\033&l%dX", num_copies); /* # of copies */ + fz_printf(ctx, out, "\033&l%dX", num_copies); /* # of copies */ /* End raster graphics, position cursor at top. */ - fz_puts(out, "\033*rB\033*p0x0Y"); + fz_puts(ctx, out, "\033*rB\033*p0x0Y"); /* The DeskJet and DeskJet Plus reset everything upon */ /* receiving \033*rB, so we must reinitialize graphics mode. */ if (pcl->features & PCL_END_GRAPHICS_DOES_RESET) { - fz_puts(out, pcl->odd_page_init); /* Assume this does the right thing */ - fz_printf(out, "\033&l%dX", num_copies); /* # of copies */ + fz_puts(ctx, out, pcl->odd_page_init); /* Assume this does the right thing */ + fz_printf(ctx, out, "\033&l%dX", num_copies); /* # of copies */ } /* Set resolution. */ - fz_printf(out, "\033*t%dR", xres); + fz_printf(ctx, out, "\033*t%dR", xres); pcl->page_count++; } void -fz_output_pcl(fz_output *out, const fz_pixmap *pixmap, fz_pcl_options *pcl) +fz_output_pcl(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, fz_pcl_options *pcl) { //unsigned char *sp; //int y, x, sn, dn, ss; - fz_context *ctx; if (!out || !pixmap) return; - ctx = out->ctx; - if (pixmap->n != 1 && pixmap->n != 2 && pixmap->n != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale or rgb to write as pcl"); - pcl_header(out, pcl, 1, pixmap->xres); + pcl_header(ctx, out, pcl, 1, pixmap->xres); #if 0 sn = pixmap->n; @@ -464,7 +461,7 @@ fz_output_pcl(fz_output *out, const fz_pixmap *pixmap, fz_pcl_options *pcl) break; } fz_write_byte(out, xrep-1); - fz_write(out, sp, dn); + fz_write(ctx, out, sp, dn); sp += sn*xrep; x += xrep; } @@ -474,7 +471,7 @@ fz_output_pcl(fz_output *out, const fz_pixmap *pixmap, fz_pcl_options *pcl) x += d; while (d > 0) { - fz_write(out, sp, dn); + fz_write(ctx, out, sp, dn); sp += sn; d--; } @@ -593,11 +590,10 @@ void wind(void) {} void -fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pcl) +fz_output_pcl_bitmap(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pcl) { unsigned char *data, *out_data; int y, ss, rmask, line_size; - fz_context *ctx; int num_blank_lines; int compression = -1; unsigned char *prev_row = NULL; @@ -610,15 +606,13 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc if (!out || !bitmap) return; - ctx = out->ctx; - if (pcl->features & HACK__IS_A_OCE9050) { /* Enter HPGL/2 mode, begin plot, Initialise (start plot), Enter PCL mode */ - fz_puts(out, "\033%1BBPIN;\033%1A"); + fz_puts(ctx, out, "\033%1BBPIN;\033%1A"); } - pcl_header(out, pcl, 1, bitmap->xres); + pcl_header(ctx, out, pcl, 1, bitmap->xres); fz_var(prev_row); fz_var(out_row_mode_2); @@ -663,23 +657,23 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc if (pcl->features & PCL_ANY_SPACING) { if (num_blank_lines > 0) - fz_printf(out, "\033*p+%dY", num_blank_lines * bitmap->yres); + fz_printf(ctx, out, "\033*p+%dY", num_blank_lines * bitmap->yres); /* Start raster graphics. */ - fz_puts(out, "\033*r1A"); + fz_puts(ctx, out, "\033*r1A"); } else if (pcl->features & PCL_MODE_3_COMPRESSION) { /* Start raster graphics. */ - fz_puts(out, "\033*r1A"); + fz_puts(ctx, out, "\033*r1A"); for (; num_blank_lines; num_blank_lines--) - fz_puts(out, "\033*b0W"); + fz_puts(ctx, out, "\033*b0W"); } else { /* Start raster graphics. */ - fz_puts(out, "\033*r1A"); + fz_puts(ctx, out, "\033*r1A"); for (; num_blank_lines; num_blank_lines--) - fz_puts(out, "\033*bW"); + fz_puts(ctx, out, "\033*bW"); } } @@ -701,30 +695,30 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc if (mode_3ns && compression != 2) { /* Switch to mode 2 */ - fz_puts(out, from3to2); + fz_puts(ctx, out, from3to2); compression = 2; } if (pcl->features & PCL_MODE_3_COMPRESSION) { /* Must clear the seed row. */ - fz_puts(out, "\033*b1Y"); + fz_puts(ctx, out, "\033*b1Y"); num_blank_lines--; } if (mode_3ns) { for (; num_blank_lines; num_blank_lines--) - fz_puts(out, "\033*b0W"); + fz_puts(ctx, out, "\033*b0W"); } else { for (; num_blank_lines; num_blank_lines--) - fz_puts(out, "\033*bW"); + fz_puts(ctx, out, "\033*bW"); } } else if (pcl->features & PCL3_SPACING) - fz_printf(out, "\033*p+%dY", num_blank_lines * bitmap->yres); + fz_printf(ctx, out, "\033*p+%dY", num_blank_lines * bitmap->yres); else - fz_printf(out, "\033*b%dY", num_blank_lines); + fz_printf(ctx, out, "\033*b%dY", num_blank_lines); /* Clear the seed row (only matters for mode 3 compression). */ memset(prev_row, 0, line_size); } @@ -744,7 +738,7 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc if (count3 + penalty3 < count2 + penalty2) { if (compression != 3) - fz_puts(out, from2to3); + fz_puts(ctx, out, from2to3); compression = 3; out_data = (unsigned char *)out_row_mode_3; out_count = count3; @@ -752,7 +746,7 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc else { if (compression != 2) - fz_puts(out, from3to2); + fz_puts(ctx, out, from3to2); compression = 2; out_data = (unsigned char *)out_row_mode_2; out_count = count2; @@ -770,17 +764,17 @@ fz_output_pcl_bitmap(fz_output *out, const fz_bitmap *bitmap, fz_pcl_options *pc } /* Transfer the data */ - fz_printf(out, "\033*b%dW", out_count); - fz_write(out, out_data, out_count); + fz_printf(ctx, out, "\033*b%dW", out_count); + fz_write(ctx, out, out_data, out_count); } /* end raster graphics and eject page */ - fz_puts(out, "\033*rB\f"); + fz_puts(ctx, out, "\033*rB\f"); if (pcl->features & HACK__IS_A_OCE9050) { /* Pen up, pen select, advance full page, reset */ - fz_puts(out, "\033%1BPUSP0PG;\033E"); + fz_puts(ctx, out, "\033%1BPUSP0PG;\033E"); } } fz_always(ctx) @@ -811,13 +805,12 @@ fz_write_pcl(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, fz_ fz_try(ctx) { - out = fz_new_output_with_file(ctx, fp); - fz_output_pcl(out, pixmap, pcl); + out = fz_new_output_with_file(ctx, fp, 1); + fz_output_pcl(ctx, out, pixmap, pcl); } fz_always(ctx) { - fz_drop_output(out); - fclose(fp); + fz_drop_output(ctx, out); } fz_catch(ctx) { @@ -841,13 +834,12 @@ fz_write_pcl_bitmap(fz_context *ctx, fz_bitmap *bitmap, char *filename, int appe fz_try(ctx) { - out = fz_new_output_with_file(ctx, fp); - fz_output_pcl_bitmap(out, bitmap, pcl); + out = fz_new_output_with_file(ctx, fp, 1); + fz_output_pcl_bitmap(ctx, out, bitmap, pcl); } fz_always(ctx) { - fz_drop_output(out); - fclose(fp); + fz_drop_output(ctx, out); } fz_catch(ctx) { diff --git a/source/fitz/output-pwg.c b/source/fitz/output-pwg.c index a2107db6..4af67c25 100644 --- a/source/fitz/output-pwg.c +++ b/source/fitz/output-pwg.c @@ -1,103 +1,100 @@ #include "mupdf/fitz.h" void -fz_output_pwg_file_header(fz_output *out) +fz_output_pwg_file_header(fz_context *ctx, fz_output *out) { static const unsigned char pwgsig[4] = { 'R', 'a', 'S', '2' }; /* Sync word */ - fz_write(out, pwgsig, 4); + fz_write(ctx, out, pwgsig, 4); } static void -output_header(fz_output *out, const fz_pwg_options *pwg, int xres, int yres, int w, int h, int bpp) +output_header(fz_context *ctx, fz_output *out, const fz_pwg_options *pwg, int xres, int yres, int w, int h, int bpp) { static const char zero[64] = { 0 }; int i; /* Page Header: */ - fz_write(out, pwg ? pwg->media_class : zero, 64); - fz_write(out, pwg ? pwg->media_color : zero, 64); - fz_write(out, pwg ? pwg->media_type : zero, 64); - fz_write(out, pwg ? pwg->output_type : zero, 64); - fz_write_int32be(out, pwg ? pwg->advance_distance : 0); - fz_write_int32be(out, pwg ? pwg->advance_media : 0); - fz_write_int32be(out, pwg ? pwg->collate : 0); - fz_write_int32be(out, pwg ? pwg->cut_media : 0); - fz_write_int32be(out, pwg ? pwg->duplex : 0); - fz_write_int32be(out, xres); - fz_write_int32be(out, yres); + fz_write(ctx, out, pwg ? pwg->media_class : zero, 64); + fz_write(ctx, out, pwg ? pwg->media_color : zero, 64); + fz_write(ctx, out, pwg ? pwg->media_type : zero, 64); + fz_write(ctx, out, pwg ? pwg->output_type : zero, 64); + fz_write_int32be(ctx, out, pwg ? pwg->advance_distance : 0); + fz_write_int32be(ctx, out, pwg ? pwg->advance_media : 0); + fz_write_int32be(ctx, out, pwg ? pwg->collate : 0); + fz_write_int32be(ctx, out, pwg ? pwg->cut_media : 0); + fz_write_int32be(ctx, out, pwg ? pwg->duplex : 0); + fz_write_int32be(ctx, out, xres); + fz_write_int32be(ctx, out, yres); /* CUPS format says that 284->300 are supposed to be the bbox of the * page in points. PWG says 'Reserved'. */ for (i=284; i < 300; i += 4) - fz_write(out, zero, 4); - fz_write_int32be(out, pwg ? pwg->insert_sheet : 0); - fz_write_int32be(out, pwg ? pwg->jog : 0); - fz_write_int32be(out, pwg ? pwg->leading_edge : 0); + fz_write(ctx, out, zero, 4); + fz_write_int32be(ctx, out, pwg ? pwg->insert_sheet : 0); + fz_write_int32be(ctx, out, pwg ? pwg->jog : 0); + fz_write_int32be(ctx, out, pwg ? pwg->leading_edge : 0); /* CUPS format says that 312->320 are supposed to be the margins of * the lower left hand edge of page in points. PWG says 'Reserved'. */ for (i=312; i < 320; i += 4) - fz_write(out, zero, 4); - fz_write_int32be(out, pwg ? pwg->manual_feed : 0); - fz_write_int32be(out, pwg ? pwg->media_position : 0); - fz_write_int32be(out, pwg ? pwg->media_weight : 0); - fz_write_int32be(out, pwg ? pwg->mirror_print : 0); - fz_write_int32be(out, pwg ? pwg->negative_print : 0); - fz_write_int32be(out, pwg ? pwg->num_copies : 0); - fz_write_int32be(out, pwg ? pwg->orientation : 0); - fz_write_int32be(out, pwg ? pwg->output_face_up : 0); - fz_write_int32be(out, w * 72/ xres); /* Page size in points */ - fz_write_int32be(out, h * 72/ yres); - fz_write_int32be(out, pwg ? pwg->separations : 0); - fz_write_int32be(out, pwg ? pwg->tray_switch : 0); - fz_write_int32be(out, pwg ? pwg->tumble : 0); - fz_write_int32be(out, w); /* Page image in pixels */ - fz_write_int32be(out, h); - fz_write_int32be(out, pwg ? pwg->media_type_num : 0); - fz_write_int32be(out, bpp < 8 ? 1 : 8); /* Bits per color */ - fz_write_int32be(out, bpp); /* Bits per pixel */ - fz_write_int32be(out, (w * bpp + 7)/8); /* Bytes per line */ - fz_write_int32be(out, 0); /* Chunky pixels */ + fz_write(ctx, out, zero, 4); + fz_write_int32be(ctx, out, pwg ? pwg->manual_feed : 0); + fz_write_int32be(ctx, out, pwg ? pwg->media_position : 0); + fz_write_int32be(ctx, out, pwg ? pwg->media_weight : 0); + fz_write_int32be(ctx, out, pwg ? pwg->mirror_print : 0); + fz_write_int32be(ctx, out, pwg ? pwg->negative_print : 0); + fz_write_int32be(ctx, out, pwg ? pwg->num_copies : 0); + fz_write_int32be(ctx, out, pwg ? pwg->orientation : 0); + fz_write_int32be(ctx, out, pwg ? pwg->output_face_up : 0); + fz_write_int32be(ctx, out, w * 72/ xres); /* Page size in points */ + fz_write_int32be(ctx, out, h * 72/ yres); + fz_write_int32be(ctx, out, pwg ? pwg->separations : 0); + fz_write_int32be(ctx, out, pwg ? pwg->tray_switch : 0); + fz_write_int32be(ctx, out, pwg ? pwg->tumble : 0); + fz_write_int32be(ctx, out, w); /* Page image in pixels */ + fz_write_int32be(ctx, out, h); + fz_write_int32be(ctx, out, pwg ? pwg->media_type_num : 0); + fz_write_int32be(ctx, out, bpp < 8 ? 1 : 8); /* Bits per color */ + fz_write_int32be(ctx, out, bpp); /* Bits per pixel */ + fz_write_int32be(ctx, out, (w * bpp + 7)/8); /* Bytes per line */ + fz_write_int32be(ctx, out, 0); /* Chunky pixels */ switch (bpp) { - case 1: fz_write_int32be(out, 3); /* Black */ break; - case 8: fz_write_int32be(out, 18); /* Sgray */ break; - case 24: fz_write_int32be(out, 19); /* Srgb */ break; - case 32: fz_write_int32be(out, 6); /* Cmyk */ break; - default: fz_throw(out->ctx, FZ_ERROR_GENERIC, "pixmap bpp must be 1, 8, 24 or 32 to write as pwg"); + case 1: fz_write_int32be(ctx, out, 3); /* Black */ break; + case 8: fz_write_int32be(ctx, out, 18); /* Sgray */ break; + case 24: fz_write_int32be(ctx, out, 19); /* Srgb */ break; + case 32: fz_write_int32be(ctx, out, 6); /* Cmyk */ break; + default: fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap bpp must be 1, 8, 24 or 32 to write as pwg"); } - fz_write_int32be(out, pwg ? pwg->compression : 0); - fz_write_int32be(out, pwg ? pwg->row_count : 0); - fz_write_int32be(out, pwg ? pwg->row_feed : 0); - fz_write_int32be(out, pwg ? pwg->row_step : 0); - fz_write_int32be(out, bpp <= 8 ? 1 : 3); /* Num Colors */ + fz_write_int32be(ctx, out, pwg ? pwg->compression : 0); + fz_write_int32be(ctx, out, pwg ? pwg->row_count : 0); + fz_write_int32be(ctx, out, pwg ? pwg->row_feed : 0); + fz_write_int32be(ctx, out, pwg ? pwg->row_step : 0); + fz_write_int32be(ctx, out, bpp <= 8 ? 1 : 3); /* Num Colors */ for (i=424; i < 452; i += 4) - fz_write(out, zero, 4); - fz_write_int32be(out, 1); /* TotalPageCount */ - fz_write_int32be(out, 1); /* CrossFeedTransform */ - fz_write_int32be(out, 1); /* FeedTransform */ - fz_write_int32be(out, 0); /* ImageBoxLeft */ - fz_write_int32be(out, 0); /* ImageBoxTop */ - fz_write_int32be(out, w); /* ImageBoxRight */ - fz_write_int32be(out, h); /* ImageBoxBottom */ + fz_write(ctx, out, zero, 4); + fz_write_int32be(ctx, out, 1); /* TotalPageCount */ + fz_write_int32be(ctx, out, 1); /* CrossFeedTransform */ + fz_write_int32be(ctx, out, 1); /* FeedTransform */ + fz_write_int32be(ctx, out, 0); /* ImageBoxLeft */ + fz_write_int32be(ctx, out, 0); /* ImageBoxTop */ + fz_write_int32be(ctx, out, w); /* ImageBoxRight */ + fz_write_int32be(ctx, out, h); /* ImageBoxBottom */ for (i=480; i < 1668; i += 4) - fz_write(out, zero, 4); - fz_write(out, pwg ? pwg->rendering_intent : zero, 64); - fz_write(out, pwg ? pwg->page_size_name : zero, 64); + fz_write(ctx, out, zero, 4); + fz_write(ctx, out, pwg ? pwg->rendering_intent : zero, 64); + fz_write(ctx, out, pwg ? pwg->page_size_name : zero, 64); } void -fz_output_pwg_page(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg) +fz_output_pwg_page(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg) { unsigned char *sp; int y, x, sn, dn, ss; - fz_context *ctx; if (!out || !pixmap) return; - ctx = out->ctx; - if (pixmap->n != 1 && pixmap->n != 2 && pixmap->n != 4 && pixmap->n != 5) fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale, rgb or cmyk to write as pwg"); @@ -106,7 +103,7 @@ fz_output_pwg_page(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options if (dn > 1) dn--; - output_header(out, pwg, pixmap->xres, pixmap->yres, pixmap->w, pixmap->h, dn*8); + output_header(ctx, out, pwg, pixmap->xres, pixmap->yres, pixmap->w, pixmap->h, dn*8); /* Now output the actual bitmap, using a packbits like compression */ sp = pixmap->samples; @@ -124,7 +121,7 @@ fz_output_pwg_page(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options if (memcmp(sp, sp + yrep * ss, ss) != 0) break; } - fz_write_byte(out, yrep-1); + fz_write_byte(ctx, out, yrep-1); /* Encode the line */ x = 0; @@ -152,18 +149,18 @@ fz_output_pwg_page(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options if (memcmp(sp, sp + xrep*sn, sn) != 0) break; } - fz_write_byte(out, xrep-1); - fz_write(out, sp, dn); + fz_write_byte(ctx, out, xrep-1); + fz_write(ctx, out, sp, dn); sp += sn*xrep; x += xrep; } else { - fz_write_byte(out, 257-d); + fz_write_byte(ctx, out, 257-d); x += d; while (d > 0) { - fz_write(out, sp, dn); + fz_write(ctx, out, sp, dn); sp += sn; d--; } @@ -177,7 +174,7 @@ fz_output_pwg_page(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options } void -fz_output_pwg_bitmap_page(fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg) +fz_output_pwg_bitmap_page(fz_context *ctx, fz_output *out, const fz_bitmap *bitmap, const fz_pwg_options *pwg) { unsigned char *sp; int y, x, ss; @@ -186,7 +183,7 @@ fz_output_pwg_bitmap_page(fz_output *out, const fz_bitmap *bitmap, const fz_pwg_ if (!out || !bitmap) return; - output_header(out, pwg, bitmap->xres, bitmap->yres, bitmap->w, bitmap->h, 1); + output_header(ctx, out, pwg, bitmap->xres, bitmap->yres, bitmap->w, bitmap->h, 1); /* Now output the actual bitmap, using a packbits like compression */ sp = bitmap->samples; @@ -205,7 +202,7 @@ fz_output_pwg_bitmap_page(fz_output *out, const fz_bitmap *bitmap, const fz_pwg_ if (memcmp(sp, sp + yrep * ss, byte_width) != 0) break; } - fz_write_byte(out, yrep-1); + fz_write_byte(ctx, out, yrep-1); /* Encode the line */ x = 0; @@ -233,15 +230,15 @@ fz_output_pwg_bitmap_page(fz_output *out, const fz_bitmap *bitmap, const fz_pwg_ if (sp[0] != sp[xrep]) break; } - fz_write_byte(out, xrep-1); - fz_write(out, sp, 1); + fz_write_byte(ctx, out, xrep-1); + fz_write(ctx, out, sp, 1); sp += xrep; x += xrep; } else { - fz_write_byte(out, 257-d); - fz_write(out, sp, d); + fz_write_byte(ctx, out, 257-d); + fz_write(ctx, out, sp, d); sp += d; x += d; } @@ -254,10 +251,10 @@ fz_output_pwg_bitmap_page(fz_output *out, const fz_bitmap *bitmap, const fz_pwg_ } void -fz_output_pwg(fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg) +fz_output_pwg(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, const fz_pwg_options *pwg) { - fz_output_pwg_file_header(out); - fz_output_pwg_page(out, pixmap, pwg); + fz_output_pwg_file_header(ctx, out); + fz_output_pwg_page(ctx, out, pixmap, pwg); } void @@ -276,15 +273,14 @@ fz_write_pwg(fz_context *ctx, fz_pixmap *pixmap, char *filename, int append, con fz_try(ctx) { - out = fz_new_output_with_file(ctx, fp); + out = fz_new_output_with_file(ctx, fp, 1); if (!append) - fz_output_pwg_file_header(out); - fz_output_pwg_page(out, pixmap, pwg); + fz_output_pwg_file_header(ctx, out); + fz_output_pwg_page(ctx, out, pixmap, pwg); } fz_always(ctx) { - fz_drop_output(out); - fclose(fp); + fz_drop_output(ctx, out); } fz_catch(ctx) { @@ -308,15 +304,14 @@ fz_write_pwg_bitmap(fz_context *ctx, fz_bitmap *bitmap, char *filename, int appe fz_try(ctx) { - out = fz_new_output_with_file(ctx, fp); + out = fz_new_output_with_file(ctx, fp, 1); if (!append) - fz_output_pwg_file_header(out); - fz_output_pwg_bitmap_page(out, bitmap, pwg); + fz_output_pwg_file_header(ctx, out); + fz_output_pwg_bitmap_page(ctx, out, bitmap, pwg); } fz_always(ctx) { - fz_drop_output(out); - fclose(fp); + fz_drop_output(ctx, out); } fz_catch(ctx) { diff --git a/source/fitz/output.c b/source/fitz/output.c index 8f5a4a0f..52381377 100644 --- a/source/fitz/output.c +++ b/source/fitz/output.c @@ -1,44 +1,42 @@ #include "mupdf/fitz.h" -void fz_rebind_output(fz_output *out, fz_context *ctx) +struct fz_output_s { - if (out != NULL) - out->ctx = ctx; -} + void *opaque; + int (*printf)(fz_context *, void *opaque, const char *, va_list ap); + int (*write)(fz_context *, void *opaque, const void *, int n); + void (*close)(fz_context *, void *opaque); +}; static int -file_printf(fz_output *out, const char *fmt, va_list ap) +file_printf(fz_context *ctx, void *opaque, const char *fmt, va_list ap) { - FILE *file = (FILE *)out->opaque; - - return fz_vfprintf(out->ctx, file, fmt, ap); + FILE *file = opaque; + return fz_vfprintf(ctx, file, fmt, ap); } static int -file_write(fz_output *out, const void *buffer, int count) +file_write(fz_context *ctx, void *opaque, const void *buffer, int count) { - FILE *file = (FILE *)out->opaque; - + FILE *file = opaque; return fwrite(buffer, 1, count, file); } static void -file_close(fz_output *out) +file_close(fz_context *ctx, void *opaque) { - FILE *file = (FILE *)out->opaque; - + FILE *file = opaque; fclose(file); } fz_output * -fz_new_output_with_file(fz_context *ctx, FILE *file) +fz_new_output_with_file(fz_context *ctx, FILE *file, int close) { fz_output *out = fz_malloc_struct(ctx, fz_output); - out->ctx = ctx; out->opaque = file; out->printf = file_printf; out->write = file_write; - out->close = NULL; + out->close = close ? file_close : NULL; return out; } @@ -56,7 +54,6 @@ fz_new_output_to_filename(fz_context *ctx, const char *filename) fz_try(ctx) { out = fz_malloc_struct(ctx, fz_output); - out->ctx = ctx; out->opaque = file; out->printf = file_printf; out->write = file_write; @@ -71,17 +68,17 @@ fz_new_output_to_filename(fz_context *ctx, const char *filename) } void -fz_drop_output(fz_output *out) +fz_drop_output(fz_context *ctx, fz_output *out) { if (!out) return; if (out->close) - out->close(out); - fz_free(out->ctx, out); + out->close(ctx, out->opaque); + fz_free(ctx, out); } int -fz_printf(fz_output *out, const char *fmt, ...) +fz_printf(fz_context *ctx, fz_output *out, const char *fmt, ...) { int ret; va_list ap; @@ -90,60 +87,64 @@ fz_printf(fz_output *out, const char *fmt, ...) return 0; va_start(ap, fmt); - ret = out->printf(out, fmt, ap); + ret = out->printf(ctx, out->opaque, fmt, ap); va_end(ap); return ret; } int -fz_write(fz_output *out, const void *data, int len) +fz_write(fz_context *ctx, fz_output *out, const void *data, int len) { if (!out) return 0; - return out->write(out, data, len); + return out->write(ctx, out->opaque, data, len); } void -fz_putc(fz_output *out, char c) +fz_putc(fz_context *ctx, fz_output *out, char c) { if (out) - (void)out->write(out, &c, 1); + (void)out->write(ctx, out->opaque, &c, 1); } int -fz_puts(fz_output *out, const char *str) +fz_puts(fz_context *ctx, fz_output *out, const char *str) { if (!out) return 0; - return out->write(out, str, strlen(str)); + return out->write(ctx, out->opaque, str, strlen(str)); } static int -buffer_printf(fz_output *out, const char *fmt, va_list list) +buffer_printf(fz_context *ctx, void *opaque, const char *fmt, va_list list) { - fz_buffer *buffer = (fz_buffer *)out->opaque; - - return fz_buffer_vprintf(out->ctx, buffer, fmt, list); + fz_buffer *buffer = opaque; + return fz_buffer_vprintf(ctx, buffer, fmt, list); } static int -buffer_write(fz_output *out, const void *data, int len) +buffer_write(fz_context *ctx, void *opaque, const void *data, int len) { - fz_buffer *buffer = (fz_buffer *)out->opaque; - - fz_write_buffer(out->ctx, buffer, (unsigned char *)data, len); + fz_buffer *buffer = opaque; + fz_write_buffer(ctx, buffer, (unsigned char *)data, len); return len; } +static void +buffer_close(fz_context *ctx, void *opaque) +{ + fz_buffer *buffer = opaque; + fz_drop_buffer(ctx, buffer); +} + fz_output * fz_new_output_with_buffer(fz_context *ctx, fz_buffer *buf) { fz_output *out = fz_malloc_struct(ctx, fz_output); - out->ctx = ctx; - out->opaque = buf; + out->opaque = fz_keep_buffer(ctx, buf); out->printf = buffer_printf; out->write = buffer_write; - out->close = NULL; + out->close = buffer_close; return out; } diff --git a/source/fitz/path.c b/source/fitz/path.c index 6c7991b9..4712ea35 100644 --- a/source/fitz/path.c +++ b/source/fitz/path.c @@ -270,14 +270,14 @@ fz_bound_path(fz_context *ctx, fz_path *path, const fz_stroke_state *stroke, con if (stroke) { - fz_adjust_rect_for_stroke(r, stroke, ctm); + fz_adjust_rect_for_stroke(ctx, r, stroke, ctm); } return r; } fz_rect * -fz_adjust_rect_for_stroke(fz_rect *r, const fz_stroke_state *stroke, const fz_matrix *ctm) +fz_adjust_rect_for_stroke(fz_context *ctx, fz_rect *r, const fz_stroke_state *stroke, const fz_matrix *ctm) { float expand; diff --git a/source/fitz/pixmap.c b/source/fitz/pixmap.c index d6a74ea1..fa4843bc 100644 --- a/source/fitz/pixmap.c +++ b/source/fitz/pixmap.c @@ -478,7 +478,7 @@ fz_invert_pixmap(fz_context *ctx, fz_pixmap *pix) } } -void fz_invert_pixmap_rect(fz_pixmap *image, const fz_irect *rect) +void fz_invert_pixmap_rect(fz_context *ctx, fz_pixmap *image, const fz_irect *rect) { unsigned char *p; int x, y, n; @@ -526,23 +526,21 @@ fz_gamma_pixmap(fz_context *ctx, fz_pixmap *pix, float gamma) */ void -fz_output_pnm_header(fz_output *out, int w, int h, int n) +fz_output_pnm_header(fz_context *ctx, fz_output *out, int w, int h, int n) { - fz_context *ctx = out->ctx; - if (n != 1 && n != 2 && n != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale or rgb to write as pnm"); if (n == 1 || n == 2) - fz_printf(out, "P5\n"); + fz_printf(ctx, out, "P5\n"); if (n == 4) - fz_printf(out, "P6\n"); - fz_printf(out, "%d %d\n", w, h); - fz_printf(out, "255\n"); + fz_printf(ctx, out, "P6\n"); + fz_printf(ctx, out, "%d %d\n", w, h); + fz_printf(ctx, out, "255\n"); } void -fz_output_pnm_band(fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *p) +fz_output_pnm_band(fz_context *ctx, fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *p) { int len; int start = band * bandheight; @@ -557,21 +555,21 @@ fz_output_pnm_band(fz_output *out, int w, int h, int n, int band, int bandheight switch (n) { case 1: - fz_write(out, p, len); + fz_write(ctx, out, p, len); break; case 2: while (len--) { - fz_putc(out, p[0]); + fz_putc(ctx, out, p[0]); p += 2; } break; case 4: while (len--) { - fz_putc(out, p[0]); - fz_putc(out, p[1]); - fz_putc(out, p[2]); + fz_putc(ctx, out, p[0]); + fz_putc(ctx, out, p[1]); + fz_putc(ctx, out, p[2]); p += 4; } } @@ -581,9 +579,9 @@ void fz_write_pnm(fz_context *ctx, fz_pixmap *pixmap, char *filename) { fz_output *out = fz_new_output_to_filename(ctx, filename); - fz_output_pnm_header(out, pixmap->w, pixmap->h, pixmap->n); - fz_output_pnm_band(out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples); - fz_drop_output(out); + fz_output_pnm_header(ctx, out, pixmap->w, pixmap->h, pixmap->n); + fz_output_pnm_band(ctx, out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples); + fz_drop_output(ctx, out); } /* @@ -591,29 +589,29 @@ fz_write_pnm(fz_context *ctx, fz_pixmap *pixmap, char *filename) */ void -fz_output_pam_header(fz_output *out, int w, int h, int n, int savealpha) +fz_output_pam_header(fz_context *ctx, fz_output *out, int w, int h, int n, int savealpha) { int sn = n; int dn = n; if (!savealpha && dn > 1) dn--; - fz_printf(out, "P7\n"); - fz_printf(out, "WIDTH %d\n", w); - fz_printf(out, "HEIGHT %d\n", h); - fz_printf(out, "DEPTH %d\n", dn); - fz_printf(out, "MAXVAL 255\n"); - if (dn == 1) fz_printf(out, "TUPLTYPE GRAYSCALE\n"); - else if (dn == 2 && sn == 2) fz_printf(out, "TUPLTYPE GRAYSCALE_ALPHA\n"); - else if (dn == 3 && sn == 4) fz_printf(out, "TUPLTYPE RGB\n"); - else if (dn == 4 && sn == 4) fz_printf(out, "TUPLTYPE RGB_ALPHA\n"); - else if (dn == 4 && sn == 5) fz_printf(out, "TUPLTYPE CMYK\n"); - else if (dn == 5 && sn == 5) fz_printf(out, "TUPLTYPE CMYK_ALPHA\n"); - fz_printf(out, "ENDHDR\n"); + fz_printf(ctx, out, "P7\n"); + fz_printf(ctx, out, "WIDTH %d\n", w); + fz_printf(ctx, out, "HEIGHT %d\n", h); + fz_printf(ctx, out, "DEPTH %d\n", dn); + fz_printf(ctx, out, "MAXVAL 255\n"); + if (dn == 1) fz_printf(ctx, out, "TUPLTYPE GRAYSCALE\n"); + else if (dn == 2 && sn == 2) fz_printf(ctx, out, "TUPLTYPE GRAYSCALE_ALPHA\n"); + else if (dn == 3 && sn == 4) fz_printf(ctx, out, "TUPLTYPE RGB\n"); + else if (dn == 4 && sn == 4) fz_printf(ctx, out, "TUPLTYPE RGB_ALPHA\n"); + else if (dn == 4 && sn == 5) fz_printf(ctx, out, "TUPLTYPE CMYK\n"); + else if (dn == 5 && sn == 5) fz_printf(ctx, out, "TUPLTYPE CMYK_ALPHA\n"); + fz_printf(ctx, out, "ENDHDR\n"); } void -fz_output_pam_band(fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *sp, int savealpha) +fz_output_pam_band(fz_context *ctx, fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *sp, int savealpha) { int y, x, k; int start = band * bandheight; @@ -633,7 +631,7 @@ fz_output_pam_band(fz_output *out, int w, int h, int n, int band, int bandheight while (x--) { for (k = 0; k < dn; k++) - fz_putc(out, sp[k]); + fz_putc(ctx, out, sp[k]); sp += sn; } } @@ -643,9 +641,9 @@ void fz_write_pam(fz_context *ctx, fz_pixmap *pixmap, char *filename, int savealpha) { fz_output *out = fz_new_output_to_filename(ctx, filename); - fz_output_pam_header(out, pixmap->w, pixmap->h, pixmap->n, savealpha); - fz_output_pam_band(out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha); - fz_drop_output(out); + fz_output_pam_header(ctx, out, pixmap->w, pixmap->h, pixmap->n, savealpha); + fz_output_pam_band(ctx, out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha); + fz_drop_output(ctx, out); } /* @@ -662,16 +660,16 @@ static inline void big32(unsigned char *buf, unsigned int v) buf[3] = (v) & 0xff; } -static void putchunk(char *tag, unsigned char *data, int size, fz_output *out) +static void putchunk(fz_context *ctx, fz_output *out, char *tag, unsigned char *data, int size) { unsigned int sum; - fz_write_int32be(out, size); - fz_write(out, tag, 4); - fz_write(out, data, size); + fz_write_int32be(ctx, out, size); + fz_write(ctx, out, tag, 4); + fz_write(ctx, out, data, size); sum = crc32(0, NULL, 0); sum = crc32(sum, (unsigned char*)tag, 4); sum = crc32(sum, data, size); - fz_write_int32be(out, sum); + fz_write_int32be(ctx, out, sum); } void @@ -684,13 +682,13 @@ fz_write_png(fz_context *ctx, fz_pixmap *pixmap, char *filename, int savealpha) fz_try(ctx) { - poc = fz_output_png_header(out, pixmap->w, pixmap->h, pixmap->n, savealpha); - fz_output_png_band(out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha, poc); + poc = fz_output_png_header(ctx, out, pixmap->w, pixmap->h, pixmap->n, savealpha); + fz_output_png_band(ctx, out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha, poc); } fz_always(ctx) { - fz_output_png_trailer(out, poc); - fz_drop_output(out); + fz_output_png_trailer(ctx, out, poc); + fz_drop_output(ctx, out); } fz_catch(ctx) { @@ -699,24 +697,22 @@ fz_write_png(fz_context *ctx, fz_pixmap *pixmap, char *filename, int savealpha) } void -fz_output_png(fz_output *out, const fz_pixmap *pixmap, int savealpha) +fz_output_png(fz_context *ctx, fz_output *out, const fz_pixmap *pixmap, int savealpha) { fz_png_output_context *poc; - fz_context *ctx; if (!out) return; - ctx = out->ctx; - poc = fz_output_png_header(out, pixmap->w, pixmap->h, pixmap->n, savealpha); + poc = fz_output_png_header(ctx, out, pixmap->w, pixmap->h, pixmap->n, savealpha); fz_try(ctx) { - fz_output_png_band(out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha, poc); + fz_output_png_band(ctx, out, pixmap->w, pixmap->h, pixmap->n, 0, pixmap->h, pixmap->samples, savealpha, poc); } fz_always(ctx) { - fz_output_png_trailer(out, poc); + fz_output_png_trailer(ctx, out, poc); } fz_catch(ctx) { @@ -733,19 +729,16 @@ struct fz_png_output_context_s }; fz_png_output_context * -fz_output_png_header(fz_output *out, int w, int h, int n, int savealpha) +fz_output_png_header(fz_context *ctx, fz_output *out, int w, int h, int n, int savealpha) { static const unsigned char pngsig[8] = { 137, 80, 78, 71, 13, 10, 26, 10 }; unsigned char head[13]; - fz_context *ctx; int color; fz_png_output_context *poc; if (!out) return NULL; - ctx = out->ctx; - if (n != 1 && n != 2 && n != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale or rgb to write as png"); @@ -771,24 +764,21 @@ fz_output_png_header(fz_output *out, int w, int h, int n, int savealpha) head[11] = 0; /* filter */ head[12] = 0; /* interlace */ - fz_write(out, pngsig, 8); - putchunk("IHDR", head, 13, out); + fz_write(ctx, out, pngsig, 8); + putchunk(ctx, out, "IHDR", head, 13); return poc; } void -fz_output_png_band(fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *sp, int savealpha, fz_png_output_context *poc) +fz_output_png_band(fz_context *ctx, fz_output *out, int w, int h, int n, int band, int bandheight, unsigned char *sp, int savealpha, fz_png_output_context *poc) { unsigned char *dp; int y, x, k, sn, dn, err, finalband; - fz_context *ctx; if (!out || !sp || !poc) return; - ctx = out->ctx; - if (n != 1 && n != 2 && n != 4) fz_throw(ctx, FZ_ERROR_GENERIC, "pixmap must be grayscale or rgb to write as png"); @@ -867,23 +857,20 @@ fz_output_png_band(fz_output *out, int w, int h, int n, int band, int bandheight } if (poc->stream.next_out != poc->cdata) - putchunk("IDAT", poc->cdata, poc->stream.next_out - poc->cdata, out); + putchunk(ctx, out, "IDAT", poc->cdata, poc->stream.next_out - poc->cdata); } while (poc->stream.avail_out == 0); } void -fz_output_png_trailer(fz_output *out, fz_png_output_context *poc) +fz_output_png_trailer(fz_context *ctx, fz_output *out, fz_png_output_context *poc) { unsigned char block[1]; int err; - fz_context *ctx; if (!out || !poc) return; - ctx = out->ctx; - err = deflateEnd(&poc->stream); if (err != Z_OK) fz_throw(ctx, FZ_ERROR_GENERIC, "compression error %d", err); @@ -892,7 +879,7 @@ fz_output_png_trailer(fz_output *out, fz_png_output_context *poc) fz_free(ctx, poc->udata); fz_free(ctx, poc); - putchunk("IEND", block, 0, out); + putchunk(ctx, out, "IEND", block, 0); } /* We use an auxiliary function to do pixmap_as_png, as it can enable us to @@ -924,12 +911,12 @@ png_from_pixmap(fz_context *ctx, fz_pixmap *pix, int drop) } buf = fz_new_buffer(ctx, 1024); out = fz_new_output_with_buffer(ctx, buf); - fz_output_png(out, pix, 1); + fz_output_png(ctx, out, pix, 1); } fz_always(ctx) { fz_drop_pixmap(ctx, drop ? pix : pix2); - fz_drop_output(out); + fz_drop_output(ctx, out); } fz_catch(ctx) { @@ -957,23 +944,23 @@ fz_new_png_from_pixmap(fz_context *ctx, fz_pixmap *pix) * Write pixmap to TGA file (with or without alpha channel) */ -static inline void tga_put_pixel(unsigned char *data, int n, int is_bgr, fz_output *out) +static inline void tga_put_pixel(fz_context *ctx, fz_output *out, unsigned char *data, int n, int is_bgr) { if (n >= 3 && !is_bgr) { - fz_putc(out, data[2]); - fz_putc(out, data[1]); - fz_putc(out, data[0]); + fz_putc(ctx, out, data[2]); + fz_putc(ctx, out, data[1]); + fz_putc(ctx, out, data[0]); if (n == 4) - fz_putc(out, data[3]); + fz_putc(ctx, out, data[3]); return; } if (n == 2) { - fz_putc(out, data[0]); - fz_putc(out, data[0]); + fz_putc(ctx, out, data[0]); + fz_putc(ctx, out, data[0]); } - fz_write(out, data, n); + fz_write(ctx, out, data, n); } void @@ -1003,7 +990,7 @@ fz_write_tga(fz_context *ctx, fz_pixmap *pixmap, const char *filename, int savea if (savealpha && d == 2) head[16] = 32; - fz_write(out, head, sizeof(head)); + fz_write(ctx, out, head, sizeof(head)); for (k = 1; k <= pixmap->h; k++) { int i, j; @@ -1013,23 +1000,23 @@ fz_write_tga(fz_context *ctx, fz_pixmap *pixmap, const char *filename, int savea for (; i + j < pixmap->w && j < 128 && !memcmp(line + i * n, line + (i + j) * n, d); j++); if (j > 1) { - fz_putc(out, j - 1 + 128); - tga_put_pixel(line + i * n, d, is_bgr, out); + fz_putc(ctx, out, j - 1 + 128); + tga_put_pixel(ctx, out, line + i * n, d, is_bgr); } else { for (; i + j < pixmap->w && j <= 128 && memcmp(line + (i + j - 1) * n, line + (i + j) * n, d) != 0; j++); if (i + j < pixmap->w || j > 128) j--; - fz_putc(out, j - 1); + fz_putc(ctx, out, j - 1); for (; j > 0; j--, i++) - tga_put_pixel(line + i * n, d, is_bgr, out); + tga_put_pixel(ctx, out, line + i * n, d, is_bgr); } } } - fz_write(out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.\0", 26); + fz_write(ctx, out, "\0\0\0\0\0\0\0\0TRUEVISION-XFILE.\0", 26); - fz_drop_output(out); + fz_drop_output(ctx, out); } unsigned int @@ -1403,7 +1390,7 @@ fz_pixmap_set_resolution(fz_pixmap *pix, int res) } void -fz_md5_pixmap(fz_pixmap *pix, unsigned char digest[16]) +fz_md5_pixmap(fz_context *ctx, fz_pixmap *pix, unsigned char digest[16]) { fz_md5 md5; diff --git a/source/fitz/shade.c b/source/fitz/shade.c index 01ada9a4..f5e25639 100644 --- a/source/fitz/shade.c +++ b/source/fitz/shade.c @@ -1,18 +1,28 @@ #include "mupdf/fitz.h" +typedef struct fz_mesh_processor_s fz_mesh_processor; + +struct fz_mesh_processor_s { + fz_shade *shade; + fz_mesh_prepare_fn *prepare; + fz_mesh_process_fn *process; + void *process_arg; + int ncomp; +}; + #define SWAP(a,b) {fz_vertex *t = (a); (a) = (b); (b) = t;} static inline void -paint_tri(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2) +paint_tri(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2) { if (painter->process) { - painter->process(painter->process_arg, v0, v1, v2); + painter->process(ctx, painter->process_arg, v0, v1, v2); } } static inline void -paint_quad(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2, fz_vertex *v3) +paint_quad(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex *v2, fz_vertex *v3) { /* For a quad with corners (in clockwise or anticlockwise order) are * v0, v1, v2, v3. We can choose to split in in various different ways. @@ -35,27 +45,27 @@ paint_quad(fz_mesh_processor *painter, fz_vertex *v0, fz_vertex *v1, fz_vertex * */ if (painter->process) { - painter->process(painter->process_arg, v0, v1, v3); - painter->process(painter->process_arg, v3, v2, v1); + painter->process(ctx, painter->process_arg, v0, v1, v3); + painter->process(ctx, painter->process_arg, v3, v2, v1); } } static inline void -fz_prepare_color(fz_mesh_processor *painter, fz_vertex *v, float *c) +fz_prepare_color(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v, float *c) { if (painter->prepare) { - painter->prepare(painter->process_arg, v, c); + painter->prepare(ctx, painter->process_arg, v, c); } } static inline void -fz_prepare_vertex(fz_mesh_processor *painter, fz_vertex *v, const fz_matrix *ctm, float x, float y, float *c) +fz_prepare_vertex(fz_context *ctx, fz_mesh_processor *painter, fz_vertex *v, const fz_matrix *ctm, float x, float y, float *c) { fz_transform_point_xy(&v->p, ctm, x, y); if (painter->prepare) { - painter->prepare(painter->process_arg, v, c); + painter->prepare(ctx, painter->process_arg, v, c); } } @@ -86,19 +96,19 @@ fz_process_mesh_type1(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz x = x0; - fz_prepare_vertex(painter, &v[0], &local_ctm, x, y, p); + fz_prepare_vertex(ctx, painter, &v[0], &local_ctm, x, y, p); p += n; - fz_prepare_vertex(painter, &v[1], &local_ctm, x, yn, p + xdivs * n); + fz_prepare_vertex(ctx, painter, &v[1], &local_ctm, x, yn, p + xdivs * n); for (xx = 0; xx < xdivs; xx++) { x = x0 + (x1 - x0) * (xx + 1) / xdivs; - fz_prepare_vertex(painter, &vn[0], &local_ctm, x, y, p); + fz_prepare_vertex(ctx, painter, &vn[0], &local_ctm, x, y, p); p += n; - fz_prepare_vertex(painter, &vn[1], &local_ctm, x, yn, p + xdivs * n); + fz_prepare_vertex(ctx, painter, &vn[1], &local_ctm, x, yn, p + xdivs * n); - paint_quad(painter, &v[0], &vn[0], &vn[1], &v[1]); + paint_quad(ctx, painter, &v[0], &vn[0], &vn[1], &v[1]); SWAP(v,vn); } y = yn; @@ -142,42 +152,42 @@ fz_process_mesh_type2(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz v2.p = fz_point_on_circle(p0, -HUGENUM, theta); v3.p = fz_point_on_circle(p1, -HUGENUM, theta); - fz_prepare_color(painter, &v0, &zero); - fz_prepare_color(painter, &v1, &one); - fz_prepare_color(painter, &v2, &zero); - fz_prepare_color(painter, &v3, &one); + fz_prepare_color(ctx, painter, &v0, &zero); + fz_prepare_color(ctx, painter, &v1, &one); + fz_prepare_color(ctx, painter, &v2, &zero); + fz_prepare_color(ctx, painter, &v3, &one); - paint_quad(painter, &v0, &v2, &v3, &v1); + paint_quad(ctx, painter, &v0, &v2, &v3, &v1); if (shade->u.l_or_r.extend[0]) { e0.p.x = v0.p.x - (p1.x - p0.x) * HUGENUM; e0.p.y = v0.p.y - (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e0, &zero); + fz_prepare_color(ctx, painter, &e0, &zero); e1.p.x = v2.p.x - (p1.x - p0.x) * HUGENUM; e1.p.y = v2.p.y - (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e1, &zero); + fz_prepare_color(ctx, painter, &e1, &zero); - paint_quad(painter, &e0, &v0, &v2, &e1); + paint_quad(ctx, painter, &e0, &v0, &v2, &e1); } if (shade->u.l_or_r.extend[1]) { e0.p.x = v1.p.x + (p1.x - p0.x) * HUGENUM; e0.p.y = v1.p.y + (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e0, &one); + fz_prepare_color(ctx, painter, &e0, &one); e1.p.x = v3.p.x + (p1.x - p0.x) * HUGENUM; e1.p.y = v3.p.y + (p1.y - p0.y) * HUGENUM; - fz_prepare_color(painter, &e1, &one); + fz_prepare_color(ctx, painter, &e1, &one); - paint_quad(painter, &e0, &v1, &v3, &e1); + paint_quad(ctx, painter, &e0, &v1, &v3, &e1); } } static void -fz_paint_annulus(const fz_matrix *ctm, +fz_paint_annulus(fz_context *ctx, const fz_matrix *ctm, fz_point p0, float r0, float c0, fz_point p1, float r1, float c1, int count, @@ -213,17 +223,17 @@ fz_paint_annulus(const fz_matrix *ctm, fz_transform_point(&b2.p, ctm); fz_transform_point(&b3.p, ctm); - fz_prepare_color(painter, &t0, &c0); - fz_prepare_color(painter, &t1, &c0); - fz_prepare_color(painter, &t2, &c1); - fz_prepare_color(painter, &t3, &c1); - fz_prepare_color(painter, &b0, &c0); - fz_prepare_color(painter, &b1, &c0); - fz_prepare_color(painter, &b2, &c1); - fz_prepare_color(painter, &b3, &c1); + fz_prepare_color(ctx, painter, &t0, &c0); + fz_prepare_color(ctx, painter, &t1, &c0); + fz_prepare_color(ctx, painter, &t2, &c1); + fz_prepare_color(ctx, painter, &t3, &c1); + fz_prepare_color(ctx, painter, &b0, &c0); + fz_prepare_color(ctx, painter, &b1, &c0); + fz_prepare_color(ctx, painter, &b2, &c1); + fz_prepare_color(ctx, painter, &b3, &c1); - paint_quad(painter, &t0, &t2, &t3, &t1); - paint_quad(painter, &b0, &b2, &b3, &b1); + paint_quad(ctx, painter, &t0, &t2, &t3, &t1); + paint_quad(ctx, painter, &b0, &b2, &b3, &b1); a = b; } @@ -264,10 +274,10 @@ fz_process_mesh_type3(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz e.y = p0.y + (p1.y - p0.y) * rs; er = r0 + (r1 - r0) * rs; - fz_paint_annulus(ctm, e, er, 0, p0, r0, 0, count, painter); + fz_paint_annulus(ctx, ctm, e, er, 0, p0, r0, 0, count, painter); } - fz_paint_annulus(ctm, p0, r0, 0, p1, r1, 1, count, painter); + fz_paint_annulus(ctx, ctm, p0, r0, 0, p1, r1, 1, count, painter); if (shade->u.l_or_r.extend[1]) { @@ -280,15 +290,15 @@ fz_process_mesh_type3(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz e.y = p1.y + (p0.y - p1.y) * rs; er = r1 + (r0 - r1) * rs; - fz_paint_annulus(ctm, p1, r1, 1, e, er, 1, count, painter); + fz_paint_annulus(ctx, ctm, p1, r1, 1, e, er, 1, count, painter); } } -static inline float read_sample(fz_stream *stream, int bits, float min, float max) +static inline float read_sample(fz_context *ctx, fz_stream *stream, int bits, float min, float max) { /* we use pow(2,x) because (1<<x) would overflow the math on 32-bit samples */ float bitscale = 1 / (powf(2, bits) - 1); - return min + fz_read_bits(stream, bits) * (max - min) * bitscale; + return min + fz_read_bits(ctx, stream, bits) * (max - min) * bitscale; } static void @@ -314,55 +324,55 @@ fz_process_mesh_type4(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz fz_try(ctx) { - while (!fz_is_eof_bits(stream)) + while (!fz_is_eof_bits(ctx, stream)) { - flag = fz_read_bits(stream, bpflag); - x = read_sample(stream, bpcoord, x0, x1); - y = read_sample(stream, bpcoord, y0, y1); + flag = fz_read_bits(ctx, stream, bpflag); + x = read_sample(ctx, stream, bpcoord, x0, x1); + y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) - c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); - fz_prepare_vertex(painter, vd, ctm, x, y, c); + c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); + fz_prepare_vertex(ctx, painter, vd, ctm, x, y, c); switch (flag) { case 0: /* start new triangle */ SWAP(va, vd); - fz_read_bits(stream, bpflag); - x = read_sample(stream, bpcoord, x0, x1); - y = read_sample(stream, bpcoord, y0, y1); + fz_read_bits(ctx, stream, bpflag); + x = read_sample(ctx, stream, bpcoord, x0, x1); + y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) - c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); - fz_prepare_vertex(painter, vb, ctm, x, y, c); + c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); + fz_prepare_vertex(ctx, painter, vb, ctm, x, y, c); - fz_read_bits(stream, bpflag); - x = read_sample(stream, bpcoord, x0, x1); - y = read_sample(stream, bpcoord, y0, y1); + fz_read_bits(ctx, stream, bpflag); + x = read_sample(ctx, stream, bpcoord, x0, x1); + y = read_sample(ctx, stream, bpcoord, y0, y1); for (i = 0; i < ncomp; i++) - c[i] = read_sample(stream, bpcomp, c0[i], c1[i]); - fz_prepare_vertex(painter, vc, ctm, x, y, c); + c[i] = read_sample(ctx, stream, bpcomp, c0[i], c1[i]); + fz_prepare_vertex(ctx, painter, vc, ctm, x, y, c); - paint_tri(painter, va, vb, vc); + paint_tri(ctx, painter, va, vb, vc); break; case 1: /* Vb, Vc, Vd */ SWAP(va, vb); SWAP(vb, vc); SWAP(vc, vd); - paint_tri(painter, va, vb, vc); + paint_tri(ctx, painter, va, vb, vc); break; case 2: /* Va, Vc, Vd */ SWAP(vb, vc); SWAP(vc, vd); - paint_tri(painter, va, vb, vc); + paint_tri(ctx, painter, va, vb, vc); break; } } } fz_always(ctx) { - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -399,20 +409,20 @@ fz_process_mesh_type5(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz buf = fz_malloc_array(ctx, vprow, sizeof(fz_vertex)); first = 1; - while (!fz_is_eof_bits(stream)) + while (!fz_is_eof_bits(ctx, stream)) { for (i = 0; i < vprow; i++) { - x = read_sample(stream, bpcoord, x0, x1); - y = read_sample(stream, bpcoord, y0, y1); + x = read_sample(ctx, stream, bpcoord, x0, x1); + y = read_sample(ctx, stream, bpcoord, y0, y1); for (k = 0; k < ncomp; k++) - c[k] = read_sample(stream, bpcomp, c0[k], c1[k]); - fz_prepare_vertex(painter, &buf[i], ctm, x, y, c); + c[k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]); + fz_prepare_vertex(ctx, painter, &buf[i], ctm, x, y, c); } if (!first) for (i = 0; i < vprow - 1; i++) - paint_quad(painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); + paint_quad(ctx, painter, &ref[i], &ref[i+1], &buf[i+1], &buf[i]); SWAP(ref,buf); first = 0; @@ -422,7 +432,7 @@ fz_process_mesh_type5(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz { fz_free(ctx, ref); fz_free(ctx, buf); - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -441,7 +451,7 @@ struct tensor_patch_s }; static void -triangulate_patch(fz_mesh_processor *painter, tensor_patch p) +triangulate_patch(fz_context *ctx, fz_mesh_processor *painter, tensor_patch p) { fz_vertex v0, v1, v2, v3; @@ -450,12 +460,12 @@ triangulate_patch(fz_mesh_processor *painter, tensor_patch p) v2.p = p.pole[3][3]; v3.p = p.pole[3][0]; - fz_prepare_color(painter, &v0, p.color[0]); - fz_prepare_color(painter, &v1, p.color[1]); - fz_prepare_color(painter, &v2, p.color[2]); - fz_prepare_color(painter, &v3, p.color[3]); + fz_prepare_color(ctx, painter, &v0, p.color[0]); + fz_prepare_color(ctx, painter, &v1, p.color[1]); + fz_prepare_color(ctx, painter, &v2, p.color[2]); + fz_prepare_color(ctx, painter, &v3, p.color[3]); - paint_quad(painter, &v0, &v1, &v2, &v3); + paint_quad(ctx, painter, &v0, &v1, &v2, &v3); } static inline void midcolor(float *c, float *c1, float *c2, int n) @@ -526,7 +536,7 @@ split_stripe(tensor_patch *p, tensor_patch *s0, tensor_patch *s1, int n) } static void -draw_stripe(fz_mesh_processor *painter, tensor_patch *p, int depth) +draw_stripe(fz_context *ctx, fz_mesh_processor *painter, tensor_patch *p, int depth) { tensor_patch s0, s1; @@ -537,14 +547,14 @@ draw_stripe(fz_mesh_processor *painter, tensor_patch *p, int depth) if (depth == 0) { /* if no more subdividing, draw two new patches... */ - triangulate_patch(painter, s1); - triangulate_patch(painter, s0); + triangulate_patch(ctx, painter, s1); + triangulate_patch(ctx, painter, s0); } else { /* ...otherwise, continue subdividing. */ - draw_stripe(painter, &s1, depth); - draw_stripe(painter, &s0, depth); + draw_stripe(ctx, painter, &s1, depth); + draw_stripe(ctx, painter, &s0, depth); } } @@ -573,7 +583,7 @@ split_patch(tensor_patch *p, tensor_patch *s0, tensor_patch *s1, int n) } static void -draw_patch(fz_mesh_processor *painter, tensor_patch *p, int depth, int origdepth) +draw_patch(fz_context *ctx, fz_mesh_processor *painter, tensor_patch *p, int depth, int origdepth) { tensor_patch s0, s1; @@ -584,14 +594,14 @@ draw_patch(fz_mesh_processor *painter, tensor_patch *p, int depth, int origdepth if (depth == 0) { /* if no more subdividing, draw two new patches... */ - draw_stripe(painter, &s0, origdepth); - draw_stripe(painter, &s1, origdepth); + draw_stripe(ctx, painter, &s0, origdepth); + draw_stripe(ctx, painter, &s1, origdepth); } else { /* ...otherwise, continue subdividing. */ - draw_patch(painter, &s0, depth, origdepth); - draw_patch(painter, &s1, depth, origdepth); + draw_patch(ctx, painter, &s0, depth, origdepth); + draw_patch(ctx, painter, &s1, depth, origdepth); } } @@ -708,7 +718,7 @@ fz_process_mesh_type6(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz { float (*prevc)[FZ_MAX_COLORS] = NULL; fz_point *prevp = NULL; - while (!fz_is_eof_bits(stream)) + while (!fz_is_eof_bits(ctx, stream)) { float (*c)[FZ_MAX_COLORS] = color_storage[store]; fz_point *v = point_storage[store]; @@ -717,7 +727,7 @@ fz_process_mesh_type6(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz int flag; tensor_patch patch; - flag = fz_read_bits(stream, bpflag); + flag = fz_read_bits(ctx, stream, bpflag); if (flag == 0) { @@ -732,15 +742,15 @@ fz_process_mesh_type6(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz for (i = startpt; i < 12; i++) { - v[i].x = read_sample(stream, bpcoord, x0, x1); - v[i].y = read_sample(stream, bpcoord, y0, y1); + v[i].x = read_sample(ctx, stream, bpcoord, x0, x1); + v[i].y = read_sample(ctx, stream, bpcoord, y0, y1); fz_transform_point(&v[i], ctm); } for (i = startcolor; i < 4; i++) { for (k = 0; k < ncomp; k++) - c[i][k] = read_sample(stream, bpcomp, c0[k], c1[k]); + c[i][k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]); } if (flag == 0) @@ -781,7 +791,7 @@ fz_process_mesh_type6(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz for (i = 0; i < 4; i++) memcpy(patch.color[i], c[i], ncomp * sizeof(float)); - draw_patch(painter, &patch, SUBDIV, SUBDIV); + draw_patch(ctx, painter, &patch, SUBDIV, SUBDIV); prevp = v; prevc = c; @@ -790,7 +800,7 @@ fz_process_mesh_type6(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz } fz_always(ctx) { - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -821,7 +831,7 @@ fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz fz_try(ctx) { - while (!fz_is_eof_bits(stream)) + while (!fz_is_eof_bits(ctx, stream)) { float (*c)[FZ_MAX_COLORS] = color_storage[store]; fz_point *v = point_storage[store]; @@ -830,7 +840,7 @@ fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz int flag; tensor_patch patch; - flag = fz_read_bits(stream, bpflag); + flag = fz_read_bits(ctx, stream, bpflag); if (flag == 0) { @@ -845,15 +855,15 @@ fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz for (i = startpt; i < 16; i++) { - v[i].x = read_sample(stream, bpcoord, x0, x1); - v[i].y = read_sample(stream, bpcoord, y0, y1); + v[i].x = read_sample(ctx, stream, bpcoord, x0, x1); + v[i].y = read_sample(ctx, stream, bpcoord, y0, y1); fz_transform_point(&v[i], ctm); } for (i = startcolor; i < 4; i++) { for (k = 0; k < ncomp; k++) - c[i][k] = read_sample(stream, bpcomp, c0[k], c1[k]); + c[i][k] = read_sample(ctx, stream, bpcomp, c0[k], c1[k]); } if (flag == 0) @@ -894,7 +904,7 @@ fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz for (i = 0; i < 4; i++) memcpy(patch.color[i], c[i], ncomp * sizeof(float)); - draw_patch(painter, &patch, SUBDIV, SUBDIV); + draw_patch(ctx, painter, &patch, SUBDIV, SUBDIV); prevp = v; prevc = c; @@ -903,7 +913,7 @@ fz_process_mesh_type7(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, fz } fz_always(ctx) { - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -917,7 +927,6 @@ fz_process_mesh(fz_context *ctx, fz_shade *shade, const fz_matrix *ctm, { fz_mesh_processor painter; - painter.ctx = ctx; painter.shade = shade; painter.prepare = prepare; painter.process = process; diff --git a/source/fitz/stext-device.c b/source/fitz/stext-device.c index f963eb19..dd1249c8 100644 --- a/source/fitz/stext-device.c +++ b/source/fitz/stext-device.c @@ -47,7 +47,7 @@ add_point_to_rect(fz_rect *a, const fz_point *p) } fz_rect * -fz_text_char_bbox(fz_rect *bbox, fz_text_span *span, int i) +fz_text_char_bbox(fz_context *ctx, fz_rect *bbox, fz_text_span *span, int i) { fz_point a, d; const fz_point *max; @@ -112,7 +112,6 @@ add_bbox_to_span(fz_text_span *span) struct span_soup_s { - fz_context *ctx; int len, cap; fz_text_span **spans; }; @@ -121,7 +120,6 @@ static span_soup * new_span_soup(fz_context *ctx) { span_soup *soup = fz_malloc_struct(ctx, span_soup); - soup->ctx = ctx; soup->len = 0; soup->cap = 0; soup->spans = NULL; @@ -129,7 +127,7 @@ new_span_soup(fz_context *ctx) } static void -free_span_soup(span_soup *soup) +free_span_soup(fz_context *ctx, span_soup *soup) { int i; @@ -137,21 +135,21 @@ free_span_soup(span_soup *soup) return; for (i = 0; i < soup->len; i++) { - fz_free(soup->ctx, soup->spans[i]); + fz_free(ctx, soup->spans[i]); } - fz_free(soup->ctx, soup->spans); - fz_free(soup->ctx, soup); + fz_free(ctx, soup->spans); + fz_free(ctx, soup); } static void -add_span_to_soup(span_soup *soup, fz_text_span *span) +add_span_to_soup(fz_context *ctx, span_soup *soup, fz_text_span *span) { if (span == NULL) return; if (soup->len == soup->cap) { int newcap = (soup->cap ? soup->cap * 2 : 16); - soup->spans = fz_resize_array(soup->ctx, soup->spans, newcap, sizeof(*soup->spans)); + soup->spans = fz_resize_array(ctx, soup->spans, newcap, sizeof(*soup->spans)); soup->cap = newcap; } add_bbox_to_span(span); @@ -638,7 +636,7 @@ fz_add_text_char_imp(fz_context *ctx, fz_text_device *dev, fz_text_style *style, if (can_append == 0) { /* Start a new span */ - add_span_to_soup(dev->spans, dev->cur_span); + add_span_to_soup(ctx, dev->spans, dev->cur_span); dev->cur_span = NULL; dev->cur_span = fz_new_text_span(ctx, &p, wmode, trm); dev->cur_span->spacing = 0; @@ -787,60 +785,59 @@ fz_text_extract(fz_context *ctx, fz_text_device *dev, fz_text *text, const fz_ma } static void -fz_text_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_text_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_text_device *tdev = dev->user; fz_text_style *style; - style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, colorspace, color, alpha, NULL); - fz_text_extract(dev->ctx, tdev, text, ctm, style); + style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, colorspace, color, alpha, NULL); + fz_text_extract(ctx, tdev, text, ctm, style); } static void -fz_text_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_text_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { fz_text_device *tdev = dev->user; fz_text_style *style; - style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, colorspace, color, alpha, stroke); - fz_text_extract(dev->ctx, tdev, text, ctm, style); + style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, colorspace, color, alpha, stroke); + fz_text_extract(ctx, tdev, text, ctm, style); } static void -fz_text_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_text_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { fz_text_device *tdev = dev->user; fz_text_style *style; - style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); - fz_text_extract(dev->ctx, tdev, text, ctm, style); + style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); + fz_text_extract(ctx, tdev, text, ctm, style); } static void -fz_text_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_text_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { fz_text_device *tdev = dev->user; fz_text_style *style; - style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, stroke); - fz_text_extract(dev->ctx, tdev, text, ctm, style); + style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, stroke); + fz_text_extract(ctx, tdev, text, ctm, style); } static void -fz_text_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_text_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { fz_text_device *tdev = dev->user; fz_text_style *style; - style = fz_lookup_text_style(dev->ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); - fz_text_extract(dev->ctx, tdev, text, ctm, style); + style = fz_lookup_text_style(ctx, tdev->sheet, text, ctm, NULL, NULL, 0, NULL); + fz_text_extract(ctx, tdev, text, ctm, style); } static void -fz_text_fill_image_mask(fz_device *dev, fz_image *img, const fz_matrix *ctm, +fz_text_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *img, const fz_matrix *ctm, fz_colorspace *cspace, float *color, float alpha) { fz_text_device *tdev = dev->user; fz_text_page *page = tdev->page; fz_image_block *block; - fz_context *ctx = dev->ctx; /* If the alpha is less than 50% then it's probably a watermark or * effect or something. Skip it */ @@ -865,9 +862,9 @@ fz_text_fill_image_mask(fz_device *dev, fz_image *img, const fz_matrix *ctm, } static void -fz_text_fill_image(fz_device *dev, fz_image *img, const fz_matrix *ctm, float alpha) +fz_text_fill_image(fz_context *ctx, fz_device *dev, fz_image *img, const fz_matrix *ctm, float alpha) { - fz_text_fill_image_mask(dev, img, ctm, NULL, NULL, alpha); + fz_text_fill_image_mask(ctx, dev, img, ctm, NULL, NULL, alpha); } static int @@ -957,9 +954,8 @@ fz_bidi_reorder_text_page(fz_context *ctx, fz_text_page *page) } static void -fz_text_begin_page(fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm) +fz_text_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm) { - fz_context *ctx = dev->ctx; fz_text_device *tdev = dev->user; if (tdev->page->len) @@ -975,16 +971,15 @@ fz_text_begin_page(fz_device *dev, const fz_rect *mediabox, const fz_matrix *ctm } static void -fz_text_end_page(fz_device *dev) +fz_text_end_page(fz_context *ctx, fz_device *dev) { - fz_context *ctx = dev->ctx; fz_text_device *tdev = dev->user; - add_span_to_soup(tdev->spans, tdev->cur_span); + add_span_to_soup(ctx, tdev->spans, tdev->cur_span); tdev->cur_span = NULL; strain_soup(ctx, tdev); - free_span_soup(tdev->spans); + free_span_soup(ctx, tdev->spans); tdev->spans = NULL; /* TODO: smart sorting of blocks in reading order */ @@ -994,11 +989,11 @@ fz_text_end_page(fz_device *dev) } static void -fz_text_drop_user(fz_device *dev) +fz_text_drop_user(fz_context *ctx, fz_device *dev) { fz_text_device *tdev = dev->user; - free_span_soup(tdev->spans); - fz_free(dev->ctx, tdev); + free_span_soup(ctx, tdev->spans); + fz_free(ctx, tdev); } fz_device * diff --git a/source/fitz/stext-output.c b/source/fitz/stext-output.c index 6ed595fc..f090020d 100644 --- a/source/fitz/stext-output.c +++ b/source/fitz/stext-output.c @@ -29,39 +29,39 @@ static int font_is_italic(fz_font *font) } static void -fz_print_style_begin(fz_output *out, fz_text_style *style) +fz_print_style_begin(fz_context *ctx, fz_output *out, fz_text_style *style) { int script = style->script; - fz_printf(out, "<span class=\"s%d\">", style->id); + fz_printf(ctx, out, "<span class=\"s%d\">", style->id); while (script-- > 0) - fz_printf(out, "<sup>"); + fz_printf(ctx, out, "<sup>"); while (++script < 0) - fz_printf(out, "<sub>"); + fz_printf(ctx, out, "<sub>"); } static void -fz_print_style_end(fz_output *out, fz_text_style *style) +fz_print_style_end(fz_context *ctx, fz_output *out, fz_text_style *style) { int script = style->script; while (script-- > 0) - fz_printf(out, "</sup>"); + fz_printf(ctx, out, "</sup>"); while (++script < 0) - fz_printf(out, "</sub>"); - fz_printf(out, "</span>"); + fz_printf(ctx, out, "</sub>"); + fz_printf(ctx, out, "</span>"); } static void -fz_print_style(fz_output *out, fz_text_style *style) +fz_print_style(fz_context *ctx, fz_output *out, fz_text_style *style) { char *s = strchr(style->font->name, '+'); s = s ? s + 1 : style->font->name; - fz_printf(out, "span.s%d{font-family:\"%s\";font-size:%gpt;", + fz_printf(ctx, out, "span.s%d{font-family:\"%s\";font-size:%gpt;", style->id, s, style->size); if (font_is_italic(style->font)) - fz_printf(out, "font-style:italic;"); + fz_printf(ctx, out, "font-style:italic;"); if (font_is_bold(style->font)) - fz_printf(out, "font-weight:bold;"); - fz_printf(out, "}\n"); + fz_printf(ctx, out, "font-weight:bold;"); + fz_printf(ctx, out, "}\n"); } void @@ -69,11 +69,11 @@ fz_print_text_sheet(fz_context *ctx, fz_output *out, fz_text_sheet *sheet) { fz_text_style *style; for (style = sheet->style; style; style = style->next) - fz_print_style(out, style); + fz_print_style(ctx, out, style); } static void -send_data_base64(fz_output *out, fz_buffer *buffer) +send_data_base64(fz_context *ctx, fz_output *out, fz_buffer *buffer) { int i, len; static const char set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; @@ -85,8 +85,8 @@ send_data_base64(fz_output *out, fz_buffer *buffer) int d = buffer->data[3*i+1]; int e = buffer->data[3*i+2]; if ((i & 15) == 0) - fz_printf(out, "\n"); - fz_printf(out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); + fz_printf(ctx, out, "\n"); + fz_printf(ctx, out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); } i *= 3; switch (buffer->len-i) @@ -95,13 +95,13 @@ send_data_base64(fz_output *out, fz_buffer *buffer) { int c = buffer->data[i]; int d = buffer->data[i+1]; - fz_printf(out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); + fz_printf(ctx, out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); break; } case 1: { int c = buffer->data[i]; - fz_printf(out, "%c%c==", set[c>>2], set[(c&3)<<4]); + fz_printf(ctx, out, "%c%c==", set[c>>2], set[(c&3)<<4]); break; } default: @@ -119,7 +119,7 @@ fz_print_text_page_html(fz_context *ctx, fz_output *out, fz_text_page *page) fz_text_span *span; void *last_region = NULL; - fz_printf(out, "<div class=\"page\">\n"); + fz_printf(ctx, out, "<div class=\"page\">\n"); for (block_n = 0; block_n < page->len; block_n++) { @@ -128,7 +128,7 @@ fz_print_text_page_html(fz_context *ctx, fz_output *out, fz_text_page *page) case FZ_PAGE_BLOCK_TEXT: { fz_text_block * block = page->blocks[block_n].u.text; - fz_printf(out, "<div class=\"block\"><p>\n"); + fz_printf(ctx, out, "<div class=\"block\"><p>\n"); for (line_n = 0; line_n < block->len; line_n++) { int lastcol=-1; @@ -138,16 +138,16 @@ fz_print_text_page_html(fz_context *ctx, fz_output *out, fz_text_page *page) if (line->region != last_region) { if (last_region) - fz_printf(out, "</div>"); - fz_printf(out, "<div class=\"metaline\">"); + fz_printf(ctx, out, "</div>"); + fz_printf(ctx, out, "<div class=\"metaline\">"); last_region = line->region; } - fz_printf(out, "<div class=\"line\""); + fz_printf(ctx, out, "<div class=\"line\""); #ifdef DEBUG_INTERNALS if (line->region) - fz_printf(out, " region=\"%x\"", line->region); + fz_printf(ctx, out, " region=\"%x\"", line->region); #endif - fz_printf(out, ">"); + fz_printf(ctx, out, ">"); for (span = line->first_span; span; span = span->next) { float size = fz_matrix_expansion(&span->transform); @@ -157,17 +157,17 @@ fz_print_text_page_html(fz_context *ctx, fz_output *out, fz_text_page *page) { if (lastcol >= 0) { - fz_printf(out, "</div>"); + fz_printf(ctx, out, "</div>"); } /* If we skipped any columns then output some spacer spans */ while (lastcol < span->column-1) { - fz_printf(out, "<div class=\"cell\"></div>"); + fz_printf(ctx, out, "<div class=\"cell\"></div>"); lastcol++; } lastcol++; /* Now output the span to contain this entire column */ - fz_printf(out, "<div class=\"cell\" style=\""); + fz_printf(ctx, out, "<div class=\"cell\" style=\""); { fz_text_span *sn; for (sn = span->next; sn; sn = sn->next) @@ -175,103 +175,103 @@ fz_print_text_page_html(fz_context *ctx, fz_output *out, fz_text_page *page) if (sn->column != lastcol) break; } - fz_printf(out, "width:%g%%;align:%s", span->column_width, (span->align == 0 ? "left" : (span->align == 1 ? "center" : "right"))); + fz_printf(ctx, out, "width:%g%%;align:%s", span->column_width, (span->align == 0 ? "left" : (span->align == 1 ? "center" : "right"))); } if (span->indent > 1) - fz_printf(out, ";padding-left:1em;text-indent:-1em"); + fz_printf(ctx, out, ";padding-left:1em;text-indent:-1em"); if (span->indent < -1) - fz_printf(out, ";text-indent:1em"); - fz_printf(out, "\">"); + fz_printf(ctx, out, ";text-indent:1em"); + fz_printf(ctx, out, "\">"); } #ifdef DEBUG_INTERNALS - fz_printf(out, "<span class=\"internal_span\""); + fz_printf(ctx, out, "<span class=\"internal_span\""); if (span->column) - fz_printf(out, " col=\"%x\"", span->column); - fz_printf(out, ">"); + fz_printf(ctx, out, " col=\"%x\"", span->column); + fz_printf(ctx, out, ">"); #endif if (span->spacing >= 1) - fz_printf(out, " "); + fz_printf(ctx, out, " "); if (base_offset > SUBSCRIPT_OFFSET) - fz_printf(out, "<sub>"); + fz_printf(ctx, out, "<sub>"); else if (base_offset < SUPERSCRIPT_OFFSET) - fz_printf(out, "<sup>"); + fz_printf(ctx, out, "<sup>"); for (ch_n = 0; ch_n < span->len; ch_n++) { fz_text_char *ch = &span->text[ch_n]; if (style != ch->style) { if (style) - fz_print_style_end(out, style); - fz_print_style_begin(out, ch->style); + fz_print_style_end(ctx, out, style); + fz_print_style_begin(ctx, out, ch->style); style = ch->style; } if (ch->c == '<') - fz_printf(out, "<"); + fz_printf(ctx, out, "<"); else if (ch->c == '>') - fz_printf(out, ">"); + fz_printf(ctx, out, ">"); else if (ch->c == '&') - fz_printf(out, "&"); + fz_printf(ctx, out, "&"); else if (ch->c >= 32 && ch->c <= 127) - fz_printf(out, "%c", ch->c); + fz_printf(ctx, out, "%c", ch->c); else - fz_printf(out, "&#x%x;", ch->c); + fz_printf(ctx, out, "&#x%x;", ch->c); } if (style) { - fz_print_style_end(out, style); + fz_print_style_end(ctx, out, style); style = NULL; } if (base_offset > SUBSCRIPT_OFFSET) - fz_printf(out, "</sub>"); + fz_printf(ctx, out, "</sub>"); else if (base_offset < SUPERSCRIPT_OFFSET) - fz_printf(out, "</sup>"); + fz_printf(ctx, out, "</sup>"); #ifdef DEBUG_INTERNALS - fz_printf(out, "</span>"); + fz_printf(ctx, out, "</span>"); #endif } /* Close our floating span */ - fz_printf(out, "</div>"); + fz_printf(ctx, out, "</div>"); /* Close the line */ - fz_printf(out, "</div>"); - fz_printf(out, "\n"); + fz_printf(ctx, out, "</div>"); + fz_printf(ctx, out, "\n"); } /* Close the metaline */ - fz_printf(out, "</div>"); + fz_printf(ctx, out, "</div>"); last_region = NULL; - fz_printf(out, "</p></div>\n"); + fz_printf(ctx, out, "</p></div>\n"); break; } case FZ_PAGE_BLOCK_IMAGE: { fz_image_block *image = page->blocks[block_n].u.image; - fz_printf(out, "<img width=%d height=%d src=\"data:", image->image->w, image->image->h); + fz_printf(ctx, out, "<img width=%d height=%d src=\"data:", image->image->w, image->image->h); switch (image->image->buffer == NULL ? FZ_IMAGE_JPX : image->image->buffer->params.type) { case FZ_IMAGE_JPEG: - fz_printf(out, "image/jpeg;base64,"); - send_data_base64(out, image->image->buffer->buffer); + fz_printf(ctx, out, "image/jpeg;base64,"); + send_data_base64(ctx, out, image->image->buffer->buffer); break; case FZ_IMAGE_PNG: - fz_printf(out, "image/png;base64,"); - send_data_base64(out, image->image->buffer->buffer); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, image->image->buffer->buffer); break; default: { fz_buffer *buf = fz_new_png_from_image(ctx, image->image, image->image->w, image->image->h); - fz_printf(out, "image/png;base64,"); - send_data_base64(out, buf); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, buf); fz_drop_buffer(ctx, buf); break; } } - fz_printf(out, "\">\n"); + fz_printf(ctx, out, "\">\n"); break; } } } - fz_printf(out, "</div>\n"); + fz_printf(ctx, out, "</div>\n"); } void @@ -279,7 +279,7 @@ fz_print_text_page_xml(fz_context *ctx, fz_output *out, fz_text_page *page) { int block_n; - fz_printf(out, "<page width=\"%g\" height=\"%g\">\n", + fz_printf(ctx, out, "<page width=\"%g\" height=\"%g\">\n", page->mediabox.x1 - page->mediabox.x0, page->mediabox.y1 - page->mediabox.y0); @@ -293,12 +293,12 @@ fz_print_text_page_xml(fz_context *ctx, fz_output *out, fz_text_page *page) fz_text_line *line; char *s; - fz_printf(out, "<block bbox=\"%g %g %g %g\">\n", + fz_printf(ctx, out, "<block bbox=\"%g %g %g %g\">\n", block->bbox.x0, block->bbox.y0, block->bbox.x1, block->bbox.y1); for (line = block->lines; line < block->lines + block->len; line++) { fz_text_span *span; - fz_printf(out, "<line bbox=\"%g %g %g %g\">\n", + fz_printf(ctx, out, "<line bbox=\"%g %g %g %g\">\n", line->bbox.x0, line->bbox.y0, line->bbox.x1, line->bbox.y1); for (span = line->first_span; span; span = span->next) { @@ -311,43 +311,43 @@ fz_print_text_page_xml(fz_context *ctx, fz_output *out, fz_text_page *page) { if (style) { - fz_printf(out, "</span>\n"); + fz_printf(ctx, out, "</span>\n"); } style = ch->style; s = strchr(style->font->name, '+'); s = s ? s + 1 : style->font->name; - fz_printf(out, "<span bbox=\"%g %g %g %g\" font=\"%s\" size=\"%g\">\n", + fz_printf(ctx, out, "<span bbox=\"%g %g %g %g\" font=\"%s\" size=\"%g\">\n", span->bbox.x0, span->bbox.y0, span->bbox.x1, span->bbox.y1, s, style->size); } { fz_rect rect; - fz_text_char_bbox(&rect, span, char_num); - fz_printf(out, "<char bbox=\"%g %g %g %g\" x=\"%g\" y=\"%g\" c=\"", + fz_text_char_bbox(ctx, &rect, span, char_num); + fz_printf(ctx, out, "<char bbox=\"%g %g %g %g\" x=\"%g\" y=\"%g\" c=\"", rect.x0, rect.y0, rect.x1, rect.y1, ch->p.x, ch->p.y); } switch (ch->c) { - case '<': fz_printf(out, "<"); break; - case '>': fz_printf(out, ">"); break; - case '&': fz_printf(out, "&"); break; - case '"': fz_printf(out, """); break; - case '\'': fz_printf(out, "'"); break; + case '<': fz_printf(ctx, out, "<"); break; + case '>': fz_printf(ctx, out, ">"); break; + case '&': fz_printf(ctx, out, "&"); break; + case '"': fz_printf(ctx, out, """); break; + case '\'': fz_printf(ctx, out, "'"); break; default: if (ch->c >= 32 && ch->c <= 127) - fz_printf(out, "%c", ch->c); + fz_printf(ctx, out, "%c", ch->c); else - fz_printf(out, "&#x%x;", ch->c); + fz_printf(ctx, out, "&#x%x;", ch->c); break; } - fz_printf(out, "\"/>\n"); + fz_printf(ctx, out, "\"/>\n"); } if (style) - fz_printf(out, "</span>\n"); + fz_printf(ctx, out, "</span>\n"); } - fz_printf(out, "</line>\n"); + fz_printf(ctx, out, "</line>\n"); } - fz_printf(out, "</block>\n"); + fz_printf(ctx, out, "</block>\n"); break; } case FZ_PAGE_BLOCK_IMAGE: @@ -356,7 +356,7 @@ fz_print_text_page_xml(fz_context *ctx, fz_output *out, fz_text_page *page) } } } - fz_printf(out, "</page>\n"); + fz_printf(ctx, out, "</page>\n"); } void @@ -385,12 +385,12 @@ fz_print_text_page(fz_context *ctx, fz_output *out, fz_text_page *page) { n = fz_runetochar(utf, ch->c); for (i = 0; i < n; i++) - fz_printf(out, "%c", utf[i]); + fz_printf(ctx, out, "%c", utf[i]); } } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); break; } case FZ_PAGE_BLOCK_IMAGE: diff --git a/source/fitz/stext-search.c b/source/fitz/stext-search.c index 29f51e64..475c0c8a 100644 --- a/source/fitz/stext-search.c +++ b/source/fitz/stext-search.c @@ -14,7 +14,7 @@ static inline int iswhite(int c) return c == ' ' || c == '\r' || c == '\n' || c == '\t' || c == 0xA0 || c == 0x2028 || c == 0x2029; } -fz_char_and_box *fz_text_char_at(fz_char_and_box *cab, fz_text_page *page, int idx) +fz_char_and_box *fz_text_char_at(fz_context *ctx, fz_char_and_box *cab, fz_text_page *page, int idx) { int block_num; int ofs = 0; @@ -35,7 +35,7 @@ fz_char_and_box *fz_text_char_at(fz_char_and_box *cab, fz_text_page *page, int i if (idx < ofs + span->len) { cab->c = span->text[idx - ofs].c; - fz_text_char_bbox(&cab->bbox, span, idx - ofs); + fz_text_char_bbox(ctx, &cab->bbox, span, idx - ofs); return cab; } ofs += span->len; @@ -55,21 +55,21 @@ fz_char_and_box *fz_text_char_at(fz_char_and_box *cab, fz_text_page *page, int i return cab; } -static int charat(fz_text_page *page, int idx) +static int charat(fz_context *ctx, fz_text_page *page, int idx) { fz_char_and_box cab; - return fz_text_char_at(&cab, page, idx)->c; + return fz_text_char_at(ctx, &cab, page, idx)->c; } -static fz_rect *bboxat(fz_text_page *page, int idx, fz_rect *bbox) +static fz_rect *bboxat(fz_context *ctx, fz_text_page *page, int idx, fz_rect *bbox) { fz_char_and_box cab; /* FIXME: Nasty extra copy */ - *bbox = fz_text_char_at(&cab, page, idx)->bbox; + *bbox = fz_text_char_at(ctx, &cab, page, idx)->bbox; return bbox; } -static int textlen(fz_text_page *page) +static int textlen(fz_context *ctx, fz_text_page *page) { int len = 0; int block_num; @@ -95,21 +95,21 @@ static int textlen(fz_text_page *page) return len; } -static int match(fz_text_page *page, const char *s, int n) +static int match(fz_context *ctx, fz_text_page *page, const char *s, int n) { int orig = n; int c; while (*s) { s += fz_chartorune(&c, (char *)s); - if (iswhite(c) && iswhite(charat(page, n))) + if (iswhite(c) && iswhite(charat(ctx, page, n))) { const char *s_next; /* Skip over whitespace in the document */ do n++; - while (iswhite(charat(page, n))); + while (iswhite(charat(ctx, page, n))); /* Skip over multiple whitespace in the search string */ while (s_next = s + fz_chartorune(&c, (char *)s), iswhite(c)) @@ -117,7 +117,7 @@ static int match(fz_text_page *page, const char *s, int n) } else { - if (fz_tolower(c) != fz_tolower(charat(page, n))) + if (fz_tolower(c) != fz_tolower(charat(ctx, page, n))) return 0; n++; } @@ -134,17 +134,17 @@ fz_search_text_page(fz_context *ctx, fz_text_page *text, const char *needle, fz_ return 0; hit_count = 0; - len = textlen(text); + len = textlen(ctx, text); for (pos = 0; pos < len; pos++) { - n = match(text, needle, pos); + n = match(ctx, text, needle, pos); if (n) { fz_rect linebox = fz_empty_rect; for (i = 0; i < n; i++) { fz_rect charbox; - bboxat(text, pos + i, &charbox); + bboxat(ctx, text, pos + i, &charbox); if (!fz_is_empty_rect(&charbox)) { if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5) @@ -195,7 +195,7 @@ fz_highlight_selection(fz_context *ctx, fz_text_page *page, fz_rect rect, fz_rec { for (i = 0; i < span->len; i++) { - fz_text_char_bbox(&charbox, span, i); + fz_text_char_bbox(ctx, &charbox, span, i); if (charbox.x1 >= x0 && charbox.x0 <= x1 && charbox.y1 >= y0 && charbox.y0 <= y1) { if (charbox.y0 != linebox.y0 || fz_abs(charbox.x0 - linebox.x1) > 5) @@ -256,7 +256,7 @@ fz_copy_selection(fz_context *ctx, fz_text_page *page, fz_rect rect) for (i = 0; i < span->len; i++) { - fz_text_char_bbox(&hitbox, span, i); + fz_text_char_bbox(ctx, &hitbox, span, i); c = span->text[i].c; if (c < 32) c = '?'; diff --git a/source/fitz/store.c b/source/fitz/store.c index 315f8e81..d4cafe15 100644 --- a/source/fitz/store.c +++ b/source/fitz/store.c @@ -114,7 +114,7 @@ evict(fz_context *ctx, fz_item *item) { fz_store_hash hash = { NULL }; hash.drop = item->val->drop; - if (item->type->make_hash_key(&hash, item->key)) + if (item->type->make_hash_key(ctx, &hash, item->key)) fz_hash_remove(ctx, store->hash, &hash); } fz_unlock(ctx, FZ_LOCK_ALLOC); @@ -251,7 +251,7 @@ fz_store_item(fz_context *ctx, void *key, void *val_, unsigned int itemsize, fz_ if (type->make_hash_key) { hash.drop = val->drop; - use_hash = type->make_hash_key(&hash, key); + use_hash = type->make_hash_key(ctx, &hash, key); } type->keep_key(ctx, key); @@ -363,7 +363,7 @@ fz_find_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, fz_store_type * if (type->make_hash_key) { hash.drop = drop; - use_hash = type->make_hash_key(&hash, key); + use_hash = type->make_hash_key(ctx, &hash, key); } fz_lock(ctx, FZ_LOCK_ALLOC); @@ -377,7 +377,7 @@ fz_find_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, fz_store_type * /* Others we have to hunt for slowly */ for (item = store->head; item; item = item->next) { - if (item->val->drop == drop && !type->cmp_key(item->key, key)) + if (item->val->drop == drop && !type->cmp_key(ctx, item->key, key)) break; } } @@ -411,7 +411,7 @@ fz_remove_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, fz_store_type if (type->make_hash_key) { hash.drop = drop; - use_hash = type->make_hash_key(&hash, key); + use_hash = type->make_hash_key(ctx, &hash, key); } fz_lock(ctx, FZ_LOCK_ALLOC); @@ -426,7 +426,7 @@ fz_remove_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, fz_store_type { /* Others we have to hunt for slowly */ for (item = store->head; item; item = item->next) - if (item->val->drop == drop && !type->cmp_key(item->key, key)) + if (item->val->drop == drop && !type->cmp_key(ctx, item->key, key)) break; } if (item) @@ -527,7 +527,7 @@ fz_print_store_locked(fz_context *ctx, FILE *out) next->val->refs++; fprintf(out, "store[*][refs=%d][size=%d] ", item->val->refs, item->size); fz_unlock(ctx, FZ_LOCK_ALLOC); - item->type->debug(out, item->key); + item->type->debug(ctx, out, item->key); fprintf(out, " = %p\n", item->val); fflush(out); fz_lock(ctx, FZ_LOCK_ALLOC); diff --git a/source/fitz/stream-open.c b/source/fitz/stream-open.c index c5808a73..fe8fc443 100644 --- a/source/fitz/stream-open.c +++ b/source/fitz/stream-open.c @@ -1,20 +1,7 @@ #include "mupdf/fitz.h" -void fz_rebind_stream(fz_stream *stm, fz_context *ctx) -{ - if (stm == NULL || stm->ctx == ctx) - return; - do { - stm->ctx = ctx; - stm = (stm->rebind == NULL ? NULL : stm->rebind(stm)); - } while (stm != NULL); -} - fz_stream * -fz_new_stream(fz_context *ctx, void *state, - fz_stream_next_fn *next, - fz_stream_close_fn *close, - fz_stream_rebind_fn *rebind) +fz_new_stream(fz_context *ctx, void *state, fz_stream_next_fn *next, fz_stream_close_fn *close) { fz_stream *stm; @@ -43,14 +30,12 @@ fz_new_stream(fz_context *ctx, void *state, stm->next = next; stm->close = close; stm->seek = NULL; - stm->rebind = rebind; - stm->ctx = ctx; return stm; } fz_stream * -fz_keep_stream(fz_stream *stm) +fz_keep_stream(fz_context *ctx, fz_stream *stm) { if (stm) stm->refs ++; @@ -58,7 +43,7 @@ fz_keep_stream(fz_stream *stm) } void -fz_drop_stream(fz_stream *stm) +fz_drop_stream(fz_context *ctx, fz_stream *stm) { if (!stm) return; @@ -66,8 +51,8 @@ fz_drop_stream(fz_stream *stm) if (stm->refs == 0) { if (stm->close) - stm->close(stm->ctx, stm->state); - fz_free(stm->ctx, stm); + stm->close(ctx, stm->state); + fz_free(ctx, stm); } } @@ -79,14 +64,14 @@ typedef struct fz_file_stream_s unsigned char buffer[4096]; } fz_file_stream; -static int next_file(fz_stream *stm, int n) +static int next_file(fz_context *ctx, fz_stream *stm, int n) { fz_file_stream *state = stm->state; /* n is only a hint, that we can safely ignore */ n = read(state->file, state->buffer, sizeof(state->buffer)); if (n < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "read error: %s", strerror(errno)); + fz_throw(ctx, FZ_ERROR_GENERIC, "read error: %s", strerror(errno)); stm->rp = state->buffer; stm->wp = state->buffer + n; stm->pos += n; @@ -96,12 +81,12 @@ static int next_file(fz_stream *stm, int n) return *stm->rp++; } -static void seek_file(fz_stream *stm, int offset, int whence) +static void seek_file(fz_context *ctx, fz_stream *stm, int offset, int whence) { fz_file_stream *state = stm->state; int n = lseek(state->file, offset, whence); if (n < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "cannot lseek: %s", strerror(errno)); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot lseek: %s", strerror(errno)); stm->pos = n; stm->rp = state->buffer; stm->wp = state->buffer; @@ -125,7 +110,7 @@ fz_open_fd(fz_context *ctx, int fd) fz_try(ctx) { - stm = fz_new_stream(ctx, state, next_file, close_file, NULL); + stm = fz_new_stream(ctx, state, next_file, close_file); } fz_catch(ctx) { @@ -173,12 +158,12 @@ fz_open_file_w(fz_context *ctx, const wchar_t *name) /* Memory stream */ -static int next_buffer(fz_stream *stm, int max) +static int next_buffer(fz_context *ctx, fz_stream *stm, int max) { return EOF; } -static void seek_buffer(fz_stream *stm, int offset, int whence) +static void seek_buffer(fz_context *ctx, fz_stream *stm, int offset, int whence) { int pos = stm->pos - (stm->wp - stm->rp); /* Convert to absolute pos */ @@ -211,7 +196,7 @@ fz_open_buffer(fz_context *ctx, fz_buffer *buf) fz_stream *stm; fz_keep_buffer(ctx, buf); - stm = fz_new_stream(ctx, buf, next_buffer, close_buffer, NULL); + stm = fz_new_stream(ctx, buf, next_buffer, close_buffer); stm->seek = seek_buffer; stm->rp = buf->data; @@ -227,7 +212,7 @@ fz_open_memory(fz_context *ctx, unsigned char *data, int len) { fz_stream *stm; - stm = fz_new_stream(ctx, NULL, next_buffer, close_buffer, NULL); + stm = fz_new_stream(ctx, NULL, next_buffer, close_buffer); stm->seek = seek_buffer; stm->rp = data; diff --git a/source/fitz/stream-prog.c b/source/fitz/stream-prog.c index 01f3e5ef..fbf42666 100644 --- a/source/fitz/stream-prog.c +++ b/source/fitz/stream-prog.c @@ -27,7 +27,7 @@ typedef struct prog_state unsigned char buffer[4096]; } prog_state; -static int next_prog(fz_stream *stm, int len) +static int next_prog(fz_context *ctx, fz_stream *stm, int len) { prog_state *ps = (prog_state *)stm->state; int n; @@ -50,14 +50,14 @@ static int next_prog(fz_stream *stm, int len) if (len <= 0) { show_progress(av, stm->pos); - fz_throw(stm->ctx, FZ_ERROR_TRYLATER, "Not enough data yet"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "Not enough data yet"); } } } n = (len > 0 ? read(ps->fd, buf, len) : 0); if (n < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "read error: %s", strerror(errno)); + fz_throw(ctx, FZ_ERROR_GENERIC, "read error: %s", strerror(errno)); stm->rp = ps->buffer + stm->pos; stm->wp = ps->buffer + stm->pos + n; stm->pos += n; @@ -66,7 +66,7 @@ static int next_prog(fz_stream *stm, int len) return *stm->rp++; } -static void seek_prog(fz_stream *stm, int offset, int whence) +static void seek_prog(fz_context *ctx, fz_stream *stm, int offset, int whence) { prog_state *ps = (prog_state *)stm->state; int n; @@ -84,7 +84,7 @@ static void seek_prog(fz_stream *stm, int offset, int whence) if (whence == SEEK_END) { show_progress(ps->available, ps->length); - fz_throw(stm->ctx, FZ_ERROR_TRYLATER, "Not enough data to seek to end yet"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "Not enough data to seek to end yet"); } } if (whence == SEEK_CUR) @@ -94,7 +94,7 @@ static void seek_prog(fz_stream *stm, int offset, int whence) if (offset > ps->available) { show_progress(ps->available, offset); - fz_throw(stm->ctx, FZ_ERROR_TRYLATER, "Not enough data to seek (relatively) to offset yet"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "Not enough data to seek (relatively) to offset yet"); } } if (whence == SEEK_SET) @@ -102,13 +102,13 @@ static void seek_prog(fz_stream *stm, int offset, int whence) if (offset > ps->available) { show_progress(ps->available, offset); - fz_throw(stm->ctx, FZ_ERROR_TRYLATER, "Not enough data to seek to offset yet"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "Not enough data to seek to offset yet"); } } n = lseek(ps->fd, offset, whence); if (n < 0) - fz_throw(stm->ctx, FZ_ERROR_GENERIC, "cannot lseek: %s", strerror(errno)); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot lseek: %s", strerror(errno)); stm->pos = n; stm->wp = stm->rp; } @@ -122,7 +122,7 @@ static void close_prog(fz_context *ctx, void *state) fz_free(ctx, state); } -static int meta_prog(fz_stream *stm, int key, int size, void *ptr) +static int meta_prog(fz_context *ctx, fz_stream *stm, int key, int size, void *ptr) { prog_state *ps = (prog_state *)stm->state; switch(key) @@ -153,7 +153,7 @@ fz_open_fd_progressive(fz_context *ctx, int fd, int bps) fz_try(ctx) { - stm = fz_new_stream(ctx, state, next_prog, close_prog, NULL); + stm = fz_new_stream(ctx, state, next_prog, close_prog); } fz_catch(ctx) { diff --git a/source/fitz/stream-read.c b/source/fitz/stream-read.c index 49e1c1a3..75261ea5 100644 --- a/source/fitz/stream-read.c +++ b/source/fitz/stream-read.c @@ -3,14 +3,14 @@ #define MIN_BOMB (100 << 20) int -fz_read(fz_stream *stm, unsigned char *buf, int len) +fz_read(fz_context *ctx, fz_stream *stm, unsigned char *buf, int len) { int count, n; count = 0; do { - n = fz_available(stm, len); + n = fz_available(ctx, stm, len); if (n > len) n = len; if (n == 0) @@ -28,17 +28,16 @@ fz_read(fz_stream *stm, unsigned char *buf, int len) } fz_buffer * -fz_read_all(fz_stream *stm, int initial) +fz_read_all(fz_context *ctx, fz_stream *stm, int initial) { - return fz_read_best(stm, initial, NULL); + return fz_read_best(ctx, stm, initial, NULL); } fz_buffer * -fz_read_best(fz_stream *stm, int initial, int *truncated) +fz_read_best(fz_context *ctx, fz_stream *stm, int initial, int *truncated) { fz_buffer *buf = NULL; int n; - fz_context *ctx = stm->ctx; fz_var(buf); @@ -62,7 +61,7 @@ fz_read_best(fz_stream *stm, int initial, int *truncated) fz_throw(ctx, FZ_ERROR_GENERIC, "compression bomb detected"); } - n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len); + n = fz_read(ctx, stm, buf->data + buf->len, buf->cap - buf->len); if (n == 0) break; @@ -91,19 +90,19 @@ fz_read_best(fz_stream *stm, int initial, int *truncated) } void -fz_read_line(fz_stream *stm, char *mem, int n) +fz_read_line(fz_context *ctx, fz_stream *stm, char *mem, int n) { char *s = mem; int c = EOF; while (n > 1) { - c = fz_read_byte(stm); + c = fz_read_byte(ctx, stm); if (c == EOF) break; if (c == '\r') { - c = fz_peek_byte(stm); + c = fz_peek_byte(ctx, stm); if (c == '\n') - fz_read_byte(stm); + fz_read_byte(ctx, stm); break; } if (c == '\n') @@ -116,50 +115,50 @@ fz_read_line(fz_stream *stm, char *mem, int n) } int -fz_tell(fz_stream *stm) +fz_tell(fz_context *ctx, fz_stream *stm) { return stm->pos - (stm->wp - stm->rp); } void -fz_seek(fz_stream *stm, int offset, int whence) +fz_seek(fz_context *ctx, fz_stream *stm, int offset, int whence) { stm->avail = 0; /* Reset bit reading */ if (stm->seek) { if (whence == 1) { - offset = fz_tell(stm) + offset; + offset = fz_tell(ctx, stm) + offset; whence = 0; } - stm->seek(stm, offset, whence); + stm->seek(ctx, stm, offset, whence); stm->eof = 0; } else if (whence != 2) { if (whence == 0) - offset -= fz_tell(stm); + offset -= fz_tell(ctx, stm); if (offset < 0) - fz_warn(stm->ctx, "cannot seek backwards"); + fz_warn(ctx, "cannot seek backwards"); /* dog slow, but rare enough */ while (offset-- > 0) { - if (fz_read_byte(stm) == EOF) + if (fz_read_byte(ctx, stm) == EOF) { - fz_warn(stm->ctx, "seek failed"); + fz_warn(ctx, "seek failed"); break; } } } else - fz_warn(stm->ctx, "cannot seek"); + fz_warn(ctx, "cannot seek"); } -int fz_stream_meta(fz_stream *stm, int key, int size, void *ptr) +int fz_stream_meta(fz_context *ctx, fz_stream *stm, int key, int size, void *ptr) { if (!stm || !stm->meta) return -1; - return stm->meta(stm, key, size, ptr); + return stm->meta(ctx, stm, key, size, ptr); } fz_buffer * @@ -173,11 +172,11 @@ fz_read_file(fz_context *ctx, const char *filename) stm = fz_open_file(ctx, filename); fz_try(ctx) { - buf = fz_read_all(stm, 0); + buf = fz_read_all(ctx, stm, 0); } fz_always(ctx) { - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); } fz_catch(ctx) { diff --git a/source/fitz/svg-device.c b/source/fitz/svg-device.c index b4e10fe4..29acc530 100644 --- a/source/fitz/svg-device.c +++ b/source/fitz/svg-device.c @@ -31,7 +31,6 @@ struct font_s struct svg_device_s { - fz_context *ctx; fz_output *out; fz_output *out_store; fz_output *defs; @@ -53,7 +52,7 @@ struct svg_device_s * so we have to delay definitions until after the symbol definition ends. */ static fz_output * -start_def(svg_device *sdev) +start_def(fz_context *ctx, svg_device *sdev) { sdev->def_count++; if (sdev->def_count == 2) @@ -61,8 +60,8 @@ start_def(svg_device *sdev) if (sdev->defs == NULL) { if (sdev->defs_buffer == NULL) - sdev->defs_buffer = fz_new_buffer(sdev->ctx, 1024); - sdev->defs = fz_new_output_with_buffer(sdev->ctx, sdev->defs_buffer); + sdev->defs_buffer = fz_new_buffer(ctx, 1024); + sdev->defs = fz_new_output_with_buffer(ctx, sdev->defs_buffer); } sdev->out = sdev->defs; } @@ -70,7 +69,7 @@ start_def(svg_device *sdev) } static fz_output * -end_def(svg_device *sdev) +end_def(fz_context *ctx, svg_device *sdev) { if (sdev->def_count > 0) sdev->def_count--; @@ -78,7 +77,7 @@ end_def(svg_device *sdev) sdev->out = sdev->out_store; if (sdev->def_count == 0 && sdev->defs_buffer != NULL) { - fz_write(sdev->out, sdev->defs_buffer->data, sdev->defs_buffer->len); + fz_write(ctx, sdev->out, sdev->defs_buffer->data, sdev->defs_buffer->len); sdev->defs_buffer->len = 0; } return sdev->out; @@ -87,12 +86,12 @@ end_def(svg_device *sdev) /* Helper functions */ static void -svg_dev_path(svg_device *sdev, fz_path *path) +svg_dev_path(fz_context *ctx, svg_device *sdev, fz_path *path) { fz_output *out = sdev->out; float x, y; int i, k; - fz_printf(out, " d=\""); + fz_printf(ctx, out, " d=\""); for (i = 0, k = 0; i < path->cmd_len; i++) { switch (path->cmds[i]) @@ -100,46 +99,46 @@ svg_dev_path(svg_device *sdev, fz_path *path) case FZ_MOVETO: x = path->coords[k++]; y = path->coords[k++]; - fz_printf(out, "M %g %g ", x, y); + fz_printf(ctx, out, "M %g %g ", x, y); break; case FZ_LINETO: x = path->coords[k++]; y = path->coords[k++]; - fz_printf(out, "L %g %g ", x, y); + fz_printf(ctx, out, "L %g %g ", x, y); break; case FZ_CURVETO: x = path->coords[k++]; y = path->coords[k++]; - fz_printf(out, "C %g %g ", x, y); + fz_printf(ctx, out, "C %g %g ", x, y); x = path->coords[k++]; y = path->coords[k++]; - fz_printf(out, "%g %g ", x, y); + fz_printf(ctx, out, "%g %g ", x, y); x = path->coords[k++]; y = path->coords[k++]; - fz_printf(out, "%g %g ", x, y); + fz_printf(ctx, out, "%g %g ", x, y); break; case FZ_CLOSE_PATH: - fz_printf(out, "Z "); + fz_printf(ctx, out, "Z "); break; } } - fz_printf(out, "\""); + fz_printf(ctx, out, "\""); } static void -svg_dev_ctm(svg_device *sdev, const fz_matrix *ctm) +svg_dev_ctm(fz_context *ctx, svg_device *sdev, const fz_matrix *ctm) { fz_output *out = sdev->out; if (ctm->a != 1.0 || ctm->b != 0 || ctm->c != 0 || ctm->d != 1.0 || ctm->e != 0 || ctm->f != 0) { - fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + fz_printf(ctx, out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", ctm->a, ctm->b, ctm->c, ctm->d, ctm->e, ctm->f); } } static void -svg_dev_stroke_state(svg_device *sdev, fz_stroke_state *stroke_state, const fz_matrix *ctm) +svg_dev_stroke_state(fz_context *ctx, svg_device *sdev, fz_stroke_state *stroke_state, const fz_matrix *ctm) { fz_output *out = sdev->out; float exp; @@ -148,31 +147,30 @@ svg_dev_stroke_state(svg_device *sdev, fz_stroke_state *stroke_state, const fz_m if (exp == 0) exp = 1; - fz_printf(out, " stroke-width=\"%g\"", stroke_state->linewidth/exp); - fz_printf(out, " stroke-linecap=\"%s\"", + fz_printf(ctx, out, " stroke-width=\"%g\"", stroke_state->linewidth/exp); + fz_printf(ctx, out, " stroke-linecap=\"%s\"", (stroke_state->start_cap == FZ_LINECAP_SQUARE ? "square" : (stroke_state->start_cap == FZ_LINECAP_ROUND ? "round" : "butt"))); if (stroke_state->dash_len != 0) { int i; - fz_printf(out, " stroke-dasharray="); + fz_printf(ctx, out, " stroke-dasharray="); for (i = 0; i < stroke_state->dash_len; i++) - fz_printf(out, "%c%g", (i == 0 ? '\"' : ','), stroke_state->dash_list[i]); - fz_printf(out, "\""); + fz_printf(ctx, out, "%c%g", (i == 0 ? '\"' : ','), stroke_state->dash_list[i]); + fz_printf(ctx, out, "\""); if (stroke_state->dash_phase != 0) - fz_printf(out, " stroke-dashoffset=\"%g\"", stroke_state->dash_phase); + fz_printf(ctx, out, " stroke-dashoffset=\"%g\"", stroke_state->dash_phase); } if (stroke_state->linejoin == FZ_LINEJOIN_MITER || stroke_state->linejoin == FZ_LINEJOIN_MITER_XPS) - fz_printf(out, " stroke-miterlimit=\"%g\"", stroke_state->miterlimit); - fz_printf(out, " stroke-linejoin=\"%s\"", + fz_printf(ctx, out, " stroke-miterlimit=\"%g\"", stroke_state->miterlimit); + fz_printf(ctx, out, " stroke-linejoin=\"%s\"", (stroke_state->linejoin == FZ_LINEJOIN_BEVEL ? "bevel" : (stroke_state->linejoin == FZ_LINEJOIN_ROUND ? "round" : "miter"))); } static void -svg_dev_fill_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +svg_dev_fill_color(fz_context *ctx, svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) { - fz_context *ctx = sdev->ctx; fz_output *out = sdev->out; float rgb[FZ_MAX_COLORS]; @@ -188,15 +186,14 @@ svg_dev_fill_color(svg_device *sdev, fz_colorspace *colorspace, float *color, fl /* don't send a fill, as it will be assumed to be black */ } else - fz_printf(out, " fill=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + fz_printf(ctx, out, " fill=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); if (alpha != 1) - fz_printf(out, " fill-opacity=\"%g\"", alpha); + fz_printf(ctx, out, " fill-opacity=\"%g\"", alpha); } static void -svg_dev_stroke_color(svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) +svg_dev_stroke_color(fz_context *ctx, svg_device *sdev, fz_colorspace *colorspace, float *color, float alpha) { - fz_context *ctx = sdev->ctx; fz_output *out = sdev->out; float rgb[FZ_MAX_COLORS]; @@ -207,9 +204,9 @@ svg_dev_stroke_color(svg_device *sdev, fz_colorspace *colorspace, float *color, color = rgb; } - fz_printf(out, " fill=\"none\" stroke=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); + fz_printf(ctx, out, " fill=\"none\" stroke=\"rgb(%d,%d,%d)\"", (int)(255*color[0] + 0.5), (int)(255*color[1] + 0.5), (int)(255*color[2]+0.5)); if (alpha != 1) - fz_printf(out, " stroke-opacity=\"%g\"", alpha); + fz_printf(ctx, out, " stroke-opacity=\"%g\"", alpha); } static inline int @@ -222,9 +219,10 @@ is_xml_wspace(int c) } static void -svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) +svg_dev_text(fz_context *ctx, svg_device *sdev, const fz_matrix *ctm, fz_text *text) { fz_output *out = sdev->out; + int i; fz_matrix inverse; fz_matrix local_trm; @@ -242,10 +240,10 @@ svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) fz_invert_matrix(&inverse, &local_trm); fz_concat(&local_trm, &local_trm, ctm); - fz_printf(out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", + fz_printf(ctx, out, " transform=\"matrix(%g,%g,%g,%g,%g,%g)\"", local_trm.a, local_trm.b, local_trm.c, local_trm.d, local_trm.e, local_trm.f); - fz_printf(out, " font-size=\"%g\"", size); - fz_printf(out, " font-family=\"%s\"", text->font->name); + fz_printf(ctx, out, " font-size=\"%g\"", size); + fz_printf(ctx, out, " font-family=\"%s\"", text->font->name); /* Leading (and repeated) whitespace presents a problem for SVG * text, so elide it here. */ @@ -256,7 +254,7 @@ svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) break; } - fz_printf(out, " x="); + fz_printf(ctx, out, " x="); was_wspace = 0; for (i=start; i < text->len; i++) { @@ -269,9 +267,9 @@ svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) p.x = it->x; p.y = it->y; fz_transform_point(&p, &inverse); - fz_printf(out, "%c%g", i == start ? '\"' : ' ', p.x); + fz_printf(ctx, out, "%c%g", i == start ? '\"' : ' ', p.x); } - fz_printf(out, "\" y="); + fz_printf(ctx, out, "\" y="); was_wspace = 0; for (i=start; i < text->len; i++) { @@ -284,9 +282,9 @@ svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) p.x = it->x; p.y = it->y; fz_transform_point(&p, &inverse); - fz_printf(out, "%c%g", i == start ? '\"' : ' ', p.y); + fz_printf(ctx, out, "%c%g", i == start ? '\"' : ' ', p.y); } - fz_printf(out, "\">\n"); + fz_printf(ctx, out, "\">\n"); was_wspace = 0; for (i=start; i < text->len; i++) { @@ -297,18 +295,17 @@ svg_dev_text(svg_device *sdev, const fz_matrix *ctm, fz_text *text) continue; was_wspace = is_wspace; if (c >= 32 && c <= 127 && c != '<' && c != '&') - fz_printf(out, "%c", c); + fz_printf(ctx, out, "%c", c); else - fz_printf(out, "&#x%04x;", c); + fz_printf(ctx, out, "&#x%04x;", c); } - fz_printf(out, "\n</text>\n"); + fz_printf(ctx, out, "\n</text>\n"); } static font * -svg_dev_text_as_paths_defs(fz_device *dev, fz_text *text, const fz_matrix *ctm) +svg_dev_text_as_paths_defs(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { svg_device *sdev = dev->user; - fz_context *ctx = sdev->ctx; fz_output *out = sdev->out; int i, font_idx; font *fnt; @@ -360,30 +357,30 @@ svg_dev_text_as_paths_defs(fz_device *dev, fz_text *text, const fz_matrix *ctm) /* Need to send this one */ fz_rect rect; fz_path *path; - path = fz_outline_glyph(sdev->ctx, text->font, gid, &fz_identity); + path = fz_outline_glyph(ctx, text->font, gid, &fz_identity); if (path) { fz_bound_path(ctx, path, NULL, &fz_identity, &rect); shift.e = -rect.x0; shift.f = -rect.y0; fz_transform_path(ctx, path, &shift); - out = start_def(sdev); - fz_printf(out, "<symbol id=\"font_%x_%x\">", fnt->id, gid); - fz_printf(out, "<path"); - svg_dev_path(sdev, path); - fz_printf(out, "/>\n"); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<symbol id=\"font_%x_%x\">", fnt->id, gid); + fz_printf(ctx, out, "<path"); + svg_dev_path(ctx, sdev, path); + fz_printf(ctx, out, "/>\n"); } else { fz_bound_glyph(ctx, text->font, gid, &fz_identity, &rect); shift.e = -rect.x0; shift.f = -rect.y0; - out = start_def(sdev); - fz_printf(out, "<symbol id=\"font_%x_%x\">", fnt->id, gid); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<symbol id=\"font_%x_%x\">", fnt->id, gid); fz_run_t3_glyph(ctx, text->font, gid, &shift, dev); } - fz_printf(out, "</symbol>"); - out = end_def(sdev); + fz_printf(ctx, out, "</symbol>"); + out = end_def(ctx, sdev); fnt->sentlist[gid].x_off = rect.x0; fnt->sentlist[gid].y_off = rect.y0; } @@ -392,11 +389,12 @@ svg_dev_text_as_paths_defs(fz_device *dev, fz_text *text, const fz_matrix *ctm) } static void -svg_dev_text_as_paths_fill(fz_device *dev, fz_text *text, const fz_matrix *ctm, +svg_dev_text_as_paths_fill(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha, font *fnt) { svg_device *sdev = dev->user; fz_output *out = sdev->out; + fz_matrix local_trm, local_trm2; int i; fz_matrix shift = { 1, 0, 0, 1, 0, 0}; @@ -423,20 +421,21 @@ svg_dev_text_as_paths_fill(fz_device *dev, fz_text *text, const fz_matrix *ctm, local_trm.f = it->y; fz_concat(&local_trm2, &local_trm, ctm); fz_concat(&local_trm2, &shift, &local_trm2); - fz_printf(out, "<use xlink:href=\"#font_%x_%x\"", fnt->id, gid); - svg_dev_ctm(sdev, &local_trm2); - svg_dev_fill_color(sdev, colorspace, color, alpha); - fz_printf(out, "/>\n"); + fz_printf(ctx, out, "<use xlink:href=\"#font_%x_%x\"", fnt->id, gid); + svg_dev_ctm(ctx, sdev, &local_trm2); + svg_dev_fill_color(ctx, sdev, colorspace, color, alpha); + fz_printf(ctx, out, "/>\n"); } } static void -svg_dev_text_as_paths_stroke(fz_device *dev, fz_text *text, +svg_dev_text_as_paths_stroke(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha, font *fnt) { svg_device *sdev = dev->user; fz_output *out = sdev->out; + fz_matrix local_trm, local_trm2; int i; fz_matrix shift = { 1, 0, 0, 1, 0, 0}; @@ -463,127 +462,130 @@ svg_dev_text_as_paths_stroke(fz_device *dev, fz_text *text, local_trm.f = it->y; fz_concat(&local_trm2, &local_trm, ctm); fz_concat(&local_trm2, &shift, &local_trm2); - fz_printf(out, "<use xlink:href=\"#font_%x_%x\"", fnt->id, gid); - svg_dev_stroke_state(sdev, stroke, &local_trm2); - svg_dev_ctm(sdev, &local_trm2); - svg_dev_stroke_color(sdev, colorspace, color, alpha); - fz_printf(out, "/>\n"); + fz_printf(ctx, out, "<use xlink:href=\"#font_%x_%x\"", fnt->id, gid); + svg_dev_stroke_state(ctx, sdev, stroke, &local_trm2); + svg_dev_ctm(ctx, sdev, &local_trm2); + svg_dev_stroke_color(ctx, sdev, colorspace, color, alpha); + fz_printf(ctx, out, "/>\n"); } } /* Entry points */ static void -svg_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +svg_dev_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { svg_device *sdev = dev->user; fz_output *out = sdev->out; - fz_printf(out, "<path"); - svg_dev_ctm(sdev, ctm); - svg_dev_path(sdev, path); - svg_dev_fill_color(sdev, colorspace, color, alpha); + fz_printf(ctx, out, "<path"); + svg_dev_ctm(ctx, sdev, ctm); + svg_dev_path(ctx, sdev, path); + svg_dev_fill_color(ctx, sdev, colorspace, color, alpha); if (even_odd) - fz_printf(out, " fill-rule=\"evenodd\""); - fz_printf(out, "/>\n"); + fz_printf(ctx, out, " fill-rule=\"evenodd\""); + fz_printf(ctx, out, "/>\n"); } static void -svg_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +svg_dev_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { svg_device *sdev = dev->user; fz_output *out = sdev->out; - fz_printf(out, "<path"); - svg_dev_ctm(sdev, ctm); - svg_dev_stroke_state(sdev, stroke, &fz_identity); - svg_dev_stroke_color(sdev, colorspace, color, alpha); - svg_dev_path(sdev, path); - fz_printf(out, "/>\n"); + fz_printf(ctx, out, "<path"); + svg_dev_ctm(ctx, sdev, ctm); + svg_dev_stroke_state(ctx, sdev, stroke, &fz_identity); + svg_dev_stroke_color(ctx, sdev, colorspace, color, alpha); + svg_dev_path(ctx, sdev, path); + fz_printf(ctx, out, "/>\n"); } static void -svg_dev_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +svg_dev_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { svg_device *sdev = dev->user; fz_output *out; + int num = sdev->id++; - out = start_def(sdev); - fz_printf(out, "<clipPath id=\"cp%d\">\n", num); - fz_printf(out, "<path"); - svg_dev_ctm(sdev, ctm); - svg_dev_path(sdev, path); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<clipPath id=\"cp%d\">\n", num); + fz_printf(ctx, out, "<path"); + svg_dev_ctm(ctx, sdev, ctm); + svg_dev_path(ctx, sdev, path); if (even_odd) - fz_printf(out, " fill-rule=\"evenodd\""); - fz_printf(out, "/>\n</clipPath>\n"); - out = end_def(sdev); - fz_printf(out, "<g clip-path=\"url(#cp%d)\">\n", num); + fz_printf(ctx, out, " fill-rule=\"evenodd\""); + fz_printf(ctx, out, "/>\n</clipPath>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g clip-path=\"url(#cp%d)\">\n", num); } static void -svg_dev_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +svg_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { svg_device *sdev = dev->user; + fz_output *out; - fz_context *ctx = dev->ctx; fz_rect bounds; int num = sdev->id++; float white[3] = { 1, 1, 1 }; fz_bound_path(ctx, path, stroke, ctm, &bounds); - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); - fz_printf(out, "<path"); - svg_dev_ctm(sdev, ctm); - svg_dev_stroke_state(sdev, stroke, &fz_identity); - svg_dev_stroke_color(sdev, fz_device_rgb(ctx), white, 1); - svg_dev_path(sdev, path); - fz_printf(out, "/>\n</mask>\n"); - out = end_def(sdev); - fz_printf(out, "<g mask=\"url(#ma%d)\">\n", num); + fz_printf(ctx, out, "<path"); + svg_dev_ctm(ctx, sdev, ctm); + svg_dev_stroke_state(ctx, sdev, stroke, &fz_identity); + svg_dev_stroke_color(ctx, sdev, fz_device_rgb(ctx), white, 1); + svg_dev_path(ctx, sdev, path); + fz_printf(ctx, out, "/>\n</mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g mask=\"url(#ma%d)\">\n", num); } static void -svg_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +svg_dev_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { svg_device *sdev = dev->user; fz_output *out = sdev->out; + font *fnt; - fz_printf(out, "<text"); - svg_dev_fill_color(sdev, colorspace, color, 0.0f); - svg_dev_text(sdev, ctm, text); - fnt = svg_dev_text_as_paths_defs(dev, text, ctm); - svg_dev_text_as_paths_fill(dev, text, ctm, colorspace, color, alpha, fnt); + fz_printf(ctx, out, "<text"); + svg_dev_fill_color(ctx, sdev, colorspace, color, 0.0f); + svg_dev_text(ctx, sdev, ctm, text); + fnt = svg_dev_text_as_paths_defs(ctx, dev, text, ctm); + svg_dev_text_as_paths_fill(ctx, dev, text, ctm, colorspace, color, alpha, fnt); } static void -svg_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +svg_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { svg_device *sdev = dev->user; fz_output *out = sdev->out; + font *fnt; - fz_printf(out, "<text"); - svg_dev_fill_color(sdev, colorspace, color, 0.0f); - svg_dev_text(sdev, ctm, text); - fnt = svg_dev_text_as_paths_defs(dev, text, ctm); - svg_dev_text_as_paths_stroke(dev, text, stroke, ctm, colorspace, color, alpha, fnt); + fz_printf(ctx, out, "<text"); + svg_dev_fill_color(ctx, sdev, colorspace, color, 0.0f); + svg_dev_text(ctx, sdev, ctm, text); + fnt = svg_dev_text_as_paths_defs(ctx, dev, text, ctm); + svg_dev_text_as_paths_stroke(ctx, dev, text, stroke, ctm, colorspace, color, alpha, fnt); } static void -svg_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +svg_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { svg_device *sdev = dev->user; fz_output *out = sdev->out; - fz_context *ctx = dev->ctx; + fz_rect bounds; int num = sdev->id++; float white[3] = { 1, 1, 1 }; @@ -591,25 +593,25 @@ svg_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accum fz_bound_text(ctx, text, NULL, ctm, &bounds); - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); - fz_printf(out, "<text"); - svg_dev_fill_color(sdev, fz_device_rgb(ctx), white, 0.0f); - svg_dev_text(sdev, ctm, text); - fnt = svg_dev_text_as_paths_defs(dev, text, ctm); - svg_dev_text_as_paths_fill(dev, text, ctm, fz_device_rgb(ctx), white, 1.0f, fnt); - fz_printf(out, "</mask>\n"); - out = end_def(sdev); - fz_printf(out, "<g mask=\"url(#ma%d)\">\n", num); + fz_printf(ctx, out, "<text"); + svg_dev_fill_color(ctx, sdev, fz_device_rgb(ctx), white, 0.0f); + svg_dev_text(ctx, sdev, ctm, text); + fnt = svg_dev_text_as_paths_defs(ctx, dev, text, ctm); + svg_dev_text_as_paths_fill(ctx, dev, text, ctm, fz_device_rgb(ctx), white, 1.0f, fnt); + fz_printf(ctx, out, "</mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g mask=\"url(#ma%d)\">\n", num); } static void -svg_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +svg_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { svg_device *sdev = dev->user; + fz_output *out; - fz_context *ctx = dev->ctx; fz_rect bounds; int num = sdev->id++; float white[3] = { 255, 255, 255 }; @@ -617,34 +619,35 @@ svg_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_bound_text(ctx, text, NULL, ctm, &bounds); - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\" maskUnits=\"userSpaceOnUse\" maskContentUnits=\"userSpaceOnUse\">\n", num, bounds.x0, bounds.y0, bounds.x1 - bounds.x0, bounds.y1 - bounds.y0); - fz_printf(out, "<text"); - svg_dev_stroke_state(sdev, stroke, &fz_identity); - svg_dev_stroke_color(sdev, fz_device_rgb(ctx), white, 0.0f); - svg_dev_text(sdev, ctm, text); - fnt = svg_dev_text_as_paths_defs(dev, text, ctm); - svg_dev_text_as_paths_stroke(dev, text, stroke, ctm, fz_device_rgb(ctx), white, 1.0f, fnt); - fz_printf(out, "</mask>\n"); - out = end_def(sdev); - fz_printf(out, "<g mask=\"url(#ma%d)\">\n", num); + fz_printf(ctx, out, "<text"); + svg_dev_stroke_state(ctx, sdev, stroke, &fz_identity); + svg_dev_stroke_color(ctx, sdev, fz_device_rgb(ctx), white, 0.0f); + svg_dev_text(ctx, sdev, ctm, text); + fnt = svg_dev_text_as_paths_defs(ctx, dev, text, ctm); + svg_dev_text_as_paths_stroke(ctx, dev, text, stroke, ctm, fz_device_rgb(ctx), white, 1.0f, fnt); + fz_printf(ctx, out, "</mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g mask=\"url(#ma%d)\">\n", num); } static void -svg_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +svg_dev_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { svg_device *sdev = dev->user; fz_output *out = sdev->out; + float black[3] = { 0, 0, 0}; - fz_printf(out, "<text"); - svg_dev_fill_color(sdev, fz_device_rgb(sdev->ctx), black, 0.0f); - svg_dev_text(sdev, ctm, text); + fz_printf(ctx, out, "<text"); + svg_dev_fill_color(ctx, sdev, fz_device_rgb(ctx), black, 0.0f); + svg_dev_text(ctx, sdev, ctm, text); } static void -send_data_base64(fz_output *out, fz_buffer *buffer) +send_data_base64(fz_context *ctx, fz_output *out, fz_buffer *buffer) { int i, len; static const char set[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; @@ -656,8 +659,8 @@ send_data_base64(fz_output *out, fz_buffer *buffer) int d = buffer->data[3*i+1]; int e = buffer->data[3*i+2]; if ((i & 15) == 0) - fz_printf(out, "\n"); - fz_printf(out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); + fz_printf(ctx, out, "\n"); + fz_printf(ctx, out, "%c%c%c%c", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)|(e>>6)], set[e & 63]); } i *= 3; switch (buffer->len-i) @@ -666,13 +669,13 @@ send_data_base64(fz_output *out, fz_buffer *buffer) { int c = buffer->data[i]; int d = buffer->data[i+1]; - fz_printf(out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); + fz_printf(ctx, out, "%c%c%c=", set[c>>2], set[((c&3)<<4)|(d>>4)], set[((d&15)<<2)]); break; } case 1: { int c = buffer->data[i]; - fz_printf(out, "%c%c==", set[c>>2], set[(c&3)<<4]); + fz_printf(ctx, out, "%c%c==", set[c>>2], set[(c&3)<<4]); break; } default: @@ -682,11 +685,11 @@ send_data_base64(fz_output *out, fz_buffer *buffer) } static void -svg_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +svg_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - svg_device *sdev = (svg_device *)dev->user; - fz_context *ctx = dev->ctx; + svg_device *sdev = dev->user; fz_output *out = sdev->out; + fz_matrix local_ctm = *ctm; fz_matrix scale = { 0 }; @@ -695,40 +698,40 @@ svg_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float fz_concat(&local_ctm, &scale, ctm); if (alpha != 1.0f) - fz_printf(out, "<g opacity=\"%g\">", alpha); - fz_printf(out, "<image"); - svg_dev_ctm(sdev, &local_ctm); - fz_printf(out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); + fz_printf(ctx, out, "<g opacity=\"%g\">", alpha); + fz_printf(ctx, out, "<image"); + svg_dev_ctm(ctx, sdev, &local_ctm); + fz_printf(ctx, out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); switch (image->buffer == NULL ? FZ_IMAGE_JPX : image->buffer->params.type) { case FZ_IMAGE_JPEG: - fz_printf(out, "image/jpeg;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/jpeg;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; case FZ_IMAGE_PNG: - fz_printf(out, "image/png;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; default: { fz_buffer *buf = fz_new_png_from_image(ctx, image, image->w, image->h); - fz_printf(out, "image/png;base64,"); - send_data_base64(out, buf); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, buf); fz_drop_buffer(ctx, buf); break; } } - fz_printf(out, "\"/>\n"); + fz_printf(ctx, out, "\"/>\n"); if (alpha != 1.0f) - fz_printf(out, "</g>"); + fz_printf(ctx, out, "</g>"); } static void -svg_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +svg_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { - svg_device *sdev = (svg_device *)dev->user; - fz_context *ctx = dev->ctx; + svg_device *sdev = dev->user; fz_output *out = sdev->out; + fz_rect rect; fz_irect bbox; fz_pixmap *pix; @@ -750,12 +753,12 @@ svg_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float fz_paint_shade(ctx, shade, ctm, pix, &bbox); buf = fz_new_png_from_pixmap(ctx, pix); if (alpha != 1.0f) - fz_printf(out, "<g opacity=\"%g\">", alpha); - fz_printf(out, "<image x=\"%dpx\" y=\"%dpx\" width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:image/png;base64,", pix->x, pix->y, pix->w, pix->h); - send_data_base64(out, buf); - fz_printf(out, "\"/>\n"); + fz_printf(ctx, out, "<g opacity=\"%g\">", alpha); + fz_printf(ctx, out, "<image x=\"%dpx\" y=\"%dpx\" width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:image/png;base64,", pix->x, pix->y, pix->w, pix->h); + send_data_base64(ctx, out, buf); + fz_printf(ctx, out, "\"/>\n"); if (alpha != 1.0f) - fz_printf(out, "</g>"); + fz_printf(ctx, out, "</g>"); } fz_always(ctx) { @@ -769,11 +772,11 @@ svg_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float } static void -svg_dev_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +svg_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - svg_device *sdev = (svg_device *)dev->user; - fz_context *ctx = dev->ctx; + svg_device *sdev = dev->user; + fz_output *out; fz_matrix local_ctm = *ctm; fz_matrix scale = { 0 }; @@ -783,41 +786,40 @@ fz_colorspace *colorspace, float *color, float alpha) scale.d = 1.0f / image->h; fz_concat(&local_ctm, &scale, ctm); - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\"><image", mask); - fz_printf(out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\"><image", mask); + fz_printf(ctx, out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); switch (image->buffer == NULL ? FZ_IMAGE_JPX : image->buffer->params.type) { case FZ_IMAGE_JPEG: - fz_printf(out, "image/jpeg;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/jpeg;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; case FZ_IMAGE_PNG: - fz_printf(out, "image/png;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; default: { fz_buffer *buf = fz_new_png_from_image(ctx, image, image->w, image->h); - fz_printf(out, "image/png;base64,"); - send_data_base64(out, buf); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, buf); fz_drop_buffer(ctx, buf); break; } } - fz_printf(out, "\"/></mask>\n"); - out = end_def(sdev); - fz_printf(out, "<rect x=\"0\" y=\"0\" width=\"%d\" height=\"%d\"", image->w, image->h); - svg_dev_fill_color(sdev, colorspace, color, alpha); - svg_dev_ctm(sdev, &local_ctm); - fz_printf(out, " mask=\"url(#ma%d)\"/>\n", mask); + fz_printf(ctx, out, "\"/></mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<rect x=\"0\" y=\"0\" width=\"%d\" height=\"%d\"", image->w, image->h); + svg_dev_fill_color(ctx, sdev, colorspace, color, alpha); + svg_dev_ctm(ctx, sdev, &local_ctm); + fz_printf(ctx, out, " mask=\"url(#ma%d)\"/>\n", mask); } static void -svg_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +svg_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { - svg_device *sdev = (svg_device *)dev->user; - fz_context *ctx = dev->ctx; + svg_device *sdev = dev->user; fz_output *out; fz_matrix local_ctm = *ctm; fz_matrix scale = { 0 }; @@ -827,99 +829,98 @@ svg_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, co scale.d = 1.0f / image->h; fz_concat(&local_ctm, &scale, ctm); - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\"><image", mask); - svg_dev_ctm(sdev, &local_ctm); - fz_printf(out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\"><image", mask); + svg_dev_ctm(ctx, sdev, &local_ctm); + fz_printf(ctx, out, " width=\"%dpx\" height=\"%dpx\" xlink:href=\"data:", image->w, image->h); switch (image->buffer == NULL ? FZ_IMAGE_JPX : image->buffer->params.type) { case FZ_IMAGE_JPEG: - fz_printf(out, "image/jpeg;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/jpeg;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; case FZ_IMAGE_PNG: - fz_printf(out, "image/png;base64,"); - send_data_base64(out, image->buffer->buffer); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, image->buffer->buffer); break; default: { fz_buffer *buf = fz_new_png_from_image(ctx, image, image->w, image->h); - fz_printf(out, "image/png;base64,"); - send_data_base64(out, buf); + fz_printf(ctx, out, "image/png;base64,"); + send_data_base64(ctx, out, buf); fz_drop_buffer(ctx, buf); break; } } - fz_printf(out, "\"/></mask>\n"); - out = end_def(sdev); - fz_printf(out, "<g mask=\"url(#ma%d)\">\n", mask); + fz_printf(ctx, out, "\"/></mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g mask=\"url(#ma%d)\">\n", mask); } static void -svg_dev_pop_clip(fz_device *dev) +svg_dev_pop_clip(fz_context *ctx, fz_device *dev) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out = sdev->out; /* FIXME */ - fz_printf(out, "</g>\n"); + fz_printf(ctx, out, "</g>\n"); } static void -svg_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) +svg_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out; int mask = sdev->id++; - out = start_def(sdev); - fz_printf(out, "<mask id=\"ma%d\">", mask); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<mask id=\"ma%d\">", mask); if (dev->container_len > 0) dev->container[dev->container_len-1].user = mask; } static void -svg_dev_end_mask(fz_device *dev) +svg_dev_end_mask(fz_context *ctx, fz_device *dev) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out = sdev->out; int mask = 0; if (dev->container_len > 0) mask = (int)dev->container[dev->container_len-1].user; - fz_printf(out, "\"/></mask>\n"); - out = end_def(sdev); - fz_printf(out, "<g mask=\"url(#ma%d)\">\n", mask); + fz_printf(ctx, out, "\"/></mask>\n"); + out = end_def(ctx, sdev); + fz_printf(ctx, out, "<g mask=\"url(#ma%d)\">\n", mask); } static void -svg_dev_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) +svg_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out = sdev->out; /* SVG 1.1 doesn't support adequate blendmodes/knockout etc, so just ignore it for now */ - fz_printf(out, "<g>\n"); + fz_printf(ctx, out, "<g>\n"); } static void -svg_dev_end_group(fz_device *dev) +svg_dev_end_group(fz_context *ctx, fz_device *dev) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out = sdev->out; - fz_printf(out, "</g>\n"); + fz_printf(ctx, out, "</g>\n"); } static int -svg_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +svg_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out; - fz_context *ctx = dev->ctx; int num; tile *t; @@ -950,16 +951,16 @@ svg_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, flo /* The first thing we do is to capture the contents of the pattern * as a symbol we can reuse. */ - out = start_def(sdev); - fz_printf(out, "<symbol id=\"pac%d\">\n", t->pattern); + out = start_def(ctx, sdev); + fz_printf(ctx, out, "<symbol id=\"pac%d\">\n", t->pattern); return 0; } static void -svg_dev_end_tile(fz_device *dev) +svg_dev_end_tile(fz_context *ctx, fz_device *dev) { - svg_device *sdev = (svg_device *)dev->user; + svg_device *sdev = dev->user; fz_output *out = sdev->out; int num, cp = -1; tile *t; @@ -971,7 +972,7 @@ svg_dev_end_tile(fz_device *dev) num = --sdev->num_tiles; t = &sdev->tiles[num]; - fz_printf(out, "</symbol>\n"); + fz_printf(ctx, out, "</symbol>\n"); /* In svg, the reference tile is taken from (x,y) to (x+width,y+height) * and is repeated at (x+n*width,y+m*height) for all integer n and m. @@ -981,76 +982,66 @@ svg_dev_end_tile(fz_device *dev) * pattern tile, we need to render the pattern contents several times * to ensure that the pattern tile contains everything. */ - fz_printf(out, "<pattern id=\"pa%d\" patternUnits=\"userSpaceOnUse\" patternContentUnits=\"userSpaceOnUse\"", + fz_printf(ctx, out, "<pattern id=\"pa%d\" patternUnits=\"userSpaceOnUse\" patternContentUnits=\"userSpaceOnUse\"", t->pattern); - fz_printf(out, " x=\"0\" y=\"0\" width=\"%g\" height=\"%g\">\n", + fz_printf(ctx, out, " x=\"0\" y=\"0\" width=\"%g\" height=\"%g\">\n", t->step.x, t->step.y); if (t->view.x0 > 0 || t->step.x < t->view.x1 || t->view.y0 > 0 || t->step.y < t->view.y1) { cp = sdev->id++; - fz_printf(out, "<clipPath id=\"cp%d\">\n", cp); - fz_printf(out, "<path d=\"M %g %g L %g %g L %g %g L %g %g Z\"/>", + fz_printf(ctx, out, "<clipPath id=\"cp%d\">\n", cp); + fz_printf(ctx, out, "<path d=\"M %g %g L %g %g L %g %g L %g %g Z\"/>", t->view.x0, t->view.y0, t->view.x1, t->view.y0, t->view.x1, t->view.y1, t->view.x0, t->view.y1); - fz_printf(out, "</clipPath>\n"); - fz_printf(out, "<g clip-path=\"url(#cp%d)\">\n", cp); + fz_printf(ctx, out, "</clipPath>\n"); + fz_printf(ctx, out, "<g clip-path=\"url(#cp%d)\">\n", cp); } /* All the pattern contents will have their own ctm applied. Let's * undo the current one to allow for this */ fz_invert_matrix(&inverse, &t->ctm); - fz_printf(out, "<g"); - svg_dev_ctm(sdev, &inverse); - fz_printf(out, ">\n"); + fz_printf(ctx, out, "<g"); + svg_dev_ctm(ctx, sdev, &inverse); + fz_printf(ctx, out, ">\n"); w = t->view.x1 - t->view.x0; h = t->view.y1 - t->view.y0; for (x = 0; x > -w; x -= t->step.x) for (y = 0; y > -h; y -= t->step.y) - fz_printf(out, "<use x=\"%g\" y=\"%g\" xlink:href=\"#pac%d\"/>", x, y, t->pattern); + fz_printf(ctx, out, "<use x=\"%g\" y=\"%g\" xlink:href=\"#pac%d\"/>", x, y, t->pattern); - fz_printf(out, "</g>\n"); + fz_printf(ctx, out, "</g>\n"); if (cp != -1) - fz_printf(out, "</g>\n"); - fz_printf(out, "</pattern>\n"); - out = end_def(sdev); + fz_printf(ctx, out, "</g>\n"); + fz_printf(ctx, out, "</pattern>\n"); + out = end_def(ctx, sdev); /* Finally, fill a rectangle with the pattern. */ - fz_printf(out, "<rect"); - svg_dev_ctm(sdev, &t->ctm); - fz_printf(out, " fill=\"url(#pa%d)\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\"/>\n", + fz_printf(ctx, out, "<rect"); + svg_dev_ctm(ctx, sdev, &t->ctm); + fz_printf(ctx, out, " fill=\"url(#pa%d)\" x=\"%g\" y=\"%g\" width=\"%g\" height=\"%g\"/>\n", t->pattern, t->area.x0, t->area.y0, t->area.x1 - t->area.x0, t->area.y1 - t->area.y0); } static void -svg_dev_drop_user(fz_device *dev) +svg_dev_drop_user(fz_context *ctx, fz_device *dev) { svg_device *sdev = dev->user; - fz_context *ctx = sdev->ctx; fz_output *out = sdev->out; fz_free(ctx, sdev->tiles); fz_drop_buffer(ctx, sdev->defs_buffer); - fz_drop_output(sdev->defs); + fz_drop_output(ctx, sdev->defs); - fz_printf(out, "</svg>\n"); + fz_printf(ctx, out, "</svg>\n"); fz_free(ctx, sdev); } -void svg_rebind(fz_device *dev) -{ - svg_device *sdev = dev->user; - - sdev->ctx = dev->ctx; - fz_rebind_output(sdev->out, sdev->ctx); - fz_rebind_output(sdev->out_store, sdev->ctx); -} - fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, float page_height) { svg_device *sdev = fz_malloc_struct(ctx, svg_device); @@ -1058,7 +1049,6 @@ fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, fz_try(ctx) { - sdev->ctx = ctx; sdev->out = out; sdev->out_store = out; sdev->id = 0; @@ -1071,7 +1061,6 @@ fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, fz_rethrow(ctx); } - dev->rebind = svg_rebind; dev->drop_user = svg_dev_drop_user; dev->fill_path = svg_dev_fill_path; @@ -1102,9 +1091,9 @@ fz_device *fz_new_svg_device(fz_context *ctx, fz_output *out, float page_width, dev->hints |= FZ_MAINTAIN_CONTAINER_STACK; - fz_printf(out, "<?xml version=\"1.0\" standalone=\"no\"?>\n"); - fz_printf(out, "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"); - fz_printf(out, "<svg xmlns=\"http://www.w3.org/2000/svg\" " + fz_printf(ctx, out, "<?xml version=\"1.0\" standalone=\"no\"?>\n"); + fz_printf(ctx, out, "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\" \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n"); + fz_printf(ctx, out, "<svg xmlns=\"http://www.w3.org/2000/svg\" " "xmlns:xlink=\"http://www.w3.org/1999/xlink\" version=\"1.1\" " "width=\"%gcm\" height=\"%gcm\" viewBox=\"0 0 %g %g\">\n", page_width*2.54/72, page_height*2.54/72, page_width, page_height); diff --git a/source/fitz/test-device.c b/source/fitz/test-device.c index 919bda98..16736c80 100644 --- a/source/fitz/test-device.c +++ b/source/fitz/test-device.c @@ -25,9 +25,8 @@ is_rgb_color_u8(int threshold_u8, int r, int g, int b) } static void -fz_test_color(fz_device *dev, fz_colorspace *colorspace, const float *color) +fz_test_color(fz_context *ctx, fz_device *dev, fz_colorspace *colorspace, const float *color) { - fz_context *ctx = dev->ctx; struct test *t = dev->user; if (!*t->is_color && colorspace && colorspace != fz_device_gray(ctx)) @@ -56,35 +55,35 @@ fz_test_color(fz_device *dev, fz_colorspace *colorspace, const float *color) } static void -fz_test_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_test_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (alpha != 0.0f) - fz_test_color(dev, colorspace, color); + fz_test_color(ctx, dev, colorspace, color); } static void -fz_test_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, +fz_test_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (alpha != 0.0f) - fz_test_color(dev, colorspace, color); + fz_test_color(ctx, dev, colorspace, color); } static void -fz_test_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_test_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (alpha != 0.0f) - fz_test_color(dev, colorspace, color); + fz_test_color(ctx, dev, colorspace, color); } static void -fz_test_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, +fz_test_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { if (alpha != 0.0f) - fz_test_color(dev, colorspace, color); + fz_test_color(ctx, dev, colorspace, color); } struct shadearg @@ -94,25 +93,23 @@ struct shadearg }; static void -prepare_vertex(void *arg0, fz_vertex *v, const float *color) +prepare_vertex(fz_context *ctx, void *arg_, fz_vertex *v, const float *color) { - struct shadearg *arg = arg0; + struct shadearg *arg = arg_; fz_device *dev = arg->dev; fz_shade *shade = arg->shade; if (!shade->use_function) - fz_test_color(dev, shade->colorspace, color); + fz_test_color(ctx, dev, shade->colorspace, color); } static void -fz_test_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_test_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { - fz_context *ctx = dev->ctx; - if (shade->use_function) { int i; for (i = 0; i < 256; i++) - fz_test_color(dev, shade->colorspace, shade->function[i]); + fz_test_color(ctx, dev, shade->colorspace, shade->function[i]); } else { @@ -124,9 +121,8 @@ fz_test_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float } static void -fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +fz_test_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - fz_context *ctx = dev->ctx; struct test *t = dev->user; fz_pixmap *pix; @@ -145,14 +141,14 @@ fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float int threshold_u8 = t->threshold * 255; for (i = 0; i < count; i++) { - int r = fz_read_byte(stream); - int g = fz_read_byte(stream); - int b = fz_read_byte(stream); + int r = fz_read_byte(ctx, stream); + int g = fz_read_byte(ctx, stream); + int b = fz_read_byte(ctx, stream); if (is_rgb_color_u8(threshold_u8, r, g, b)) { *t->is_color = 1; dev->hints |= FZ_IGNORE_IMAGE; - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); fz_throw(ctx, FZ_ERROR_ABORT, "Page found as color; stopping interpretation"); break; } @@ -170,9 +166,9 @@ fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float float ds[FZ_MAX_COLORS]; for (k = 0; k < n; k++) - cs[k] = fz_read_byte(stream) / 255.0f; + cs[k] = fz_read_byte(ctx, stream) / 255.0f; - cc.convert(&cc, ds, cs); + cc.convert(ctx, &cc, ds, cs); if (is_rgb_color(t->threshold, ds[0], ds[1], ds[2])) { @@ -181,9 +177,9 @@ fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float break; } } - fz_fin_cached_color_converter(&cc); + fz_fin_cached_color_converter(ctx, &cc); } - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); return; } @@ -226,7 +222,7 @@ fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float if (*s++ == 0) continue; - cc.convert(&cc, ds, cs); + cc.convert(ctx, &cc, ds, cs); if (is_rgb_color(t->threshold, ds[0], ds[1], ds[2])) { @@ -237,26 +233,26 @@ fz_test_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float break; } } - fz_fin_cached_color_converter(&cc); + fz_fin_cached_color_converter(ctx, &cc); } fz_drop_pixmap(ctx, pix); } static void -fz_test_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_test_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { /* We assume that at least some of the image pixels are non-zero */ - fz_test_color(dev, colorspace, color); + fz_test_color(ctx, dev, colorspace, color); } static void -fz_test_free(fz_device *dev) +fz_test_free(fz_context *ctx, fz_device *dev) { if (dev == NULL) return; - fz_free(dev->ctx, dev->user); + fz_free(ctx, dev->user); dev->user = NULL; } diff --git a/source/fitz/text.c b/source/fitz/text.c index f184e11d..4d2b73d9 100644 --- a/source/fitz/text.c +++ b/source/fitz/text.c @@ -76,7 +76,7 @@ fz_bound_text(fz_context *ctx, fz_text *text, const fz_stroke_state *stroke, con } if (stroke) - fz_adjust_rect_for_stroke(bbox, stroke, ctm); + fz_adjust_rect_for_stroke(ctx, bbox, stroke, ctm); /* Compensate for the glyph cache limited positioning precision */ bbox->x0 -= 1; diff --git a/source/fitz/trace-device.c b/source/fitz/trace-device.c index d6c01323..3a0bba0a 100644 --- a/source/fitz/trace-device.c +++ b/source/fitz/trace-device.c @@ -66,7 +66,7 @@ fz_trace_path(fz_path *path, int indent) } static void -fz_trace_begin_page(fz_device *dev, const fz_rect *rect, const fz_matrix *ctm) +fz_trace_begin_page(fz_context *ctx, fz_device *dev, const fz_rect *rect, const fz_matrix *ctm) { printf("<page mediabox=\"%g %g %g %g\"", rect->x0, rect->y0, rect->x1, rect->y1); fz_trace_matrix(ctm); @@ -74,13 +74,13 @@ fz_trace_begin_page(fz_device *dev, const fz_rect *rect, const fz_matrix *ctm) } static void -fz_trace_end_page(fz_device *dev) +fz_trace_end_page(fz_context *ctx, fz_device *dev) { printf("</page>\n"); } static void -fz_trace_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +fz_trace_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { printf("<fill_path"); @@ -96,7 +96,7 @@ fz_trace_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix } static void -fz_trace_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_trace_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { int i; @@ -125,7 +125,7 @@ fz_trace_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, con } static void -fz_trace_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +fz_trace_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { printf("<clip_path"); if (even_odd) @@ -142,7 +142,7 @@ fz_trace_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_ } static void -fz_trace_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_trace_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { printf("<clip_stroke_path"); fz_trace_matrix(ctm); @@ -152,7 +152,7 @@ fz_trace_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz } static void -fz_trace_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +fz_trace_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { printf("<fill_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode); @@ -160,12 +160,12 @@ fz_trace_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_trace_matrix(ctm); fz_trace_trm(&text->trm); printf(">\n"); - fz_print_text(dev->ctx, stdout, text); + fz_print_text(ctx, stdout, text); printf("</fill_text>\n"); } static void -fz_trace_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +fz_trace_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { printf("<stroke_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode); @@ -173,46 +173,46 @@ fz_trace_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, con fz_trace_matrix(ctm); fz_trace_trm(&text->trm); printf(">\n"); - fz_print_text(dev->ctx, stdout, text); + fz_print_text(ctx, stdout, text); printf("</stroke_text>\n"); } static void -fz_trace_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +fz_trace_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { printf("<clip_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode); printf(" accumulate=\"%d\"", accumulate); fz_trace_matrix(ctm); fz_trace_trm(&text->trm); printf(">\n"); - fz_print_text(dev->ctx, stdout, text); + fz_print_text(ctx, stdout, text); printf("</clip_text>\n"); } static void -fz_trace_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +fz_trace_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { printf("<clip_stroke_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode); fz_trace_matrix(ctm); fz_trace_trm(&text->trm); printf(">\n"); - fz_print_text(dev->ctx, stdout, text); + fz_print_text(ctx, stdout, text); printf("</clip_stroke_text>\n"); } static void -fz_trace_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +fz_trace_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { printf("<ignore_text font=\"%s\" wmode=\"%d\"", text->font->name, text->wmode); fz_trace_matrix(ctm); fz_trace_trm(&text->trm); printf(">\n"); - fz_print_text(dev->ctx, stdout, text); + fz_print_text(ctx, stdout, text); printf("</ignore_text>\n"); } static void -fz_trace_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +fz_trace_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { printf("<fill_image alpha=\"%g\"", alpha); fz_trace_matrix(ctm); @@ -221,7 +221,7 @@ fz_trace_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float } static void -fz_trace_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +fz_trace_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { printf("<fill_shade alpha=\"%g\"", alpha); fz_trace_matrix(ctm); @@ -229,7 +229,7 @@ fz_trace_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float } static void -fz_trace_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +fz_trace_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { printf("<fill_image_mask"); @@ -240,7 +240,7 @@ fz_colorspace *colorspace, float *color, float alpha) } static void -fz_trace_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +fz_trace_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { printf("<clip_image_mask"); fz_trace_matrix(ctm); @@ -249,13 +249,13 @@ fz_trace_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, c } static void -fz_trace_pop_clip(fz_device *dev) +fz_trace_pop_clip(fz_context *ctx, fz_device *dev) { printf("<pop_clip/>\n"); } static void -fz_trace_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) +fz_trace_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) { printf("<mask bbox=\"%g %g %g %g\" s=\"%s\"", bbox->x0, bbox->y0, bbox->x1, bbox->y1, @@ -264,13 +264,13 @@ fz_trace_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colo } static void -fz_trace_end_mask(fz_device *dev) +fz_trace_end_mask(fz_context *ctx, fz_device *dev) { printf("</mask>\n"); } static void -fz_trace_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) +fz_trace_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) { printf("<group bbox=\"%g %g %g %g\" isolated=\"%d\" knockout=\"%d\" blendmode=\"%s\" alpha=\"%g\">\n", bbox->x0, bbox->y0, bbox->x1, bbox->y1, @@ -278,13 +278,13 @@ fz_trace_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knoc } static void -fz_trace_end_group(fz_device *dev) +fz_trace_end_group(fz_context *ctx, fz_device *dev) { printf("</group>\n"); } static int -fz_trace_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +fz_trace_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { printf("<tile"); printf(" area=\"%g %g %g %g\"", area->x0, area->y0, area->x1, area->y1); @@ -296,7 +296,7 @@ fz_trace_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, fl } static void -fz_trace_end_tile(fz_device *dev) +fz_trace_end_tile(fz_context *ctx, fz_device *dev) { printf("</tile>\n"); } diff --git a/source/fitz/transition.c b/source/fitz/transition.c index c71729a9..b4da6192 100644 --- a/source/fitz/transition.c +++ b/source/fitz/transition.c @@ -139,7 +139,7 @@ wipe_lr(fz_pixmap *tpix, fz_pixmap *opix, fz_pixmap *npix, int time) return 1; } -int fz_generate_transition(fz_pixmap *tpix, fz_pixmap *opix, fz_pixmap *npix, int time, fz_transition *trans) +int fz_generate_transition(fz_context *ctx, fz_pixmap *tpix, fz_pixmap *opix, fz_pixmap *npix, int time, fz_transition *trans) { switch (trans->type) { diff --git a/source/fitz/unzip.c b/source/fitz/unzip.c index bafc4146..8c8a6ba3 100644 --- a/source/fitz/unzip.c +++ b/source/fitz/unzip.c @@ -27,26 +27,26 @@ struct fz_archive_s struct zip_entry *table; }; -static inline int getshort(fz_stream *file) +static inline int getshort(fz_context *ctx, fz_stream *file) { - int a = fz_read_byte(file); - int b = fz_read_byte(file); + int a = fz_read_byte(ctx, file); + int b = fz_read_byte(ctx, file); return a | b << 8; } -static inline int getlong(fz_stream *file) +static inline int getlong(fz_context *ctx, fz_stream *file) { - int a = fz_read_byte(file); - int b = fz_read_byte(file); - int c = fz_read_byte(file); - int d = fz_read_byte(file); + int a = fz_read_byte(ctx, file); + int b = fz_read_byte(ctx, file); + int c = fz_read_byte(ctx, file); + int d = fz_read_byte(ctx, file); return a | b << 8 | c << 16 | d << 24; } -static inline int getlong64(fz_stream *file) +static inline int getlong64(fz_context *ctx, fz_stream *file) { - int a = getlong(file); - int b = getlong(file); + int a = getlong(ctx, file); + int b = getlong(ctx, file); return b != 0 ? -1 : a; } @@ -106,50 +106,50 @@ static void read_zip_dir_imp(fz_context *ctx, fz_archive *zip, int start_offset) int namesize, metasize, commentsize; int i; - fz_seek(file, start_offset, 0); + fz_seek(ctx, file, start_offset, 0); - sig = getlong(file); + sig = getlong(ctx, file); if (sig != ZIP_END_OF_CENTRAL_DIRECTORY_SIG) fz_throw(ctx, FZ_ERROR_GENERIC, "wrong zip end of central directory signature (0x%x)", sig); - (void) getshort(file); /* this disk */ - (void) getshort(file); /* start disk */ - (void) getshort(file); /* entries in this disk */ - count = getshort(file); /* entries in central directory disk */ - (void) getlong(file); /* size of central directory */ - offset = getlong(file); /* offset to central directory */ + (void) getshort(ctx, file); /* this disk */ + (void) getshort(ctx, file); /* start disk */ + (void) getshort(ctx, file); /* entries in this disk */ + count = getshort(ctx, file); /* entries in central directory disk */ + (void) getlong(ctx, file); /* size of central directory */ + offset = getlong(ctx, file); /* offset to central directory */ /* ZIP64 */ if (count == 0xFFFF || offset == 0xFFFFFFFF) { int offset64, count64; - fz_seek(file, start_offset - 20, 0); + fz_seek(ctx, file, start_offset - 20, 0); - sig = getlong(file); + sig = getlong(ctx, file); if (sig != ZIP64_END_OF_CENTRAL_DIRECTORY_LOCATOR_SIG) fz_throw(ctx, FZ_ERROR_GENERIC, "wrong zip64 end of central directory locator signature (0x%x)", sig); - (void) getlong(file); /* start disk */ - offset64 = getlong64(file); /* offset to end of central directory record */ + (void) getlong(ctx, file); /* start disk */ + offset64 = getlong64(ctx, file); /* offset to end of central directory record */ if (offset64 < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "zip64 files larger than 2 GB aren't supported"); - fz_seek(file, offset64, 0); + fz_seek(ctx, file, offset64, 0); - sig = getlong(file); + sig = getlong(ctx, file); if (sig != ZIP64_END_OF_CENTRAL_DIRECTORY_SIG) fz_throw(ctx, FZ_ERROR_GENERIC, "wrong zip64 end of central directory signature (0x%x)", sig); - (void) getlong64(file); /* size of record */ - (void) getshort(file); /* version made by */ - (void) getshort(file); /* version to extract */ - (void) getlong(file); /* disk number */ - (void) getlong(file); /* disk number start */ - count64 = getlong64(file); /* entries in central directory disk */ - (void) getlong64(file); /* entries in central directory */ - (void) getlong64(file); /* size of central directory */ - offset64 = getlong64(file); /* offset to central directory */ + (void) getlong64(ctx, file); /* size of record */ + (void) getshort(ctx, file); /* version made by */ + (void) getshort(ctx, file); /* version to extract */ + (void) getlong(ctx, file); /* disk number */ + (void) getlong(ctx, file); /* disk number start */ + count64 = getlong64(ctx, file); /* entries in central directory disk */ + (void) getlong64(ctx, file); /* entries in central directory */ + (void) getlong64(ctx, file); /* size of central directory */ + offset64 = getlong64(ctx, file); /* offset to central directory */ if (count == 0xFFFF) count = count64; @@ -163,66 +163,66 @@ static void read_zip_dir_imp(fz_context *ctx, fz_archive *zip, int start_offset) zip->table = fz_malloc_array(ctx, count, sizeof *zip->table); memset(zip->table, 0, count * sizeof *zip->table); - fz_seek(file, offset, 0); + fz_seek(ctx, file, offset, 0); for (i = 0; i < count; i++) { - sig = getlong(file); + sig = getlong(ctx, file); if (sig != ZIP_CENTRAL_DIRECTORY_SIG) fz_throw(ctx, FZ_ERROR_GENERIC, "wrong zip central directory signature (0x%x)", sig); - (void) getshort(file); /* version made by */ - (void) getshort(file); /* version to extract */ - (void) getshort(file); /* general */ - (void) getshort(file); /* method */ - (void) getshort(file); /* last mod file time */ - (void) getshort(file); /* last mod file date */ - (void) getlong(file); /* crc-32 */ - zip->table[i].csize = getlong(file); - zip->table[i].usize = getlong(file); - namesize = getshort(file); - metasize = getshort(file); - commentsize = getshort(file); - (void) getshort(file); /* disk number start */ - (void) getshort(file); /* int file atts */ - (void) getlong(file); /* ext file atts */ - zip->table[i].offset = getlong(file); + (void) getshort(ctx, file); /* version made by */ + (void) getshort(ctx, file); /* version to extract */ + (void) getshort(ctx, file); /* general */ + (void) getshort(ctx, file); /* method */ + (void) getshort(ctx, file); /* last mod file time */ + (void) getshort(ctx, file); /* last mod file date */ + (void) getlong(ctx, file); /* crc-32 */ + zip->table[i].csize = getlong(ctx, file); + zip->table[i].usize = getlong(ctx, file); + namesize = getshort(ctx, file); + metasize = getshort(ctx, file); + commentsize = getshort(ctx, file); + (void) getshort(ctx, file); /* disk number start */ + (void) getshort(ctx, file); /* int file atts */ + (void) getlong(ctx, file); /* ext file atts */ + zip->table[i].offset = getlong(ctx, file); zip->table[i].name = fz_malloc(ctx, namesize + 1); - fz_read(file, (unsigned char*)zip->table[i].name, namesize); + fz_read(ctx, file, (unsigned char*)zip->table[i].name, namesize); zip->table[i].name[namesize] = 0; while (metasize > 0) { - int type = getshort(file); - int size = getshort(file); + int type = getshort(ctx, file); + int size = getshort(ctx, file); if (type == ZIP64_EXTRA_FIELD_SIG) { int sizeleft = size; if (zip->table[i].usize == 0xFFFFFFFF && sizeleft >= 8) { - zip->table[i].usize = getlong64(file); + zip->table[i].usize = getlong64(ctx, file); sizeleft -= 8; } if (zip->table[i].csize == 0xFFFFFFFF && sizeleft >= 8) { - zip->table[i].csize = getlong64(file); + zip->table[i].csize = getlong64(ctx, file); sizeleft -= 8; } if (zip->table[i].offset == 0xFFFFFFFF && sizeleft >= 8) { - zip->table[i].offset = getlong64(file); + zip->table[i].offset = getlong64(ctx, file); sizeleft -= 8; } - fz_seek(file, sizeleft - size, 1); + fz_seek(ctx, file, sizeleft - size, 1); } - fz_seek(file, size, 1); + fz_seek(ctx, file, size, 1); metasize -= 4 + size; } if (zip->table[i].usize < 0 || zip->table[i].csize < 0 || zip->table[i].offset < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "zip64 files larger than 2 GB are not supported"); - fz_seek(file, commentsize, 1); + fz_seek(ctx, file, commentsize, 1); } qsort(zip->table, count, sizeof *zip->table, case_compare_entries); @@ -235,16 +235,16 @@ static void read_zip_dir(fz_context *ctx, fz_archive *zip) int size, back, maxback; int i, n; - fz_seek(file, 0, SEEK_END); - size = fz_tell(file); + fz_seek(ctx, file, 0, SEEK_END); + size = fz_tell(ctx, file); maxback = fz_mini(size, 0xFFFF + sizeof buf); back = fz_mini(maxback, sizeof buf); while (back < maxback) { - fz_seek(file, size - back, 0); - n = fz_read(file, buf, sizeof buf); + fz_seek(ctx, file, size - back, 0); + n = fz_read(ctx, file, buf, sizeof buf); for (i = n - 4; i > 0; i--) { if (!memcmp(buf + i, "PK\5\6", 4)) @@ -264,27 +264,27 @@ static int read_zip_entry_header(fz_context *ctx, fz_archive *zip, struct zip_en fz_stream *file = zip->file; int sig, general, method, namelength, extralength; - fz_seek(file, ent->offset, 0); + fz_seek(ctx, file, ent->offset, 0); - sig = getlong(file); + sig = getlong(ctx, file); if (sig != ZIP_LOCAL_FILE_SIG) fz_throw(ctx, FZ_ERROR_GENERIC, "wrong zip local file signature (0x%x)", sig); - (void) getshort(file); /* version */ - general = getshort(file); /* general */ + (void) getshort(ctx, file); /* version */ + general = getshort(ctx, file); /* general */ if (general & ZIP_ENCRYPTED_FLAG) fz_throw(ctx, FZ_ERROR_GENERIC, "zip content is encrypted"); - method = getshort(file); - (void) getshort(file); /* file time */ - (void) getshort(file); /* file date */ - (void) getlong(file); /* crc-32 */ - (void) getlong(file); /* csize */ - (void) getlong(file); /* usize */ - namelength = getshort(file); - extralength = getshort(file); + method = getshort(ctx, file); + (void) getshort(ctx, file); /* file time */ + (void) getshort(ctx, file); /* file date */ + (void) getlong(ctx, file); /* crc-32 */ + (void) getlong(ctx, file); /* csize */ + (void) getlong(ctx, file); /* usize */ + namelength = getshort(ctx, file); + extralength = getshort(ctx, file); - fz_seek(file, namelength + extralength, 1); + fz_seek(ctx, file, namelength + extralength, 1); return method; } @@ -294,9 +294,9 @@ static fz_stream *open_zip_entry(fz_context *ctx, fz_archive *zip, struct zip_en fz_stream *file = zip->file; int method = read_zip_entry_header(ctx, zip, ent); if (method == 0) - return fz_open_null(file, ent->usize, fz_tell(file)); + return fz_open_null(ctx, file, ent->usize, fz_tell(ctx, file)); if (method == 8) - return fz_open_flated(file, -15); + return fz_open_flated(ctx, file, -15); fz_throw(ctx, FZ_ERROR_GENERIC, "unknown zip method: %d", method); } @@ -318,7 +318,7 @@ static fz_buffer *read_zip_entry(fz_context *ctx, fz_archive *zip, struct zip_en { fz_try(ctx) { - fz_read(file, ubuf->data, ent->usize); + fz_read(ctx, file, ubuf->data, ent->usize); } fz_catch(ctx) { @@ -333,7 +333,7 @@ static fz_buffer *read_zip_entry(fz_context *ctx, fz_archive *zip, struct zip_en cbuf = fz_malloc(ctx, ent->csize); fz_try(ctx) { - fz_read(file, cbuf, ent->csize); + fz_read(ctx, file, cbuf, ent->csize); z.zalloc = (alloc_func) fz_malloc_array; z.zfree = (free_func) fz_free; @@ -458,7 +458,7 @@ fz_drop_archive(fz_context *ctx, fz_archive *zip) if (zip) { fz_free(ctx, zip->directory); - fz_drop_stream(zip->file); + fz_drop_stream(ctx, zip->file); for (i = 0; i < zip->count; ++i) fz_free(ctx, zip->table[i].name); fz_free(ctx, zip->table); @@ -466,13 +466,6 @@ fz_drop_archive(fz_context *ctx, fz_archive *zip) } } -void -fz_rebind_archive(fz_archive *zip, fz_context *ctx) -{ - if (zip->file) - fz_rebind_stream(zip->file, ctx); -} - fz_archive * fz_open_directory(fz_context *ctx, const char *dirname) { @@ -487,7 +480,7 @@ fz_open_archive_with_stream(fz_context *ctx, fz_stream *file) fz_archive *zip; zip = fz_malloc_struct(ctx, fz_archive); - zip->file = fz_keep_stream(file); + zip->file = fz_keep_stream(ctx, file); zip->count = 0; zip->table = NULL; @@ -517,7 +510,7 @@ fz_open_archive(fz_context *ctx, const char *filename) } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { diff --git a/source/fitz/xml.c b/source/fitz/xml.c index 424a6bdf..6051caf5 100644 --- a/source/fitz/xml.c +++ b/source/fitz/xml.c @@ -66,7 +66,6 @@ static const struct { const char *ent; int ucs; } html_entities[] = { struct parser { fz_xml *head; - fz_context *ctx; int preserve_white; int depth; }; @@ -287,7 +286,7 @@ static inline int iswhite(int c) return c == ' ' || c == '\r' || c == '\n' || c == '\t'; } -static void xml_emit_open_tag(struct parser *parser, char *a, char *b) +static void xml_emit_open_tag(fz_context *ctx, struct parser *parser, char *a, char *b) { fz_xml *head, *tail; char *ns; @@ -297,7 +296,7 @@ static void xml_emit_open_tag(struct parser *parser, char *a, char *b) if (*ns == ':') a = ns + 1; - head = fz_malloc_struct(parser->ctx, fz_xml); + head = fz_malloc_struct(ctx, fz_xml); if (b - a > sizeof(head->name) - 1) b = a + sizeof(head->name) - 1; memcpy(head->name, a, b - a); @@ -325,12 +324,12 @@ static void xml_emit_open_tag(struct parser *parser, char *a, char *b) parser->depth++; } -static void xml_emit_att_name(struct parser *parser, char *a, char *b) +static void xml_emit_att_name(fz_context *ctx, struct parser *parser, char *a, char *b) { fz_xml *head = parser->head; struct attribute *att; - att = fz_malloc_struct(parser->ctx, struct attribute); + att = fz_malloc_struct(ctx, struct attribute); if (b - a > sizeof(att->name) - 1) b = a + sizeof(att->name) - 1; memcpy(att->name, a, b - a); @@ -340,7 +339,7 @@ static void xml_emit_att_name(struct parser *parser, char *a, char *b) head->atts = att; } -static void xml_emit_att_value(struct parser *parser, char *a, char *b) +static void xml_emit_att_value(fz_context *ctx, struct parser *parser, char *a, char *b) { fz_xml *head = parser->head; struct attribute *att = head->atts; @@ -348,7 +347,7 @@ static void xml_emit_att_value(struct parser *parser, char *a, char *b) int c; /* entities are all longer than UTFmax so runetochar is safe */ - s = att->value = fz_malloc(parser->ctx, b - a + 1); + s = att->value = fz_malloc(ctx, b - a + 1); while (a < b) { if (*a == '&') { a += xml_parse_entity(&c, a); @@ -361,14 +360,14 @@ static void xml_emit_att_value(struct parser *parser, char *a, char *b) *s = 0; } -static void xml_emit_close_tag(struct parser *parser) +static void xml_emit_close_tag(fz_context *ctx, struct parser *parser) { parser->depth--; if (parser->head->up) parser->head = parser->head->up; } -static void xml_emit_text(struct parser *parser, char *a, char *b) +static void xml_emit_text(fz_context *ctx, struct parser *parser, char *a, char *b) { static char *empty = ""; fz_xml *head; @@ -389,11 +388,11 @@ static void xml_emit_text(struct parser *parser, char *a, char *b) return; } - xml_emit_open_tag(parser, empty, empty); + xml_emit_open_tag(ctx, parser, empty, empty); head = parser->head; /* entities are all longer than UTFmax so runetochar is safe */ - s = head->text = fz_malloc(parser->ctx, b - a + 1); + s = head->text = fz_malloc(ctx, b - a + 1); while (a < b) { if (*a == '&') { a += xml_parse_entity(&c, a); @@ -405,27 +404,27 @@ static void xml_emit_text(struct parser *parser, char *a, char *b) } *s = 0; - xml_emit_close_tag(parser); + xml_emit_close_tag(ctx, parser); } -static void xml_emit_cdata(struct parser *parser, char *a, char *b) +static void xml_emit_cdata(fz_context *ctx, struct parser *parser, char *a, char *b) { static char *empty = ""; fz_xml *head; char *s; - xml_emit_open_tag(parser, empty, empty); + xml_emit_open_tag(ctx, parser, empty, empty); head = parser->head; - s = head->text = fz_malloc(parser->ctx, b - a + 1); + s = head->text = fz_malloc(ctx, b - a + 1); while (a < b) *s++ = *a++; *s = 0; - xml_emit_close_tag(parser); + xml_emit_close_tag(ctx, parser); } -static char *xml_parse_document_imp(struct parser *x, char *p) +static char *xml_parse_document_imp(fz_context *ctx, struct parser *parser, char *p) { char *mark; int quote; @@ -433,7 +432,7 @@ static char *xml_parse_document_imp(struct parser *x, char *p) parse_text: mark = p; while (*p && *p != '<') ++p; - if (mark != p) xml_emit_text(x, mark, p); + if (mark != p) xml_emit_text(ctx, parser, mark, p); if (*p == '<') { ++p; goto parse_element; } return NULL; @@ -471,7 +470,7 @@ parse_cdata: mark = p; while (*p) { if (p[0] == ']' && p[1] == ']' && p[2] == '>') { - xml_emit_cdata(x, mark, p); + xml_emit_cdata(ctx, parser, mark, p); p += 3; goto parse_text; } @@ -495,17 +494,17 @@ parse_closing_element: while (iswhite(*p)) ++p; if (*p != '>') return "syntax error in closing element"; - xml_emit_close_tag(x); + xml_emit_close_tag(ctx, parser); ++p; goto parse_text; parse_element_name: mark = p; while (isname(*p)) ++p; - xml_emit_open_tag(x, mark, p); + xml_emit_open_tag(ctx, parser, mark, p); if (*p == '>') { ++p; goto parse_text; } if (p[0] == '/' && p[1] == '>') { - xml_emit_close_tag(x); + xml_emit_close_tag(ctx, parser); p += 2; goto parse_text; } @@ -519,7 +518,7 @@ parse_attributes: goto parse_attribute_name; if (*p == '>') { ++p; goto parse_text; } if (p[0] == '/' && p[1] == '>') { - xml_emit_close_tag(x); + xml_emit_close_tag(ctx, parser); p += 2; goto parse_text; } @@ -528,7 +527,7 @@ parse_attributes: parse_attribute_name: mark = p; while (isname(*p)) ++p; - xml_emit_att_name(x, mark, p); + xml_emit_att_name(ctx, parser, mark, p); while (iswhite(*p)) ++p; if (*p == '=') { ++p; goto parse_attribute_value; } return "syntax error after attribute name"; @@ -541,7 +540,7 @@ parse_attribute_value: mark = p; while (*p && *p != quote) ++p; if (*p == quote) { - xml_emit_att_value(x, mark, p++); + xml_emit_att_value(ctx, parser, mark, p++); goto parse_attributes; } return "end of data in attribute value"; @@ -599,7 +598,6 @@ fz_parse_xml(fz_context *ctx, unsigned char *s, int n, int preserve_white) memset(&root, 0, sizeof(root)); parser.head = &root; - parser.ctx = ctx; parser.preserve_white = preserve_white; parser.depth = 0; @@ -607,7 +605,7 @@ fz_parse_xml(fz_context *ctx, unsigned char *s, int n, int preserve_white) fz_try(ctx) { - error = xml_parse_document_imp(&parser, p); + error = xml_parse_document_imp(ctx, &parser, p); if (error) fz_throw(ctx, FZ_ERROR_GENERIC, "%s", error); } diff --git a/source/img/muimage.c b/source/img/muimage.c deleted file mode 100644 index 30f9b043..00000000 --- a/source/img/muimage.c +++ /dev/null @@ -1,190 +0,0 @@ -#include "mupdf/img.h" - -#include <ctype.h> /* for tolower */ - -#define DPI 72.0f - -static void image_init_document(image_document *doc); - -struct image_document_s -{ - fz_document super; - - fz_context *ctx; - fz_stream *file; - fz_image *image; -}; - -image_document * -image_open_document_with_stream(fz_context *ctx, fz_stream *file) -{ - image_document *doc; - fz_buffer *buffer = NULL; - - doc = fz_malloc_struct(ctx, image_document); - image_init_document(doc); - doc->ctx = ctx; - doc->file = fz_keep_stream(file); - - fz_var(buffer); - - fz_try(ctx) - { - buffer = fz_read_all(doc->file, 1024); - doc->image = fz_new_image_from_buffer(ctx, buffer); - } - fz_always(ctx) - { - fz_drop_buffer(ctx, buffer); - } - fz_catch(ctx) - { - image_close_document(doc); - fz_rethrow(ctx); - } - - return doc; -} - -image_document * -image_open_document(fz_context *ctx, const char *filename) -{ - fz_stream *file; - image_document *doc; - - file = fz_open_file(ctx, filename); - if (!file) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", filename, strerror(errno)); - - fz_try(ctx) - { - doc = image_open_document_with_stream(ctx, file); - } - fz_always(ctx) - { - fz_drop_stream(file); - } - fz_catch(ctx) - { - fz_rethrow(ctx); - } - - return doc; -} - -void -image_close_document(image_document *doc) -{ - fz_context *ctx = doc->ctx; - fz_drop_image(ctx, doc->image); - fz_drop_stream(doc->file); - fz_free(ctx, doc); -} - -int -image_count_pages(image_document *doc) -{ - return 1; -} - -image_page * -image_load_page(image_document *doc, int number) -{ - if (number != 0) - return NULL; - - return (image_page *)doc->image; -} - -void -image_free_page(image_document *doc, image_page *page) -{ -} - -fz_rect * -image_bound_page(image_document *doc, image_page *page, fz_rect *bbox) -{ - fz_image *image = (fz_image *)page; - int xres, yres; - fz_image_get_sanitised_res(image, &xres, &yres); - bbox->x0 = bbox->y0 = 0; - bbox->x1 = image->w * DPI / xres; - bbox->y1 = image->h * DPI / yres; - return bbox; -} - -void -image_run_page(image_document *doc, image_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) -{ - fz_matrix local_ctm = *ctm; - fz_image *image = (fz_image *)page; - int xres, yres; - float w, h; - fz_image_get_sanitised_res(image, &xres, &yres); - w = image->w * DPI / xres; - h = image->h * DPI / yres; - fz_pre_scale(&local_ctm, w, h); - fz_fill_image(dev, image, &local_ctm, 1); -} - -static int -image_meta(image_document *doc, int key, void *ptr, int size) -{ - switch(key) - { - case FZ_META_FORMAT_INFO: - sprintf((char *)ptr, "IMAGE"); - return FZ_META_OK; - default: - return FZ_META_UNKNOWN_KEY; - } -} - -static void -image_rebind(image_document *doc, fz_context *ctx) -{ - doc->ctx = ctx; - fz_rebind_stream(doc->file, ctx); -} - -static void -image_init_document(image_document *doc) -{ - doc->super.refs = 1; - doc->super.close = (fz_document_close_fn *)image_close_document; - doc->super.count_pages = (fz_document_count_pages_fn *)image_count_pages; - doc->super.load_page = (fz_document_load_page_fn *)image_load_page; - doc->super.bound_page = (fz_document_bound_page_fn *)image_bound_page; - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)image_run_page; - doc->super.free_page = (fz_document_free_page_fn *)image_free_page; - doc->super.meta = (fz_document_meta_fn *)image_meta; - doc->super.rebind = (fz_document_rebind_fn *)image_rebind; -} - -static int -image_recognize(fz_context *doc, const char *magic) -{ - char *ext = strrchr(magic, '.'); - - if (ext) - { - if (!fz_strcasecmp(ext, ".png") || !fz_strcasecmp(ext, ".jpg") || - !fz_strcasecmp(ext, ".jpeg") || !fz_strcasecmp(ext, ".jfif") || - !fz_strcasecmp(ext, ".jfif-tbnl") || !fz_strcasecmp(ext, ".jpe")) - return 100; - } - if (!strcmp(magic, "png") || !strcmp(magic, "image/png") || - !strcmp(magic, "jpg") || !strcmp(magic, "image/jpeg") || - !strcmp(magic, "jpeg") || !strcmp(magic, "image/pjpeg") || - !strcmp(magic, "jpe") || !strcmp(magic, "jfif")) - return 100; - - return 0; -} - -fz_document_handler img_document_handler = -{ - (fz_document_recognize_fn *)&image_recognize, - (fz_document_open_fn *)&image_open_document, - (fz_document_open_with_stream_fn *)&image_open_document_with_stream -}; diff --git a/source/pdf/js/pdf-js.c b/source/pdf/js/pdf-js.c index 8364fc95..008cebfb 100644 --- a/source/pdf/js/pdf-js.c +++ b/source/pdf/js/pdf-js.c @@ -1,7 +1,11 @@ #include "mupdf/pdf.h" +/* TODO: js->doc -> doc */ +/* TODO: js->ctx -> ctx */ + struct pdf_js_s { + fz_context *ctx; pdf_document *doc; pdf_obj *form; pdf_js_event event; @@ -15,7 +19,7 @@ struct pdf_js_s static pdf_jsimp_obj *app_alert(void *jsctx, void *obj, int argc, pdf_jsimp_obj *args[]) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_jsimp_obj *cMsg_obj = NULL; pdf_jsimp_obj *nIcon_obj = NULL; pdf_jsimp_obj *nType_obj = NULL; @@ -77,7 +81,7 @@ static pdf_jsimp_obj *app_alert(void *jsctx, void *obj, int argc, pdf_jsimp_obj if (cTitle_obj) event.title = pdf_jsimp_to_string(js->imp, cTitle_obj); - pdf_event_issue_alert(js->doc, &event); + pdf_event_issue_alert(ctx, js->doc, &event); nButton_obj = pdf_jsimp_from_number(js->imp, (double)event.button_pressed); } fz_always(ctx) @@ -102,7 +106,7 @@ static pdf_jsimp_obj *app_execDialog(void *jsctx, void *obj, int argc, pdf_jsimp { pdf_js *js = (pdf_js *)jsctx; - pdf_event_issue_exec_dialog(js->doc); + pdf_event_issue_exec_dialog(js->ctx, js->doc); return NULL; } @@ -112,7 +116,7 @@ static pdf_jsimp_obj *app_execMenuItem(void *jsctx, void *obj, int argc, pdf_jsi pdf_js *js = (pdf_js *)jsctx; if (argc == 1) - pdf_event_issue_exec_menu_item(js->doc, pdf_jsimp_to_string(js->imp, args[0])); + pdf_event_issue_exec_menu_item(js->ctx, js->doc, pdf_jsimp_to_string(js->imp, args[0])); return NULL; } @@ -133,19 +137,18 @@ static pdf_jsimp_obj *app_launchURL(void *jsctx, void *obj, int argc, pdf_jsimp_ cUrl = pdf_jsimp_to_string(js->imp, args[0]); } - pdf_event_issue_launch_url(js->doc, cUrl, bNewFrame); + pdf_event_issue_launch_url(js->ctx, js->doc, cUrl, bNewFrame); return NULL; } -static pdf_obj *load_color(pdf_document *doc, pdf_jsimp *imp, pdf_jsimp_obj *val) +static pdf_obj *load_color(fz_context *ctx, pdf_document *doc, pdf_jsimp *imp, pdf_jsimp_obj *val) { pdf_obj *col = NULL; pdf_obj *comp = NULL; pdf_jsimp_obj *jscomp = NULL; int i; int n; - fz_context *ctx = doc->ctx; n = pdf_jsimp_array_len(imp, val); @@ -155,7 +158,7 @@ static pdf_obj *load_color(pdf_document *doc, pdf_jsimp *imp, pdf_jsimp_obj *val if (n <= 1) return NULL; - col = pdf_new_array(doc, n-1); + col = pdf_new_array(ctx, doc, n-1); fz_var(comp); fz_var(jscomp); @@ -164,19 +167,19 @@ static pdf_obj *load_color(pdf_document *doc, pdf_jsimp *imp, pdf_jsimp_obj *val for (i = 0; i < n-1; i++) { jscomp = pdf_jsimp_array_item(imp, val, i+1); - comp = pdf_new_real(doc, pdf_jsimp_to_number(imp, jscomp)); - pdf_array_push(col, comp); + comp = pdf_new_real(ctx, doc, pdf_jsimp_to_number(imp, jscomp)); + pdf_array_push(ctx, col, comp); pdf_jsimp_drop_obj(imp, jscomp); jscomp = NULL; - pdf_drop_obj(comp); + pdf_drop_obj(ctx, comp); comp = NULL; } } fz_catch(ctx) { pdf_jsimp_drop_obj(imp, jscomp); - pdf_drop_obj(comp); - pdf_drop_obj(col); + pdf_drop_obj(ctx, comp); + pdf_drop_obj(ctx, col); fz_rethrow(ctx); } @@ -193,7 +196,7 @@ static pdf_jsimp_obj *field_buttonSetCaption(void *jsctx, void *obj, int argc, p return NULL; name = pdf_jsimp_to_string(js->imp, args[0]); - pdf_field_set_button_caption(js->doc, field, name); + pdf_field_set_button_caption(js->ctx, js->doc, field, name); return NULL; } @@ -201,7 +204,7 @@ static pdf_jsimp_obj *field_buttonSetCaption(void *jsctx, void *obj, int argc, p static pdf_jsimp_obj *field_getName(void *jsctx, void *obj) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_obj *field = (pdf_obj *)obj; char *name; pdf_jsimp_obj *oname = NULL; @@ -209,7 +212,7 @@ static pdf_jsimp_obj *field_getName(void *jsctx, void *obj) if (field == NULL) return NULL; - name = pdf_field_name(js->doc, field); + name = pdf_field_name(ctx, js->doc, field); fz_try(ctx) { oname = pdf_jsimp_from_string(js->imp, name); @@ -229,7 +232,7 @@ static pdf_jsimp_obj *field_getName(void *jsctx, void *obj) static void field_setName(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_warn(js->doc->ctx, "Unexpected call to field_setName"); + fz_warn(js->ctx, "Unexpected call to field_setName"); } static pdf_jsimp_obj *field_getDisplay(void *jsctx, void *obj) @@ -237,7 +240,7 @@ static pdf_jsimp_obj *field_getDisplay(void *jsctx, void *obj) pdf_js *js = (pdf_js *)jsctx; pdf_obj *field = (pdf_obj *)obj; - return field ? pdf_jsimp_from_number(js->imp, (double)pdf_field_display(js->doc, field)) : NULL; + return field ? pdf_jsimp_from_number(js->imp, (double)pdf_field_display(js->ctx, js->doc, field)) : NULL; } static void field_setDisplay(void *jsctx, void *obj, pdf_jsimp_obj *val) @@ -245,7 +248,7 @@ static void field_setDisplay(void *jsctx, void *obj, pdf_jsimp_obj *val) pdf_js *js = (pdf_js *)jsctx; pdf_obj *field = (pdf_obj *)obj; if (field) - pdf_field_set_display(js->doc, field, (int)pdf_jsimp_to_number(js->imp, val)); + pdf_field_set_display(js->ctx, js->doc, field, (int)pdf_jsimp_to_number(js->imp, val)); } static pdf_jsimp_obj *field_getFillColor(void *jsctx, void *obj) @@ -256,21 +259,21 @@ static pdf_jsimp_obj *field_getFillColor(void *jsctx, void *obj) static void field_setFillColor(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_obj *field = (pdf_obj *)obj; pdf_obj *col; if (!field) return; - col = load_color(js->doc, js->imp, val); + col = load_color(ctx, js->doc, js->imp, val); fz_try(ctx) { - pdf_field_set_fill_color(js->doc, field, col); + pdf_field_set_fill_color(ctx, js->doc, field, col); } fz_always(ctx) { - pdf_drop_obj(col); + pdf_drop_obj(ctx, col); } fz_catch(ctx) { @@ -286,21 +289,21 @@ static pdf_jsimp_obj *field_getTextColor(void *jsctx, void *obj) static void field_setTextColor(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_obj *field = (pdf_obj *)obj; pdf_obj *col; if (!field) return; - col = load_color(js->doc, js->imp, val); + col = load_color(ctx, js->doc, js->imp, val); fz_try(ctx) { - pdf_field_set_text_color(js->doc, field, col); + pdf_field_set_text_color(ctx, js->doc, field, col); } fz_always(ctx) { - pdf_drop_obj(col); + pdf_drop_obj(ctx, col); } fz_catch(ctx) { @@ -313,7 +316,7 @@ static pdf_jsimp_obj *field_getBorderStyle(void *jsctx, void *obj) pdf_js *js = (pdf_js *)jsctx; pdf_obj *field = (pdf_obj *)obj; - return field ? pdf_jsimp_from_string(js->imp, pdf_field_border_style(js->doc, field)) : NULL; + return field ? pdf_jsimp_from_string(js->imp, pdf_field_border_style(js->ctx, js->doc, field)) : NULL; } static void field_setBorderStyle(void *jsctx, void *obj, pdf_jsimp_obj *val) @@ -322,7 +325,7 @@ static void field_setBorderStyle(void *jsctx, void *obj, pdf_jsimp_obj *val) pdf_obj *field = (pdf_obj *)obj; if (field) - pdf_field_set_border_style(js->doc, field, pdf_jsimp_to_string(js->imp, val)); + pdf_field_set_border_style(js->ctx, js->doc, field, pdf_jsimp_to_string(js->imp, val)); } static pdf_jsimp_obj *field_getValue(void *jsctx, void *obj) @@ -334,7 +337,7 @@ static pdf_jsimp_obj *field_getValue(void *jsctx, void *obj) if (!field) return NULL; - fval = pdf_field_value(js->doc, field); + fval = pdf_field_value(js->ctx, js->doc, field); return pdf_jsimp_from_string(js->imp, fval?fval:""); } @@ -344,7 +347,7 @@ static void field_setValue(void *jsctx, void *obj, pdf_jsimp_obj *val) pdf_obj *field = (pdf_obj *)obj; if (field) - (void)pdf_field_set_value(js->doc, field, pdf_jsimp_to_string(js->imp, val)); + (void)pdf_field_set_value(js->ctx, js->doc, field, pdf_jsimp_to_string(js->imp, val)); } static pdf_jsimp_obj *event_getTarget(void *jsctx, void *obj) @@ -357,7 +360,7 @@ static pdf_jsimp_obj *event_getTarget(void *jsctx, void *obj) static void event_setTarget(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_warn(js->doc->ctx, "Unexpected call to event_setTarget"); + fz_warn(js->ctx, "Unexpected call to event_setTarget"); } static pdf_jsimp_obj *event_getValue(void *jsctx, void *obj) @@ -371,7 +374,7 @@ static pdf_jsimp_obj *event_getValue(void *jsctx, void *obj) static void event_setValue(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; fz_free(ctx, js->event.value); js->event.value = NULL; js->event.value = fz_strdup(ctx, pdf_jsimp_to_string(js->imp, val)); @@ -387,7 +390,7 @@ static pdf_jsimp_obj *event_getWillCommit(void *jsctx, void *obj) static void event_setWillCommit(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_warn(js->doc->ctx, "Unexpected call to event_setWillCommit"); + fz_warn(js->ctx, "Unexpected call to event_setWillCommit"); } static pdf_jsimp_obj *event_getRC(void *jsctx, void *obj) @@ -414,7 +417,7 @@ static pdf_jsimp_obj *doc_getEvent(void *jsctx, void *obj) static void doc_setEvent(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_warn(js->doc->ctx, "Unexpected call to doc_setEvent"); + fz_warn(js->ctx, "Unexpected call to doc_setEvent"); } static pdf_jsimp_obj *doc_getApp(void *jsctx, void *obj) @@ -427,7 +430,7 @@ static pdf_jsimp_obj *doc_getApp(void *jsctx, void *obj) static void doc_setApp(void *jsctx, void *obj, pdf_jsimp_obj *val) { pdf_js *js = (pdf_js *)jsctx; - fz_warn(js->doc->ctx, "Unexpected call to doc_setApp"); + fz_warn(js->ctx, "Unexpected call to doc_setApp"); } static char *utf8_to_pdf(fz_context *ctx, char *utf8) @@ -466,7 +469,7 @@ static char *utf8_to_pdf(fz_context *ctx, char *utf8) static pdf_jsimp_obj *doc_getField(void *jsctx, void *obj, int argc, pdf_jsimp_obj *args[]) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_obj *dict = NULL; char *utf8; char *name = NULL; @@ -483,7 +486,7 @@ static pdf_jsimp_obj *doc_getField(void *jsctx, void *obj, int argc, pdf_jsimp_o if (utf8) { name = utf8_to_pdf(ctx, utf8); - dict = pdf_lookup_field(js->form, name); + dict = pdf_lookup_field(js->ctx, js->form, name); } } fz_always(ctx) @@ -502,7 +505,7 @@ static pdf_jsimp_obj *doc_getField(void *jsctx, void *obj, int argc, pdf_jsimp_o static void reset_field(pdf_js *js, pdf_jsimp_obj *item) { - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; char *name = NULL; char *utf8 = pdf_jsimp_to_string(js->imp, item); @@ -514,9 +517,9 @@ static void reset_field(pdf_js *js, pdf_jsimp_obj *item) fz_try(ctx) { name = utf8_to_pdf(ctx, utf8); - field = pdf_lookup_field(js->form, name); + field = pdf_lookup_field(js->ctx, js->form, name); if (field) - pdf_field_reset(js->doc, field); + pdf_field_reset(js->ctx, js->doc, field); } fz_always(ctx) { @@ -532,7 +535,7 @@ static void reset_field(pdf_js *js, pdf_jsimp_obj *item) static pdf_jsimp_obj *doc_resetForm(void *jsctx, void *obj, int argc, pdf_jsimp_obj *args[]) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_jsimp_obj *arr = NULL; pdf_jsimp_obj *elem = NULL; @@ -583,10 +586,10 @@ static pdf_jsimp_obj *doc_resetForm(void *jsctx, void *obj, int argc, pdf_jsimp_ else { /* No argument or null passed in means reset all. */ - int i, n = pdf_array_len(js->form); + int i, n = pdf_array_len(ctx, js->form); for (i = 0; i < n; i++) - pdf_field_reset(js->doc, pdf_array_get(js->form, i)); + pdf_field_reset(js->ctx, js->doc, pdf_array_get(ctx, js->form, i)); } } fz_catch(ctx) @@ -601,7 +604,7 @@ static pdf_jsimp_obj *doc_print(void *jsctx, void *obj, int argc, pdf_jsimp_obj { pdf_js *js = (pdf_js *)jsctx; - pdf_event_issue_print(js->doc); + pdf_event_issue_print(js->ctx, js->doc); return NULL; } @@ -609,7 +612,7 @@ static pdf_jsimp_obj *doc_print(void *jsctx, void *obj, int argc, pdf_jsimp_obj static pdf_jsimp_obj *doc_mailDoc(void *jsctx, void *obj, int argc, pdf_jsimp_obj *args[]) { pdf_js *js = (pdf_js *)jsctx; - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; pdf_jsimp_obj *bUI_obj = NULL; pdf_jsimp_obj *cTo_obj = NULL; pdf_jsimp_obj *cCc_obj = NULL; @@ -684,7 +687,7 @@ static pdf_jsimp_obj *doc_mailDoc(void *jsctx, void *obj, int argc, pdf_jsimp_ob if (cMessage_obj) event.message = pdf_jsimp_to_string(js->imp, cMessage_obj); - pdf_event_issue_mail_doc(js->doc, &event); + pdf_event_issue_mail_doc(js->ctx, js->doc, &event); } fz_always(ctx) { @@ -774,7 +777,7 @@ static void pdf_drop_js(pdf_js *js) { if (js) { - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; fz_free(ctx, js->event.value); pdf_jsimp_drop_type(js->imp, js->apptype); pdf_jsimp_drop_type(js->imp, js->eventtype); @@ -785,9 +788,8 @@ static void pdf_drop_js(pdf_js *js) } } -static pdf_js *pdf_new_js(pdf_document *doc) +static pdf_js *pdf_new_js(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; pdf_js *js = NULL; fz_var(js); @@ -796,12 +798,13 @@ static pdf_js *pdf_new_js(pdf_document *doc) pdf_obj *root, *acroform; js = fz_malloc_struct(ctx, pdf_js); + js->ctx = ctx; js->doc = doc; /* Find the form array */ - root = pdf_dict_gets(pdf_trailer(doc), "Root"); - acroform = pdf_dict_gets(root, "AcroForm"); - js->form = pdf_dict_gets(acroform, "Fields"); + root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + acroform = pdf_dict_gets(ctx, root, "AcroForm"); + js->form = pdf_dict_gets(ctx, acroform, "Fields"); /* Initialise the javascript engine, passing the main context * for use in memory allocation and exception handling. Also @@ -823,7 +826,7 @@ static pdf_js *pdf_new_js(pdf_document *doc) static void pdf_js_load_document_level(pdf_js *js) { pdf_document *doc = js->doc; - fz_context *ctx = doc->ctx; + fz_context *ctx = js->ctx; pdf_obj *javascript = NULL; char *codebuf = NULL; @@ -833,18 +836,18 @@ static void pdf_js_load_document_level(pdf_js *js) { int len, i; - javascript = pdf_load_name_tree(doc, "JavaScript"); - len = pdf_dict_len(javascript); + javascript = pdf_load_name_tree(ctx, doc, "JavaScript"); + len = pdf_dict_len(ctx, javascript); for (i = 0; i < len; i++) { - pdf_obj *fragment = pdf_dict_get_val(javascript, i); - pdf_obj *code = pdf_dict_gets(fragment, "JS"); + pdf_obj *fragment = pdf_dict_get_val(ctx, javascript, i); + pdf_obj *code = pdf_dict_gets(ctx, fragment, "JS"); fz_var(codebuf); fz_try(ctx) { - codebuf = pdf_to_utf8(doc, code); + codebuf = pdf_to_utf8(ctx, doc, code); pdf_jsimp_execute(js->imp, codebuf); } fz_always(ctx) @@ -861,7 +864,7 @@ static void pdf_js_load_document_level(pdf_js *js) } fz_always(ctx) { - pdf_drop_obj(javascript); + pdf_drop_obj(ctx, javascript); } fz_catch(ctx) { @@ -873,7 +876,7 @@ void pdf_js_setup_event(pdf_js *js, pdf_js_event *e) { if (js) { - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; char *ev = e->value ? e->value : ""; char *v = fz_strdup(ctx, ev); @@ -894,7 +897,7 @@ void pdf_js_execute(pdf_js *js, char *code) { if (js) { - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; fz_try(ctx) { pdf_jsimp_execute(js->imp, code); @@ -909,7 +912,7 @@ void pdf_js_execute_count(pdf_js *js, char *code, int count) { if (js) { - fz_context *ctx = js->doc->ctx; + fz_context *ctx = js->ctx; fz_try(ctx) { pdf_jsimp_execute_count(js->imp, code, count); @@ -920,23 +923,23 @@ void pdf_js_execute_count(pdf_js *js, char *code, int count) } } -void pdf_enable_js(pdf_document *doc) +void pdf_enable_js(fz_context *ctx, pdf_document *doc) { if (!doc->js) { - doc->js = pdf_new_js(doc); + doc->js = pdf_new_js(ctx, doc); doc->drop_js = pdf_drop_js; pdf_js_load_document_level(doc->js); } } -void pdf_disable_js(pdf_document *doc) +void pdf_disable_js(fz_context *ctx, pdf_document *doc) { if (doc->js) doc->drop_js(doc->js); doc->js = NULL; } -int pdf_js_supported(pdf_document *doc) +int pdf_js_supported(fz_context *ctx, pdf_document *doc) { return doc->js != NULL; } diff --git a/source/pdf/pdf-annot-edit.c b/source/pdf/pdf-annot-edit.c index 719f92bd..565e3171 100644 --- a/source/pdf/pdf-annot-edit.c +++ b/source/pdf/pdf-annot-edit.c @@ -36,48 +36,47 @@ static const char *annot_type_str(fz_annot_type type) } void -pdf_update_annot(pdf_document *doc, pdf_annot *annot) +pdf_update_annot(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { pdf_obj *obj, *ap, *as, *n; - fz_context *ctx = doc->ctx; if (doc->update_appearance) - doc->update_appearance(doc, annot); + doc->update_appearance(ctx, doc, annot); obj = annot->obj; - ap = pdf_dict_gets(obj, "AP"); - as = pdf_dict_gets(obj, "AS"); + ap = pdf_dict_gets(ctx, obj, "AP"); + as = pdf_dict_gets(ctx, obj, "AS"); - if (pdf_is_dict(ap)) + if (pdf_is_dict(ctx, ap)) { pdf_hotspot *hp = &doc->hotspot; n = NULL; - if (hp->num == pdf_to_num(obj) - && hp->gen == pdf_to_gen(obj) + if (hp->num == pdf_to_num(ctx, obj) + && hp->gen == pdf_to_gen(ctx, obj) && (hp->state & HOTSPOT_POINTER_DOWN)) { - n = pdf_dict_gets(ap, "D"); /* down state */ + n = pdf_dict_gets(ctx, ap, "D"); /* down state */ } if (n == NULL) - n = pdf_dict_gets(ap, "N"); /* normal state */ + n = pdf_dict_gets(ctx, ap, "N"); /* normal state */ /* lookup current state in sub-dictionary */ - if (!pdf_is_stream(doc, pdf_to_num(n), pdf_to_gen(n))) - n = pdf_dict_get(n, as); + if (!pdf_is_stream(ctx, doc, pdf_to_num(ctx, n), pdf_to_gen(ctx, n))) + n = pdf_dict_get(ctx, n, as); pdf_drop_xobject(ctx, annot->ap); annot->ap = NULL; - if (pdf_is_stream(doc, pdf_to_num(n), pdf_to_gen(n))) + if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, n), pdf_to_gen(ctx, n))) { fz_try(ctx) { - annot->ap = pdf_load_xobject(doc, n); - pdf_transform_annot(annot); + annot->ap = pdf_load_xobject(ctx, doc, n); + pdf_transform_annot(ctx, annot); annot->ap_iteration = annot->ap->iteration; } fz_catch(ctx) @@ -90,11 +89,10 @@ pdf_update_annot(pdf_document *doc, pdf_annot *annot) } pdf_annot * -pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type) +pdf_create_annot(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_annot_type type) { - fz_context *ctx = doc->ctx; pdf_annot *annot = NULL; - pdf_obj *annot_obj = pdf_new_dict(doc, 0); + pdf_obj *annot_obj = pdf_new_dict(ctx, doc, 0); pdf_obj *ind_obj = NULL; fz_var(annot); @@ -104,20 +102,20 @@ pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type) int ind_obj_num; fz_rect rect = {0.0, 0.0, 0.0, 0.0}; const char *type_str = annot_type_str(type); - pdf_obj *annot_arr = pdf_dict_gets(page->me, "Annots"); + pdf_obj *annot_arr = pdf_dict_gets(ctx, page->me, "Annots"); if (annot_arr == NULL) { - annot_arr = pdf_new_array(doc, 0); - pdf_dict_puts_drop(page->me, "Annots", annot_arr); + annot_arr = pdf_new_array(ctx, doc, 0); + pdf_dict_puts_drop(ctx, page->me, "Annots", annot_arr); } - pdf_dict_puts_drop(annot_obj, "Type", pdf_new_name(doc, "Annot")); + pdf_dict_puts_drop(ctx, annot_obj, "Type", pdf_new_name(ctx, doc, "Annot")); - pdf_dict_puts_drop(annot_obj, "Subtype", pdf_new_name(doc, type_str)); - pdf_dict_puts_drop(annot_obj, "Rect", pdf_new_rect(doc, &rect)); + pdf_dict_puts_drop(ctx, annot_obj, "Subtype", pdf_new_name(ctx, doc, type_str)); + pdf_dict_puts_drop(ctx, annot_obj, "Rect", pdf_new_rect(ctx, doc, &rect)); /* Make printable as default */ - pdf_dict_puts_drop(annot_obj, "F", pdf_new_int(doc, F_Print)); + pdf_dict_puts_drop(ctx, annot_obj, "F", pdf_new_int(ctx, doc, F_Print)); annot = fz_malloc_struct(ctx, pdf_annot); annot->page = page; @@ -132,11 +130,11 @@ pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type) Insert the object in the hierarchy and the structure in the page's array. */ - ind_obj_num = pdf_create_object(doc); - pdf_update_object(doc, ind_obj_num, annot_obj); - ind_obj = pdf_new_indirect(doc, ind_obj_num, 0); - pdf_array_push(annot_arr, ind_obj); - annot->obj = pdf_keep_obj(ind_obj); + ind_obj_num = pdf_create_object(ctx, doc); + pdf_update_object(ctx, doc, ind_obj_num, annot_obj); + ind_obj = pdf_new_indirect(ctx, doc, ind_obj_num, 0); + pdf_array_push(ctx, annot_arr, ind_obj); + annot->obj = pdf_keep_obj(ctx, ind_obj); /* Linking must be done after any call that might throw because @@ -150,8 +148,8 @@ pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type) } fz_always(ctx) { - pdf_drop_obj(annot_obj); - pdf_drop_obj(ind_obj); + pdf_drop_obj(ctx, annot_obj); + pdf_drop_obj(ctx, ind_obj); } fz_catch(ctx) { @@ -163,9 +161,8 @@ pdf_create_annot(pdf_document *doc, pdf_page *page, fz_annot_type type) } void -pdf_delete_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot) +pdf_delete_annot(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_annot *annot) { - fz_context *ctx = doc->ctx; pdf_annot **annotptr; pdf_obj *old_annot_arr; pdf_obj *annot_arr; @@ -197,34 +194,34 @@ pdf_delete_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot) annot->ap = NULL; /* Recreate the "Annots" array with this annot removed */ - old_annot_arr = pdf_dict_gets(page->me, "Annots"); + old_annot_arr = pdf_dict_gets(ctx, page->me, "Annots"); if (old_annot_arr) { - int i, n = pdf_array_len(old_annot_arr); - annot_arr = pdf_new_array(doc, n?(n-1):0); + int i, n = pdf_array_len(ctx, old_annot_arr); + annot_arr = pdf_new_array(ctx, doc, n?(n-1):0); fz_try(ctx) { for (i = 0; i < n; i++) { - pdf_obj *obj = pdf_array_get(old_annot_arr, i); + pdf_obj *obj = pdf_array_get(ctx, old_annot_arr, i); if (obj != annot->obj) - pdf_array_push(annot_arr, obj); + pdf_array_push(ctx, annot_arr, obj); } - if (pdf_is_indirect(old_annot_arr)) - pdf_update_object(doc, pdf_to_num(old_annot_arr), annot_arr); + if (pdf_is_indirect(ctx, old_annot_arr)) + pdf_update_object(ctx, doc, pdf_to_num(ctx, old_annot_arr), annot_arr); else - pdf_dict_puts(page->me, "Annots", annot_arr); + pdf_dict_puts(ctx, page->me, "Annots", annot_arr); - if (pdf_is_indirect(annot->obj)) - pdf_delete_object(doc, pdf_to_num(annot->obj)); + if (pdf_is_indirect(ctx, annot->obj)) + pdf_delete_object(ctx, doc, pdf_to_num(ctx, annot->obj)); } fz_always(ctx) { - pdf_drop_obj(annot_arr); + pdf_drop_obj(ctx, annot_arr); } fz_catch(ctx) { @@ -232,21 +229,21 @@ pdf_delete_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot) } } - pdf_drop_obj(annot->obj); + pdf_drop_obj(ctx, annot->obj); annot->obj = NULL; doc->dirty = 1; } void -pdf_set_markup_annot_quadpoints(pdf_document *doc, pdf_annot *annot, fz_point *qp, int n) +pdf_set_markup_annot_quadpoints(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point *qp, int n) { fz_matrix ctm; - pdf_obj *arr = pdf_new_array(doc, n*2); + pdf_obj *arr = pdf_new_array(ctx, doc, n*2); int i; fz_invert_matrix(&ctm, &annot->page->ctm); - pdf_dict_puts_drop(annot->obj, "QuadPoints", arr); + pdf_dict_puts_drop(ctx, annot->obj, "QuadPoints", arr); for (i = 0; i < n; i++) { @@ -254,40 +251,39 @@ pdf_set_markup_annot_quadpoints(pdf_document *doc, pdf_annot *annot, fz_point *q pdf_obj *r; fz_transform_point(&pt, &ctm); - r = pdf_new_real(doc, pt.x); - pdf_array_push_drop(arr, r); - r = pdf_new_real(doc, pt.y); - pdf_array_push_drop(arr, r); + r = pdf_new_real(ctx, doc, pt.x); + pdf_array_push_drop(ctx, arr, r); + r = pdf_new_real(ctx, doc, pt.y); + pdf_array_push_drop(ctx, arr, r); } } static void update_rect(fz_context *ctx, pdf_annot *annot) { - pdf_to_rect(ctx, pdf_dict_gets(annot->obj, "Rect"), &annot->rect); + pdf_to_rect(ctx, pdf_dict_gets(ctx, annot->obj, "Rect"), &annot->rect); annot->pagerect = annot->rect; fz_transform_rect(&annot->pagerect, &annot->page->ctm); } void -pdf_set_ink_annot_list(pdf_document *doc, pdf_annot *annot, fz_point *pts, int *counts, int ncount, float color[3], float thickness) +pdf_set_ink_annot_list(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point *pts, int *counts, int ncount, float color[3], float thickness) { - fz_context *ctx = doc->ctx; fz_matrix ctm; - pdf_obj *list = pdf_new_array(doc, ncount); + pdf_obj *list = pdf_new_array(ctx, doc, ncount); pdf_obj *bs, *col; fz_rect rect; int i, k = 0; fz_invert_matrix(&ctm, &annot->page->ctm); - pdf_dict_puts_drop(annot->obj, "InkList", list); + pdf_dict_puts_drop(ctx, annot->obj, "InkList", list); for (i = 0; i < ncount; i++) { int j; - pdf_obj *arc = pdf_new_array(doc, counts[i]); + pdf_obj *arc = pdf_new_array(ctx, doc, counts[i]); - pdf_array_push_drop(list, arc); + pdf_array_push_drop(ctx, list, arc); for (j = 0; j < counts[i]; j++) { @@ -305,8 +301,8 @@ pdf_set_ink_annot_list(pdf_document *doc, pdf_annot *annot, fz_point *pts, int * fz_include_point_in_rect(&rect, &pt); } - pdf_array_push_drop(arc, pdf_new_real(doc, pt.x)); - pdf_array_push_drop(arc, pdf_new_real(doc, pt.y)); + pdf_array_push_drop(ctx, arc, pdf_new_real(ctx, doc, pt.x)); + pdf_array_push_drop(ctx, arc, pdf_new_real(ctx, doc, pt.y)); k++; } } @@ -324,20 +320,20 @@ pdf_set_ink_annot_list(pdf_document *doc, pdf_annot *annot, fz_point *pts, int * rect.y1 += thickness; } - pdf_dict_puts_drop(annot->obj, "Rect", pdf_new_rect(doc, &rect)); + pdf_dict_puts_drop(ctx, annot->obj, "Rect", pdf_new_rect(ctx, doc, &rect)); update_rect(ctx, annot); - bs = pdf_new_dict(doc, 1); - pdf_dict_puts_drop(annot->obj, "BS", bs); - pdf_dict_puts_drop(bs, "W", pdf_new_real(doc, thickness)); + bs = pdf_new_dict(ctx, doc, 1); + pdf_dict_puts_drop(ctx, annot->obj, "BS", bs); + pdf_dict_puts_drop(ctx, bs, "W", pdf_new_real(ctx, doc, thickness)); - col = pdf_new_array(doc, 3); - pdf_dict_puts_drop(annot->obj, "C", col); + col = pdf_new_array(ctx, doc, 3); + pdf_dict_puts_drop(ctx, annot->obj, "C", col); for (i = 0; i < 3; i++) - pdf_array_push_drop(col, pdf_new_real(doc, color[i])); + pdf_array_push_drop(ctx, col, pdf_new_real(ctx, doc, color[i])); } -static void find_free_font_name(pdf_obj *fdict, char *buf, int buf_size) +static void find_free_font_name(fz_context *ctx, pdf_obj *fdict, char *buf, int buf_size) { int i; @@ -346,12 +342,12 @@ static void find_free_font_name(pdf_obj *fdict, char *buf, int buf_size) { snprintf(buf, buf_size, "F%d", i); - if (!pdf_dict_gets(fdict, buf)) + if (!pdf_dict_gets(ctx, fdict, buf)) break; } } -void pdf_set_text_annot_position(pdf_document *doc, pdf_annot *annot, fz_point pt) +void pdf_set_text_annot_position(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point pt) { fz_matrix ctm; fz_rect rect; @@ -364,28 +360,27 @@ void pdf_set_text_annot_position(pdf_document *doc, pdf_annot *annot, fz_point p rect.y1 = pt.y + TEXT_ANNOT_SIZE; fz_transform_rect(&rect, &ctm); - pdf_dict_puts_drop(annot->obj, "Rect", pdf_new_rect(doc, &rect)); + pdf_dict_puts_drop(ctx, annot->obj, "Rect", pdf_new_rect(ctx, doc, &rect)); - flags = pdf_to_int(pdf_dict_gets(annot->obj, "F")); + flags = pdf_to_int(ctx, pdf_dict_gets(ctx, annot->obj, "F")); flags |= (F_NoZoom|F_NoRotate); - pdf_dict_puts_drop(annot->obj, "F", pdf_new_int(doc, flags)); + pdf_dict_puts_drop(ctx, annot->obj, "F", pdf_new_int(ctx, doc, flags)); - update_rect(doc->ctx, annot); + update_rect(ctx, annot); } -void pdf_set_annot_contents(pdf_document *doc, pdf_annot *annot, char *text) +void pdf_set_annot_contents(fz_context *ctx, pdf_document *doc, pdf_annot *annot, char *text) { - pdf_dict_puts_drop(annot->obj, "Contents", pdf_new_string(doc, text, strlen(text))); + pdf_dict_puts_drop(ctx, annot->obj, "Contents", pdf_new_string(ctx, doc, text, strlen(text))); } -char *pdf_annot_contents(pdf_document *doc, pdf_annot *annot) +char *pdf_annot_contents(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { - return pdf_to_str_buf(pdf_dict_getp(annot->obj, "Contents")); + return pdf_to_str_buf(ctx, pdf_dict_getp(ctx, annot->obj, "Contents")); } -void pdf_set_free_text_details(pdf_document *doc, pdf_annot *annot, fz_point *pos, char *text, char *font_name, float font_size, float color[3]) +void pdf_set_free_text_details(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point *pos, char *text, char *font_name, float font_size, float color[3]) { - fz_context *ctx = doc->ctx; char nbuf[32]; pdf_obj *dr; pdf_obj *form_fonts; @@ -399,19 +394,19 @@ void pdf_set_free_text_details(pdf_document *doc, pdf_annot *annot, fz_point *po fz_invert_matrix(&ctm, &annot->page->ctm); - dr = pdf_dict_gets(annot->page->me, "Resources"); + dr = pdf_dict_gets(ctx, annot->page->me, "Resources"); if (!dr) { - dr = pdf_new_dict(doc, 1); - pdf_dict_putp_drop(annot->page->me, "Resources", dr); + dr = pdf_new_dict(ctx, doc, 1); + pdf_dict_putp_drop(ctx, annot->page->me, "Resources", dr); } /* Ensure the resource dictionary includes a font dict */ - form_fonts = pdf_dict_gets(dr, "Font"); + form_fonts = pdf_dict_gets(ctx, dr, "Font"); if (!form_fonts) { - form_fonts = pdf_new_dict(doc, 1); - pdf_dict_puts_drop(dr, "Font", form_fonts); + form_fonts = pdf_new_dict(ctx, doc, 1); + pdf_dict_puts_drop(ctx, dr, "Font", form_fonts); /* form_fonts is still valid if execution continues past the above call */ } @@ -423,16 +418,16 @@ void pdf_set_free_text_details(pdf_document *doc, pdf_annot *annot, fz_point *po int da_len; fz_rect bounds; - find_free_font_name(form_fonts, nbuf, sizeof(nbuf)); + find_free_font_name(ctx, form_fonts, nbuf, sizeof(nbuf)); - font = pdf_new_dict(doc, 5); - ref = pdf_new_ref(doc, font); - pdf_dict_puts_drop(form_fonts, nbuf, ref); + font = pdf_new_dict(ctx, doc, 5); + ref = pdf_new_ref(ctx, doc, font); + pdf_dict_puts_drop(ctx, form_fonts, nbuf, ref); - pdf_dict_puts_drop(font, "Type", pdf_new_name(doc, "Font")); - pdf_dict_puts_drop(font, "Subtype", pdf_new_name(doc, "Type1")); - pdf_dict_puts_drop(font, "BaseFont", pdf_new_name(doc, font_name)); - pdf_dict_puts_drop(font, "Encoding", pdf_new_name(doc, "WinAnsiEncoding")); + pdf_dict_puts_drop(ctx, font, "Type", pdf_new_name(ctx, doc, "Font")); + pdf_dict_puts_drop(ctx, font, "Subtype", pdf_new_name(ctx, doc, "Type1")); + pdf_dict_puts_drop(ctx, font, "BaseFont", pdf_new_name(ctx, doc, font_name)); + pdf_dict_puts_drop(ctx, font, "Encoding", pdf_new_name(ctx, doc, "WinAnsiEncoding")); memcpy(da_info.col, color, sizeof(float)*3); da_info.col_size = 3; @@ -443,12 +438,12 @@ void pdf_set_free_text_details(pdf_document *doc, pdf_annot *annot, fz_point *po pdf_fzbuf_print_da(ctx, fzbuf, &da_info); da_len = fz_buffer_storage(ctx, fzbuf, &da_str); - pdf_dict_puts_drop(annot->obj, "DA", pdf_new_string(doc, (char *)da_str, da_len)); + pdf_dict_puts_drop(ctx, annot->obj, "DA", pdf_new_string(ctx, doc, (char *)da_str, da_len)); /* FIXME: should convert to WinAnsiEncoding */ - pdf_dict_puts_drop(annot->obj, "Contents", pdf_new_string(doc, text, strlen(text))); + pdf_dict_puts_drop(ctx, annot->obj, "Contents", pdf_new_string(ctx, doc, text, strlen(text))); - font_desc = pdf_load_font(doc, NULL, font, 0); + font_desc = pdf_load_font(ctx, doc, NULL, font, 0); pdf_measure_text(ctx, font_desc, (unsigned char *)text, strlen(text), &bounds); page_pos = *pos; @@ -464,12 +459,12 @@ void pdf_set_free_text_details(pdf_document *doc, pdf_annot *annot, fz_point *po bounds.y0 += page_pos.y; bounds.y1 += page_pos.y; - pdf_dict_puts_drop(annot->obj, "Rect", pdf_new_rect(doc, &bounds)); + pdf_dict_puts_drop(ctx, annot->obj, "Rect", pdf_new_rect(ctx, doc, &bounds)); update_rect(ctx, annot); } fz_always(ctx) { - pdf_drop_obj(font); + pdf_drop_obj(ctx, font); fz_drop_buffer(ctx, fzbuf); pdf_drop_font(ctx, font_desc); } diff --git a/source/pdf/pdf-annot.c b/source/pdf/pdf-annot.c index 72f5cd8e..b25c24df 100644 --- a/source/pdf/pdf-annot.c +++ b/source/pdf/pdf-annot.c @@ -1,47 +1,47 @@ #include "mupdf/pdf.h" static pdf_obj * -resolve_dest_rec(pdf_document *doc, pdf_obj *dest, fz_link_kind kind, int depth) +resolve_dest_rec(fz_context *ctx, pdf_document *doc, pdf_obj *dest, fz_link_kind kind, int depth) { if (depth > 10) /* Arbitrary to avoid infinite recursion */ return NULL; - if (pdf_is_name(dest) || pdf_is_string(dest)) + if (pdf_is_name(ctx, dest) || pdf_is_string(ctx, dest)) { if (kind == FZ_LINK_GOTO) { - dest = pdf_lookup_dest(doc, dest); - dest = resolve_dest_rec(doc, dest, kind, depth+1); + dest = pdf_lookup_dest(ctx, doc, dest); + dest = resolve_dest_rec(ctx, doc, dest, kind, depth+1); } return dest; } - else if (pdf_is_array(dest)) + else if (pdf_is_array(ctx, dest)) { return dest; } - else if (pdf_is_dict(dest)) + else if (pdf_is_dict(ctx, dest)) { - dest = pdf_dict_gets(dest, "D"); - return resolve_dest_rec(doc, dest, kind, depth+1); + dest = pdf_dict_gets(ctx, dest, "D"); + return resolve_dest_rec(ctx, doc, dest, kind, depth+1); } - else if (pdf_is_indirect(dest)) + else if (pdf_is_indirect(ctx, dest)) return dest; return NULL; } static pdf_obj * -resolve_dest(pdf_document *doc, pdf_obj *dest, fz_link_kind kind) +resolve_dest(fz_context *ctx, pdf_document *doc, pdf_obj *dest, fz_link_kind kind) { - return resolve_dest_rec(doc, dest, kind, 0); + return resolve_dest_rec(ctx, doc, dest, kind, 0); } fz_link_dest -pdf_parse_link_dest(pdf_document *doc, fz_link_kind kind, pdf_obj *dest) +pdf_parse_link_dest(fz_context *ctx, pdf_document *doc, fz_link_kind kind, pdf_obj *dest) { fz_link_dest ld; pdf_obj *obj; @@ -63,65 +63,65 @@ pdf_parse_link_dest(pdf_document *doc, fz_link_kind kind, pdf_obj *dest) ld.ld.gotor.page = -1; ld.ld.gotor.dest = NULL; - dest = resolve_dest(doc, dest, kind); + dest = resolve_dest(ctx, doc, dest, kind); if (dest == NULL) { - fz_warn(doc->ctx, "undefined link destination"); + fz_warn(ctx, "undefined link destination"); return ld; } - if (pdf_is_name(dest)) + if (pdf_is_name(ctx, dest)) { - ld.ld.gotor.dest = pdf_to_name(dest); + ld.ld.gotor.dest = pdf_to_name(ctx, dest); return ld; } - else if (pdf_is_string(dest)) + else if (pdf_is_string(ctx, dest)) { - ld.ld.gotor.dest = pdf_to_str_buf(dest); + ld.ld.gotor.dest = pdf_to_str_buf(ctx, dest); return ld; } - obj = pdf_array_get(dest, 0); - if (pdf_is_int(obj)) - ld.ld.gotor.page = pdf_to_int(obj); + obj = pdf_array_get(ctx, dest, 0); + if (pdf_is_int(ctx, obj)) + ld.ld.gotor.page = pdf_to_int(ctx, obj); else { - fz_try(doc->ctx) + fz_try(ctx) { - ld.ld.gotor.page = pdf_lookup_page_number(doc, obj); + ld.ld.gotor.page = pdf_lookup_page_number(ctx, doc, obj); } - fz_catch(doc->ctx) + fz_catch(ctx) { ld.kind = FZ_LINK_NONE; return ld; } } - obj = pdf_array_get(dest, 1); - if (!pdf_is_name(obj)) + obj = pdf_array_get(ctx, dest, 1); + if (!pdf_is_name(ctx, obj)) return ld; - if (!strcmp("XYZ", pdf_to_name(obj))) + if (!strcmp("XYZ", pdf_to_name(ctx, obj))) { l_from_2 = t_from_3 = z_from_4 = 1; ld.ld.gotor.flags |= fz_link_flag_r_is_zoom; } - else if ((!strcmp("Fit", pdf_to_name(obj))) || (!strcmp("FitB", pdf_to_name(obj)))) + else if ((!strcmp("Fit", pdf_to_name(ctx, obj))) || (!strcmp("FitB", pdf_to_name(ctx, obj)))) { ld.ld.gotor.flags |= fz_link_flag_fit_h; ld.ld.gotor.flags |= fz_link_flag_fit_v; } - else if ((!strcmp("FitH", pdf_to_name(obj))) || (!strcmp("FitBH", pdf_to_name(obj)))) + else if ((!strcmp("FitH", pdf_to_name(ctx, obj))) || (!strcmp("FitBH", pdf_to_name(ctx, obj)))) { t_from_2 = 1; ld.ld.gotor.flags |= fz_link_flag_fit_h; } - else if ((!strcmp("FitV", pdf_to_name(obj))) || (!strcmp("FitBV", pdf_to_name(obj)))) + else if ((!strcmp("FitV", pdf_to_name(ctx, obj))) || (!strcmp("FitBV", pdf_to_name(ctx, obj)))) { l_from_2 = 1; ld.ld.gotor.flags |= fz_link_flag_fit_v; } - else if (!strcmp("FitR", pdf_to_name(obj))) + else if (!strcmp("FitR", pdf_to_name(ctx, obj))) { l_from_2 = b_from_3 = r_from_4 = t_from_5 = 1; ld.ld.gotor.flags |= fz_link_flag_fit_h; @@ -130,77 +130,77 @@ pdf_parse_link_dest(pdf_document *doc, fz_link_kind kind, pdf_obj *dest) if (l_from_2) { - obj = pdf_array_get(dest, 2); - if (pdf_is_int(obj)) + obj = pdf_array_get(ctx, dest, 2); + if (pdf_is_int(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_l_valid; - ld.ld.gotor.lt.x = pdf_to_int(obj); + ld.ld.gotor.lt.x = pdf_to_int(ctx, obj); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_l_valid; - ld.ld.gotor.lt.x = pdf_to_real(obj); + ld.ld.gotor.lt.x = pdf_to_real(ctx, obj); } } if (b_from_3) { - obj = pdf_array_get(dest, 3); - if (pdf_is_int(obj)) + obj = pdf_array_get(ctx, dest, 3); + if (pdf_is_int(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_b_valid; - ld.ld.gotor.rb.y = pdf_to_int(obj); + ld.ld.gotor.rb.y = pdf_to_int(ctx, obj); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_b_valid; - ld.ld.gotor.rb.y = pdf_to_real(obj); + ld.ld.gotor.rb.y = pdf_to_real(ctx, obj); } } if (r_from_4) { - obj = pdf_array_get(dest, 4); - if (pdf_is_int(obj)) + obj = pdf_array_get(ctx, dest, 4); + if (pdf_is_int(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_r_valid; - ld.ld.gotor.rb.x = pdf_to_int(obj); + ld.ld.gotor.rb.x = pdf_to_int(ctx, obj); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_r_valid; - ld.ld.gotor.rb.x = pdf_to_real(obj); + ld.ld.gotor.rb.x = pdf_to_real(ctx, obj); } } if (t_from_5 || t_from_3 || t_from_2) { if (t_from_5) - obj = pdf_array_get(dest, 5); + obj = pdf_array_get(ctx, dest, 5); else if (t_from_3) - obj = pdf_array_get(dest, 3); + obj = pdf_array_get(ctx, dest, 3); else - obj = pdf_array_get(dest, 2); - if (pdf_is_int(obj)) + obj = pdf_array_get(ctx, dest, 2); + if (pdf_is_int(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_t_valid; - ld.ld.gotor.lt.y = pdf_to_int(obj); + ld.ld.gotor.lt.y = pdf_to_int(ctx, obj); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_t_valid; - ld.ld.gotor.lt.y = pdf_to_real(obj); + ld.ld.gotor.lt.y = pdf_to_real(ctx, obj); } } if (z_from_4) { - obj = pdf_array_get(dest, 4); - if (pdf_is_int(obj)) + obj = pdf_array_get(ctx, dest, 4); + if (pdf_is_int(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_r_valid; - ld.ld.gotor.rb.x = pdf_to_int(obj); + ld.ld.gotor.rb.x = pdf_to_int(ctx, obj); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { ld.ld.gotor.flags |= fz_link_flag_r_valid; - ld.ld.gotor.rb.x = pdf_to_real(obj); + ld.ld.gotor.rb.x = pdf_to_real(ctx, obj); } } @@ -218,26 +218,25 @@ pdf_parse_link_dest(pdf_document *doc, fz_link_kind kind, pdf_obj *dest) } static char * -pdf_parse_file_spec(pdf_document *doc, pdf_obj *file_spec) +pdf_parse_file_spec(fz_context *ctx, pdf_document *doc, pdf_obj *file_spec) { - fz_context *ctx = doc->ctx; pdf_obj *filename; - if (pdf_is_string(file_spec)) - return pdf_to_utf8(doc, file_spec); + if (pdf_is_string(ctx, file_spec)) + return pdf_to_utf8(ctx, doc, file_spec); - if (pdf_is_dict(file_spec)) { - filename = pdf_dict_gets(file_spec, "UF"); + if (pdf_is_dict(ctx, file_spec)) { + filename = pdf_dict_gets(ctx, file_spec, "UF"); if (!filename) - filename = pdf_dict_gets(file_spec, "F"); + filename = pdf_dict_gets(ctx, file_spec, "F"); if (!filename) - filename = pdf_dict_gets(file_spec, "Unix"); + filename = pdf_dict_gets(ctx, file_spec, "Unix"); if (!filename) - filename = pdf_dict_gets(file_spec, "Mac"); + filename = pdf_dict_gets(ctx, file_spec, "Mac"); if (!filename) - filename = pdf_dict_gets(file_spec, "DOS"); + filename = pdf_dict_gets(ctx, file_spec, "DOS"); - return pdf_to_utf8(doc, filename); + return pdf_to_utf8(ctx, doc, filename); } fz_warn(ctx, "cannot parse file specification"); @@ -245,65 +244,61 @@ pdf_parse_file_spec(pdf_document *doc, pdf_obj *file_spec) } fz_link_dest -pdf_parse_action(pdf_document *doc, pdf_obj *action) +pdf_parse_action(fz_context *ctx, pdf_document *doc, pdf_obj *action) { fz_link_dest ld; pdf_obj *obj, *dest, *file_spec; - fz_context *ctx = doc->ctx; - - UNUSED(ctx); ld.kind = FZ_LINK_NONE; if (!action) return ld; - obj = pdf_dict_gets(action, "S"); - if (!strcmp(pdf_to_name(obj), "GoTo")) + obj = pdf_dict_gets(ctx, action, "S"); + if (!strcmp(pdf_to_name(ctx, obj), "GoTo")) { - dest = pdf_dict_gets(action, "D"); - ld = pdf_parse_link_dest(doc, FZ_LINK_GOTO, dest); + dest = pdf_dict_gets(ctx, action, "D"); + ld = pdf_parse_link_dest(ctx, doc, FZ_LINK_GOTO, dest); } - else if (!strcmp(pdf_to_name(obj), "URI")) + else if (!strcmp(pdf_to_name(ctx, obj), "URI")) { ld.kind = FZ_LINK_URI; - ld.ld.uri.is_map = pdf_to_bool(pdf_dict_gets(action, "IsMap")); - ld.ld.uri.uri = pdf_to_utf8(doc, pdf_dict_gets(action, "URI")); + ld.ld.uri.is_map = pdf_to_bool(ctx, pdf_dict_gets(ctx, action, "IsMap")); + ld.ld.uri.uri = pdf_to_utf8(ctx, doc, pdf_dict_gets(ctx, action, "URI")); } - else if (!strcmp(pdf_to_name(obj), "Launch")) + else if (!strcmp(pdf_to_name(ctx, obj), "Launch")) { ld.kind = FZ_LINK_LAUNCH; - file_spec = pdf_dict_gets(action, "F"); - ld.ld.launch.file_spec = pdf_parse_file_spec(doc, file_spec); - ld.ld.launch.new_window = pdf_to_int(pdf_dict_gets(action, "NewWindow")); - ld.ld.launch.is_uri = !strcmp(pdf_to_name(pdf_dict_gets(file_spec, "FS")), "URL"); + file_spec = pdf_dict_gets(ctx, action, "F"); + ld.ld.launch.file_spec = pdf_parse_file_spec(ctx, doc, file_spec); + ld.ld.launch.new_window = pdf_to_int(ctx, pdf_dict_gets(ctx, action, "NewWindow")); + ld.ld.launch.is_uri = !strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, file_spec, "FS")), "URL"); } - else if (!strcmp(pdf_to_name(obj), "Named")) + else if (!strcmp(pdf_to_name(ctx, obj), "Named")) { ld.kind = FZ_LINK_NAMED; - ld.ld.named.named = fz_strdup(ctx, pdf_to_name(pdf_dict_gets(action, "N"))); + ld.ld.named.named = fz_strdup(ctx, pdf_to_name(ctx, pdf_dict_gets(ctx, action, "N"))); } - else if (!strcmp(pdf_to_name(obj), "GoToR")) + else if (!strcmp(pdf_to_name(ctx, obj), "GoToR")) { - dest = pdf_dict_gets(action, "D"); - file_spec = pdf_dict_gets(action, "F"); - ld = pdf_parse_link_dest(doc, FZ_LINK_GOTOR, dest); - ld.ld.gotor.file_spec = pdf_parse_file_spec(doc, file_spec); - ld.ld.gotor.new_window = pdf_to_int(pdf_dict_gets(action, "NewWindow")); + dest = pdf_dict_gets(ctx, action, "D"); + file_spec = pdf_dict_gets(ctx, action, "F"); + ld = pdf_parse_link_dest(ctx, doc, FZ_LINK_GOTOR, dest); + ld.ld.gotor.file_spec = pdf_parse_file_spec(ctx, doc, file_spec); + ld.ld.gotor.new_window = pdf_to_int(ctx, pdf_dict_gets(ctx, action, "NewWindow")); } return ld; } static fz_link * -pdf_load_link(pdf_document *doc, pdf_obj *dict, const fz_matrix *page_ctm) +pdf_load_link(fz_context *ctx, pdf_document *doc, pdf_obj *dict, const fz_matrix *page_ctm) { pdf_obj *action; pdf_obj *obj; fz_rect bbox; - fz_context *ctx = doc->ctx; fz_link_dest ld; - obj = pdf_dict_gets(dict, "Rect"); + obj = pdf_dict_gets(ctx, dict, "Rect"); if (obj) pdf_to_rect(ctx, obj, &bbox); else @@ -311,17 +306,17 @@ pdf_load_link(pdf_document *doc, pdf_obj *dict, const fz_matrix *page_ctm) fz_transform_rect(&bbox, page_ctm); - obj = pdf_dict_gets(dict, "Dest"); + obj = pdf_dict_gets(ctx, dict, "Dest"); if (obj) - ld = pdf_parse_link_dest(doc, FZ_LINK_GOTO, obj); + ld = pdf_parse_link_dest(ctx, doc, FZ_LINK_GOTO, obj); else { - action = pdf_dict_gets(dict, "A"); + action = pdf_dict_gets(ctx, dict, "A"); /* fall back to additional action button's down/up action */ if (!action) - action = pdf_dict_getsa(pdf_dict_gets(dict, "AA"), "U", "D"); + action = pdf_dict_getsa(ctx, pdf_dict_gets(ctx, dict, "AA"), "U", "D"); - ld = pdf_parse_action(doc, action); + ld = pdf_parse_action(ctx, doc, action); } if (ld.kind == FZ_LINK_NONE) return NULL; @@ -329,7 +324,7 @@ pdf_load_link(pdf_document *doc, pdf_obj *dict, const fz_matrix *page_ctm) } fz_link * -pdf_load_link_annots(pdf_document *doc, pdf_obj *annots, const fz_matrix *page_ctm) +pdf_load_link_annots(fz_context *ctx, pdf_document *doc, pdf_obj *annots, const fz_matrix *page_ctm) { fz_link *link, *head, *tail; pdf_obj *obj; @@ -338,18 +333,18 @@ pdf_load_link_annots(pdf_document *doc, pdf_obj *annots, const fz_matrix *page_c head = tail = NULL; link = NULL; - n = pdf_array_len(annots); + n = pdf_array_len(ctx, annots); for (i = 0; i < n; i++) { /* FIXME: Move the try/catch out of the loop for performance? */ - fz_try(doc->ctx) + fz_try(ctx) { - obj = pdf_array_get(annots, i); - link = pdf_load_link(doc, obj, page_ctm); + obj = pdf_array_get(ctx, annots, i); + link = pdf_load_link(ctx, doc, obj, page_ctm); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); link = NULL; } @@ -378,14 +373,14 @@ pdf_drop_annot(fz_context *ctx, pdf_annot *annot) next = annot->next; if (annot->ap) pdf_drop_xobject(ctx, annot->ap); - pdf_drop_obj(annot->obj); + pdf_drop_obj(ctx, annot->obj); fz_free(ctx, annot); annot = next; } } void -pdf_transform_annot(pdf_annot *annot) +pdf_transform_annot(fz_context *ctx, pdf_annot *annot) { fz_rect bbox = annot->ap->bbox; fz_rect rect = annot->rect; @@ -406,9 +401,9 @@ pdf_transform_annot(pdf_annot *annot) fz_pre_scale(fz_translate(&annot->matrix, x, y), w, h); } -fz_annot_type pdf_annot_obj_type(pdf_obj *obj) +fz_annot_type pdf_annot_obj_type(fz_context *ctx, pdf_obj *obj) { - char *subtype = pdf_to_name(pdf_dict_gets(obj, "Subtype")); + char *subtype = pdf_to_name(ctx, pdf_dict_gets(ctx, obj, "Subtype")); if (!strcmp(subtype, "Text")) return FZ_ANNOT_TEXT; else if (!strcmp(subtype, "Link")) @@ -464,12 +459,11 @@ fz_annot_type pdf_annot_obj_type(pdf_obj *obj) } void -pdf_load_annots(pdf_document *doc, pdf_page *page, pdf_obj *annots) +pdf_load_annots(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_obj *annots) { pdf_annot *annot, **itr; pdf_obj *obj, *ap, *as, *n, *rect; int i, len, keep_annot; - fz_context *ctx = doc->ctx; fz_var(annot); fz_var(itr); @@ -477,7 +471,7 @@ pdf_load_annots(pdf_document *doc, pdf_page *page, pdf_obj *annots) itr = &page->annots; - len = pdf_array_len(annots); + len = pdf_array_len(ctx, annots); /* Create an initial linked list of pdf_annot structures with only the obj field filled in. We do this because update_appearance has the potential to change @@ -488,9 +482,9 @@ pdf_load_annots(pdf_document *doc, pdf_page *page, pdf_obj *annots) { for (i = 0; i < len; i++) { - obj = pdf_array_get(annots, i); + obj = pdf_array_get(ctx, annots, i); annot = fz_malloc_struct(ctx, pdf_annot); - annot->obj = pdf_keep_obj(obj); + annot->obj = pdf_keep_obj(ctx, obj); annot->page = page; annot->next = NULL; @@ -521,45 +515,45 @@ pdf_load_annots(pdf_document *doc, pdf_page *page, pdf_obj *annots) n = NULL; if (doc->update_appearance) - doc->update_appearance(doc, annot); + doc->update_appearance(ctx, doc, annot); obj = annot->obj; - rect = pdf_dict_gets(obj, "Rect"); - ap = pdf_dict_gets(obj, "AP"); - as = pdf_dict_gets(obj, "AS"); + rect = pdf_dict_gets(ctx, obj, "Rect"); + ap = pdf_dict_gets(ctx, obj, "AP"); + as = pdf_dict_gets(ctx, obj, "AS"); /* We only collect annotations with an appearance * stream into this list, so remove any that don't * (such as links) and continue. */ - keep_annot = pdf_is_dict(ap); + keep_annot = pdf_is_dict(ctx, ap); if (!keep_annot) break; - if (hp->num == pdf_to_num(obj) - && hp->gen == pdf_to_gen(obj) + if (hp->num == pdf_to_num(ctx, obj) + && hp->gen == pdf_to_gen(ctx, obj) && (hp->state & HOTSPOT_POINTER_DOWN)) { - n = pdf_dict_gets(ap, "D"); /* down state */ + n = pdf_dict_gets(ctx, ap, "D"); /* down state */ } if (n == NULL) - n = pdf_dict_gets(ap, "N"); /* normal state */ + n = pdf_dict_gets(ctx, ap, "N"); /* normal state */ /* lookup current state in sub-dictionary */ - if (!pdf_is_stream(doc, pdf_to_num(n), pdf_to_gen(n))) - n = pdf_dict_get(n, as); + if (!pdf_is_stream(ctx, doc, pdf_to_num(ctx, n), pdf_to_gen(ctx, n))) + n = pdf_dict_get(ctx, n, as); pdf_to_rect(ctx, rect, &annot->rect); annot->pagerect = annot->rect; fz_transform_rect(&annot->pagerect, &page->ctm); annot->ap = NULL; - annot->annot_type = pdf_annot_obj_type(obj); - annot->widget_type = annot->annot_type == FZ_ANNOT_WIDGET ? pdf_field_type(doc, obj) : PDF_WIDGET_TYPE_NOT_WIDGET; + annot->annot_type = pdf_annot_obj_type(ctx, obj); + annot->widget_type = annot->annot_type == FZ_ANNOT_WIDGET ? pdf_field_type(ctx, doc, obj) : PDF_WIDGET_TYPE_NOT_WIDGET; - if (pdf_is_stream(doc, pdf_to_num(n), pdf_to_gen(n))) + if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, n), pdf_to_gen(ctx, n))) { - annot->ap = pdf_load_xobject(doc, n); - pdf_transform_annot(annot); + annot->ap = pdf_load_xobject(ctx, doc, n); + pdf_transform_annot(ctx, annot); annot->ap_iteration = annot->ap->iteration; } @@ -593,19 +587,19 @@ pdf_load_annots(pdf_document *doc, pdf_page *page, pdf_obj *annots) } pdf_annot * -pdf_first_annot(pdf_document *doc, pdf_page *page) +pdf_first_annot(fz_context *ctx, pdf_page *page) { return page ? page->annots : NULL; } pdf_annot * -pdf_next_annot(pdf_document *doc, pdf_annot *annot) +pdf_next_annot(fz_context *ctx, pdf_page *page, pdf_annot *annot) { return annot ? annot->next : NULL; } fz_rect * -pdf_bound_annot(pdf_document *doc, pdf_annot *annot, fz_rect *rect) +pdf_bound_annot(fz_context *ctx, pdf_page *page, pdf_annot *annot, fz_rect *rect) { if (rect == NULL) return NULL; @@ -618,7 +612,7 @@ pdf_bound_annot(pdf_document *doc, pdf_annot *annot, fz_rect *rect) } fz_annot_type -pdf_annot_type(pdf_annot *annot) +pdf_annot_type(fz_context *ctx, pdf_annot *annot) { return annot->annot_type; } diff --git a/source/pdf/pdf-appearance.c b/source/pdf/pdf-appearance.c index a8d8d6ef..ce9bdb1f 100644 --- a/source/pdf/pdf-appearance.c +++ b/source/pdf/pdf-appearance.c @@ -93,7 +93,7 @@ void pdf_parse_da(fz_context *ctx, char *da, pdf_da_info *di) fz_var(name); fz_try(ctx) { - for (tok = pdf_lex(str, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str, &lbuf)) + for (tok = pdf_lex(ctx, str, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str, &lbuf)) { switch (tok) { @@ -147,8 +147,8 @@ void pdf_parse_da(fz_context *ctx, char *da, pdf_da_info *di) fz_always(ctx) { fz_free(ctx, name); - fz_drop_stream(str); - pdf_lexbuf_fin(&lbuf); + fz_drop_stream(ctx, str); + pdf_lexbuf_fin(ctx, &lbuf); } fz_catch(ctx) { @@ -156,16 +156,15 @@ void pdf_parse_da(fz_context *ctx, char *da, pdf_da_info *di) } } -static void get_font_info(pdf_document *doc, pdf_obj *dr, char *da, font_info *font_rec) +static void get_font_info(fz_context *ctx, pdf_document *doc, pdf_obj *dr, char *da, font_info *font_rec) { - fz_context *ctx = doc->ctx; pdf_font_desc *font; pdf_parse_da(ctx, da, &font_rec->da_rec); if (font_rec->da_rec.font_name == NULL) fz_throw(ctx, FZ_ERROR_GENERIC, "No font name in default appearance"); - font_rec->font = font = pdf_load_font(doc, dr, pdf_dict_gets(pdf_dict_gets(dr, "Font"), font_rec->da_rec.font_name), 0); + font_rec->font = font = pdf_load_font(ctx, doc, dr, pdf_dict_gets(ctx, pdf_dict_gets(ctx, dr, "Font"), font_rec->da_rec.font_name), 0); font_rec->lineheight = 1.0; if (font && font->ascent != 0.0f && font->descent != 0.0f) font_rec->lineheight = (font->ascent - font->descent) / 1000.0; @@ -178,24 +177,24 @@ static void font_info_fin(fz_context *ctx, font_info *font_rec) pdf_da_info_fin(ctx, &font_rec->da_rec); } -static void get_text_widget_info(pdf_document *doc, pdf_obj *widget, text_widget_info *info) +static void get_text_widget_info(fz_context *ctx, pdf_document *doc, pdf_obj *widget, text_widget_info *info) { - char *da = pdf_to_str_buf(pdf_get_inheritable(doc, widget, "DA")); - int ff = pdf_get_field_flags(doc, widget); - pdf_obj *ml = pdf_get_inheritable(doc, widget, "MaxLen"); + char *da = pdf_to_str_buf(ctx, pdf_get_inheritable(ctx, doc, widget, "DA")); + int ff = pdf_get_field_flags(ctx, doc, widget); + pdf_obj *ml = pdf_get_inheritable(ctx, doc, widget, "MaxLen"); - info->dr = pdf_get_inheritable(doc, widget, "DR"); - info->col = pdf_dict_getp(widget, "MK/BG"); - info->q = pdf_to_int(pdf_get_inheritable(doc, widget, "Q")); + info->dr = pdf_get_inheritable(ctx, doc, widget, "DR"); + info->col = pdf_dict_getp(ctx, widget, "MK/BG"); + info->q = pdf_to_int(ctx, pdf_get_inheritable(ctx, doc, widget, "Q")); info->multiline = (ff & Ff_Multiline) != 0; info->comb = (ff & (Ff_Multiline|Ff_Password|Ff_FileSelect|Ff_Comb)) == Ff_Comb; if (ml == NULL) info->comb = 0; else - info->max_len = pdf_to_int(ml); + info->max_len = pdf_to_int(ctx, ml); - get_font_info(doc, info->dr, da, &info->font_rec); + get_font_info(ctx, doc, info->dr, da, &info->font_rec); } void pdf_fzbuf_print_da(fz_context *ctx, fz_buffer *fzbuf, pdf_da_info *di) @@ -223,9 +222,9 @@ void pdf_fzbuf_print_da(fz_context *ctx, fz_buffer *fzbuf, pdf_da_info *di) } } -static fz_rect *measure_text(pdf_document *doc, font_info *font_rec, const fz_matrix *tm, char *text, fz_rect *bbox) +static fz_rect *measure_text(fz_context *ctx, pdf_document *doc, font_info *font_rec, const fz_matrix *tm, char *text, fz_rect *bbox) { - pdf_measure_text(doc->ctx, font_rec->font, (unsigned char *)text, strlen(text), bbox); + pdf_measure_text(ctx, font_rec->font, (unsigned char *)text, strlen(text), bbox); bbox->x0 *= font_rec->da_rec.font_size * tm->a; bbox->y0 *= font_rec->da_rec.font_size * tm->d; @@ -237,24 +236,24 @@ static fz_rect *measure_text(pdf_document *doc, font_info *font_rec, const fz_ma static void fzbuf_print_color(fz_context *ctx, fz_buffer *fzbuf, pdf_obj *arr, int stroke, float adj) { - switch (pdf_array_len(arr)) + switch (pdf_array_len(ctx, arr)) { case 1: fz_buffer_printf(ctx, fzbuf, stroke?"%f G\n":"%f g\n", - pdf_to_real(pdf_array_get(arr, 0)) + adj); + pdf_to_real(ctx, pdf_array_get(ctx, arr, 0)) + adj); break; case 3: fz_buffer_printf(ctx, fzbuf, stroke?"%f %f %f RG\n":"%f %f %f rg\n", - pdf_to_real(pdf_array_get(arr, 0)) + adj, - pdf_to_real(pdf_array_get(arr, 1)) + adj, - pdf_to_real(pdf_array_get(arr, 2)) + adj); + pdf_to_real(ctx, pdf_array_get(ctx, arr, 0)) + adj, + pdf_to_real(ctx, pdf_array_get(ctx, arr, 1)) + adj, + pdf_to_real(ctx, pdf_array_get(ctx, arr, 2)) + adj); break; case 4: fz_buffer_printf(ctx, fzbuf, stroke?"%f %f %f %f K\n":"%f %f %f %f k\n", - pdf_to_real(pdf_array_get(arr, 0)), - pdf_to_real(pdf_array_get(arr, 1)), - pdf_to_real(pdf_array_get(arr, 2)), - pdf_to_real(pdf_array_get(arr, 3))); + pdf_to_real(ctx, pdf_array_get(ctx, arr, 0)), + pdf_to_real(ctx, pdf_array_get(ctx, arr, 1)), + pdf_to_real(ctx, pdf_array_get(ctx, arr, 2)), + pdf_to_real(ctx, pdf_array_get(ctx, arr, 3))); break; } } @@ -310,25 +309,23 @@ static fz_buffer *create_text_buffer(fz_context *ctx, const fz_rect *clip, text_ return fzbuf; } -static fz_buffer *create_aligned_text_buffer(pdf_document *doc, const fz_rect *clip, text_widget_info *info, const fz_matrix *tm, char *text) +static fz_buffer *create_aligned_text_buffer(fz_context *ctx, pdf_document *doc, const fz_rect *clip, text_widget_info *info, const fz_matrix *tm, char *text) { - fz_context *ctx = doc->ctx; fz_matrix atm = *tm; if (info->q != Q_Left) { fz_rect rect; - measure_text(doc, &info->font_rec, tm, text, &rect); + measure_text(ctx, doc, &info->font_rec, tm, text, &rect); atm.e -= info->q == Q_Right ? rect.x1 : (rect.x1 - rect.x0) / 2; } return create_text_buffer(ctx, clip, info, &atm, text); } -static void measure_ascent_descent(pdf_document *doc, font_info *finf, char *text, float *ascent, float *descent) +static void measure_ascent_descent(fz_context *ctx, pdf_document *doc, font_info *finf, char *text, float *ascent, float *descent) { - fz_context *ctx = doc->ctx; char *testtext = NULL; fz_rect bbox; font_info tinf = *finf; @@ -342,7 +339,7 @@ static void measure_ascent_descent(pdf_document *doc, font_info *finf, char *tex strcpy(testtext, "My"); strcat(testtext, text); tinf.da_rec.font_size = 1; - measure_text(doc, &tinf, &fz_identity, testtext, &bbox); + measure_text(ctx, doc, &tinf, &fz_identity, testtext, &bbox); *descent = -bbox.y0; *ascent = bbox.y1; } @@ -572,9 +569,8 @@ static void fzbuf_print_text_word(fz_context *ctx, fz_buffer *fzbuf, float x, fl fz_buffer_printf(ctx, fzbuf, ") Tj\n"); } -static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, const fz_matrix *oldtm, text_widget_info *info, char *text) +static fz_buffer *create_text_appearance(fz_context *ctx, pdf_document *doc, const fz_rect *bbox, const fz_matrix *oldtm, text_widget_info *info, char *text) { - fz_context *ctx = doc->ctx; int fontsize; int variable; float height, width, full_width; @@ -610,7 +606,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, info->font_rec.da_rec.font_size = fontsize; - measure_ascent_descent(doc, &info->font_rec, text, &ascent, &descent); + measure_ascent_descent(ctx, doc, &info->font_rec, text, &ascent, &descent); if (info->multiline) { @@ -709,7 +705,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, if (variable) { - measure_text(doc, &info->font_rec, &tm, text, &tbox); + measure_text(ctx, doc, &info->font_rec, &tm, text, &tbox); if (tbox.x1 - tbox.x0 > width) { @@ -720,7 +716,7 @@ static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, } } - fzbuf = create_aligned_text_buffer(doc, &rect, info, &tm, text); + fzbuf = create_aligned_text_buffer(ctx, doc, &rect, info, &tm, text); } } fz_always(ctx) @@ -736,14 +732,13 @@ static fz_buffer *create_text_appearance(pdf_document *doc, const fz_rect *bbox, return fzbuf; } -static int get_matrix(pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt) +static int get_matrix(fz_context *ctx, pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt) { - fz_context *ctx = doc->ctx; int found = 0; pdf_lexbuf lbuf; fz_stream *str; - str = pdf_open_stream(doc, pdf_to_num(form->contents), pdf_to_gen(form->contents)); + str = pdf_open_stream(ctx, doc, pdf_to_num(ctx, form->contents), pdf_to_gen(ctx, form->contents)); pdf_lexbuf_init(ctx, &lbuf, PDF_LEXBUF_SMALL); @@ -754,7 +749,7 @@ static int get_matrix(pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt int coef_i = 0; /* Look for the text matrix Tm in the stream */ - for (tok = pdf_lex(str, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str, &lbuf)) + for (tok = pdf_lex(ctx, str, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str, &lbuf)) { if (tok == PDF_TOK_INT || tok == PDF_TOK_REAL) { @@ -789,7 +784,7 @@ static int get_matrix(pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt if (found) { fz_rect bbox; - pdf_to_rect(ctx, pdf_dict_gets(form->contents, "BBox"), &bbox); + pdf_to_rect(ctx, pdf_dict_gets(ctx, form->contents, "BBox"), &bbox); switch (q) { @@ -809,8 +804,8 @@ static int get_matrix(pdf_document *doc, pdf_xobject *form, int q, fz_matrix *mt } fz_always(ctx) { - fz_drop_stream(str); - pdf_lexbuf_fin(&lbuf); + fz_drop_stream(ctx, str); + pdf_lexbuf_fin(ctx, &lbuf); } fz_catch(ctx) { @@ -912,23 +907,22 @@ static void account_for_rot(fz_rect *rect, fz_matrix *mat, int rot) } } -static void copy_resources(pdf_obj *dst, pdf_obj *src) +static void copy_resources(fz_context *ctx, pdf_obj *dst, pdf_obj *src) { int i, len; - len = pdf_dict_len(src); + len = pdf_dict_len(ctx, src); for (i = 0; i < len; i++) { - pdf_obj *key = pdf_dict_get_key(src, i); + pdf_obj *key = pdf_dict_get_key(ctx, src, i); - if (!pdf_dict_get(dst, key)) - pdf_dict_put(dst, key, pdf_dict_get_val(src, i)); + if (!pdf_dict_get(ctx, dst, key)) + pdf_dict_put(ctx, dst, key, pdf_dict_get_val(ctx, src, i)); } } -static pdf_xobject *load_or_create_form(pdf_document *doc, pdf_obj *obj, fz_rect *rect) +static pdf_xobject *load_or_create_form(fz_context *ctx, pdf_document *doc, pdf_obj *obj, fz_rect *rect) { - fz_context *ctx = doc->ctx; pdf_obj *ap = NULL; fz_matrix mat; int rot; @@ -943,36 +937,36 @@ static pdf_xobject *load_or_create_form(pdf_document *doc, pdf_obj *obj, fz_rect fz_var(fzbuf); fz_try(ctx) { - rot = pdf_to_int(pdf_dict_getp(obj, "MK/R")); - pdf_to_rect(ctx, pdf_dict_gets(obj, "Rect"), rect); + rot = pdf_to_int(ctx, pdf_dict_getp(ctx, obj, "MK/R")); + pdf_to_rect(ctx, pdf_dict_gets(ctx, obj, "Rect"), rect); rect->x1 -= rect->x0; rect->y1 -= rect->y0; rect->x0 = rect->y0 = 0; account_for_rot(rect, &mat, rot); - ap = pdf_dict_gets(obj, "AP"); + ap = pdf_dict_gets(ctx, obj, "AP"); if (ap == NULL) { - ap = pdf_new_dict(doc, 1); - pdf_dict_puts_drop(obj, "AP", ap); + ap = pdf_new_dict(ctx, doc, 1); + pdf_dict_puts_drop(ctx, obj, "AP", ap); } - formobj = pdf_dict_gets(ap, dn); + formobj = pdf_dict_gets(ctx, ap, dn); if (formobj == NULL) { - formobj = pdf_new_xobject(doc, rect, &mat); - pdf_dict_puts_drop(ap, dn, formobj); + formobj = pdf_new_xobject(ctx, doc, rect, &mat); + pdf_dict_puts_drop(ctx, ap, dn, formobj); create_form = 1; } - form = pdf_load_xobject(doc, formobj); + form = pdf_load_xobject(ctx, doc, formobj); if (create_form) { fzbuf = fz_new_buffer(ctx, 1); - pdf_update_xobject_contents(doc, form, fzbuf); + pdf_update_xobject_contents(ctx, doc, form, fzbuf); } - copy_resources(form->resources, pdf_get_inheritable(doc, obj, "DR")); + copy_resources(ctx, form->resources, pdf_get_inheritable(ctx, doc, obj, "DR")); } fz_always(ctx) { @@ -987,9 +981,8 @@ static pdf_xobject *load_or_create_form(pdf_document *doc, pdf_obj *obj, fz_rect return form; } -static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffer *fzbuf) +static void update_marked_content(fz_context *ctx, pdf_document *doc, pdf_xobject *form, fz_buffer *fzbuf) { - fz_context *ctx = doc->ctx; pdf_token tok; pdf_lexbuf lbuf; fz_stream *str_outer = NULL; @@ -1009,12 +1002,12 @@ static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffe int first = 1; newbuf = fz_new_buffer(ctx, 0); - str_outer = pdf_open_stream(doc, pdf_to_num(form->contents), pdf_to_gen(form->contents)); + str_outer = pdf_open_stream(ctx, doc, pdf_to_num(ctx, form->contents), pdf_to_gen(ctx, form->contents)); len = fz_buffer_storage(ctx, fzbuf, &buf); str_inner = fz_open_memory(ctx, buf, len); /* Copy the existing appearance stream to newbuf while looking for BMC */ - for (tok = pdf_lex(str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str_outer, &lbuf)) + for (tok = pdf_lex(ctx, str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str_outer, &lbuf)) { if (first) first = 0; @@ -1031,12 +1024,12 @@ static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffe if (bmc_found) { /* Drop Tx BMC from the replacement appearance stream */ - (void)pdf_lex(str_inner, &lbuf); - (void)pdf_lex(str_inner, &lbuf); + (void)pdf_lex(ctx, str_inner, &lbuf); + (void)pdf_lex(ctx, str_inner, &lbuf); } /* Copy the replacement appearance stream to newbuf */ - for (tok = pdf_lex(str_inner, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str_inner, &lbuf)) + for (tok = pdf_lex(ctx, str_inner, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str_inner, &lbuf)) { fz_buffer_printf(ctx, newbuf, " "); pdf_print_token(ctx, newbuf, tok, &lbuf); @@ -1045,14 +1038,14 @@ static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffe if (bmc_found) { /* Drop the rest of the existing appearance stream until EMC found */ - for (tok = pdf_lex(str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str_outer, &lbuf)) + for (tok = pdf_lex(ctx, str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str_outer, &lbuf)) { if (tok == PDF_TOK_KEYWORD && !strcmp(lbuf.scratch, "EMC")) break; } /* Copy the rest of the existing appearance stream to newbuf */ - for (tok = pdf_lex(str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(str_outer, &lbuf)) + for (tok = pdf_lex(ctx, str_outer, &lbuf); tok != PDF_TOK_EOF; tok = pdf_lex(ctx, str_outer, &lbuf)) { fz_buffer_printf(ctx, newbuf, " "); pdf_print_token(ctx, newbuf, tok, &lbuf); @@ -1060,14 +1053,14 @@ static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffe } /* Use newbuf in place of the existing appearance stream */ - pdf_update_xobject_contents(doc, form, newbuf); + pdf_update_xobject_contents(ctx, doc, form, newbuf); } fz_always(ctx) { - fz_drop_stream(str_outer); - fz_drop_stream(str_inner); + fz_drop_stream(ctx, str_outer); + fz_drop_stream(ctx, str_inner); fz_drop_buffer(ctx, newbuf); - pdf_lexbuf_fin(&lbuf); + pdf_lexbuf_fin(ctx, &lbuf); } fz_catch(ctx) { @@ -1075,9 +1068,9 @@ static void update_marked_content(pdf_document *doc, pdf_xobject *form, fz_buffe } } -static int get_border_style(pdf_obj *obj) +static int get_border_style(fz_context *ctx, pdf_obj *obj) { - char *sname = pdf_to_name(pdf_dict_getp(obj, "BS/S")); + char *sname = pdf_to_name(ctx, pdf_dict_getp(ctx, obj, "BS/S")); if (!strcmp(sname, "D")) return BS_Dashed; @@ -1091,15 +1084,14 @@ static int get_border_style(pdf_obj *obj) return BS_Solid; } -static float get_border_width(pdf_obj *obj) +static float get_border_width(fz_context *ctx, pdf_obj *obj) { - float w = pdf_to_real(pdf_dict_getp(obj, "BS/W")); + float w = pdf_to_real(ctx, pdf_dict_getp(ctx, obj, "BS/W")); return w == 0.0 ? 1.0 : w; } -void pdf_update_text_appearance(pdf_document *doc, pdf_obj *obj, char *eventValue) +void pdf_update_text_appearance(fz_context *ctx, pdf_document *doc, pdf_obj *obj, char *eventValue) { - fz_context *ctx = doc->ctx; text_widget_info info; pdf_xobject *form = NULL; fz_buffer *fzbuf = NULL; @@ -1116,19 +1108,19 @@ void pdf_update_text_appearance(pdf_document *doc, pdf_obj *obj, char *eventValu fz_var(text); fz_try(ctx) { - get_text_widget_info(doc, obj, &info); + get_text_widget_info(ctx, doc, obj, &info); if (eventValue) text = to_font_encoding(ctx, info.font_rec.font, eventValue); else - text = pdf_field_value(doc, obj); + text = pdf_field_value(ctx, doc, obj); - form = load_or_create_form(doc, obj, &rect); + form = load_or_create_form(ctx, doc, obj, &rect); - has_tm = get_matrix(doc, form, info.q, &tm); - fzbuf = create_text_appearance(doc, &form->bbox, has_tm ? &tm : NULL, &info, + has_tm = get_matrix(ctx, doc, form, info.q, &tm); + fzbuf = create_text_appearance(ctx, doc, &form->bbox, has_tm ? &tm : NULL, &info, text?text:""); - update_marked_content(doc, form, fzbuf); + update_marked_content(ctx, doc, form, fzbuf); } fz_always(ctx) { @@ -1143,9 +1135,8 @@ void pdf_update_text_appearance(pdf_document *doc, pdf_obj *obj, char *eventValu } } -void pdf_update_combobox_appearance(pdf_document *doc, pdf_obj *obj) +void pdf_update_combobox_appearance(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; text_widget_info info; pdf_xobject *form = NULL; fz_buffer *fzbuf = NULL; @@ -1162,24 +1153,24 @@ void pdf_update_combobox_appearance(pdf_document *doc, pdf_obj *obj) fz_var(fzbuf); fz_try(ctx) { - get_text_widget_info(doc, obj, &info); + get_text_widget_info(ctx, doc, obj, &info); - val = pdf_get_inheritable(doc, obj, "V"); + val = pdf_get_inheritable(ctx, doc, obj, "V"); - if (pdf_is_array(val)) - val = pdf_array_get(val, 0); + if (pdf_is_array(ctx, val)) + val = pdf_array_get(ctx, val, 0); - text = pdf_to_str_buf(val); + text = pdf_to_str_buf(ctx, val); if (!text) text = ""; - form = load_or_create_form(doc, obj, &rect); + form = load_or_create_form(ctx, doc, obj, &rect); - has_tm = get_matrix(doc, form, info.q, &tm); - fzbuf = create_text_appearance(doc, &form->bbox, has_tm ? &tm : NULL, &info, + has_tm = get_matrix(ctx, doc, form, info.q, &tm); + fzbuf = create_text_appearance(ctx, doc, &form->bbox, has_tm ? &tm : NULL, &info, text?text:""); - update_marked_content(doc, form, fzbuf); + update_marked_content(ctx, doc, form, fzbuf); } fz_always(ctx) { @@ -1193,9 +1184,8 @@ void pdf_update_combobox_appearance(pdf_document *doc, pdf_obj *obj) } } -void pdf_update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj) +void pdf_update_pushbutton_appearance(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; fz_rect rect; pdf_xobject *form = NULL; fz_buffer *fzbuf = NULL; @@ -1212,18 +1202,18 @@ void pdf_update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj) fz_var(fzbuf); fz_try(ctx) { - form = load_or_create_form(doc, obj, &rect); + form = load_or_create_form(ctx, doc, obj, &rect); fzbuf = fz_new_buffer(ctx, 0); - tobj = pdf_dict_getp(obj, "MK/BG"); - if (pdf_is_array(tobj)) + tobj = pdf_dict_getp(ctx, obj, "MK/BG"); + if (pdf_is_array(ctx, tobj)) { fzbuf_print_color(ctx, fzbuf, tobj, 0, 0.0); fz_buffer_printf(ctx, fzbuf, fmt_re, rect.x0, rect.y0, rect.x1, rect.y1); fz_buffer_printf(ctx, fzbuf, fmt_f); } - bstyle = get_border_style(obj); - bwidth = get_border_width(obj); + bstyle = get_border_style(ctx, obj); + bwidth = get_border_width(ctx, obj); btotal = bwidth; if (bstyle == BS_Beveled || bstyle == BS_Inset) { @@ -1253,7 +1243,7 @@ void pdf_update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj) fz_buffer_printf(ctx, fzbuf, fmt_f); } - tobj = pdf_dict_getp(obj, "MK/BC"); + tobj = pdf_dict_getp(ctx, obj, "MK/BC"); if (tobj) { fzbuf_print_color(ctx, fzbuf, tobj, 1, 0.0); @@ -1264,27 +1254,27 @@ void pdf_update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj) fz_buffer_printf(ctx, fzbuf, fmt_s); } - tobj = pdf_dict_getp(obj, "MK/CA"); + tobj = pdf_dict_getp(ctx, obj, "MK/CA"); if (tobj) { fz_rect clip = rect; fz_rect bounds; fz_matrix mat; - char *da = pdf_to_str_buf(pdf_get_inheritable(doc, obj, "DA")); - char *text = pdf_to_str_buf(tobj); + char *da = pdf_to_str_buf(ctx, pdf_get_inheritable(ctx, doc, obj, "DA")); + char *text = pdf_to_str_buf(ctx, tobj); clip.x0 += btotal; clip.y0 += btotal; clip.x1 -= btotal; clip.y1 -= btotal; - get_font_info(doc, form->resources, da, &font_rec); - measure_text(doc, &font_rec, &fz_identity, text, &bounds); + get_font_info(ctx, doc, form->resources, da, &font_rec); + measure_text(ctx, doc, &font_rec, &fz_identity, text, &bounds); fz_translate(&mat, (rect.x1 - bounds.x1)/2, (rect.y1 - bounds.y1)/2); fzbuf_print_text(ctx, fzbuf, &clip, NULL, &font_rec, &mat, text); } - pdf_update_xobject_contents(doc, form, fzbuf); + pdf_update_xobject_contents(ctx, doc, form, fzbuf); } fz_always(ctx) { @@ -1298,7 +1288,7 @@ void pdf_update_pushbutton_appearance(pdf_document *doc, pdf_obj *obj) } } -void pdf_update_text_markup_appearance(pdf_document *doc, pdf_annot *annot, fz_annot_type type) +void pdf_update_text_markup_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_annot_type type) { float color[3]; float alpha; @@ -1335,19 +1325,18 @@ void pdf_update_text_markup_appearance(pdf_document *doc, pdf_annot *annot, fz_a return; } - pdf_set_markup_appearance(doc, annot, color, alpha, line_thickness, line_height); + pdf_set_markup_appearance(ctx, doc, annot, color, alpha, line_thickness, line_height); } static void update_rect(fz_context *ctx, pdf_annot *annot) { - pdf_to_rect(ctx, pdf_dict_gets(annot->obj, "Rect"), &annot->rect); + pdf_to_rect(ctx, pdf_dict_gets(ctx, annot->obj, "Rect"), &annot->rect); annot->pagerect = annot->rect; fz_transform_rect(&annot->pagerect, &annot->page->ctm); } -void pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_rect *rect, fz_display_list *disp_list) +void pdf_set_annot_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_rect *rect, fz_display_list *disp_list) { - fz_context *ctx = doc->ctx; pdf_obj *obj = annot->obj; const fz_matrix *page_ctm = &annot->page->ctm; fz_matrix ctm; @@ -1365,32 +1354,32 @@ void pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_rect *rect fz_transform_rect(&trect, &ctm); - pdf_dict_puts_drop(obj, "Rect", pdf_new_rect(doc, &trect)); + pdf_dict_puts_drop(ctx, obj, "Rect", pdf_new_rect(ctx, doc, &trect)); /* See if there is a current normal appearance */ - ap_obj = pdf_dict_getp(obj, "AP/N"); - if (!pdf_is_stream(doc, pdf_to_num(ap_obj), pdf_to_gen(ap_obj))) + ap_obj = pdf_dict_getp(ctx, obj, "AP/N"); + if (!pdf_is_stream(ctx, doc, pdf_to_num(ctx, ap_obj), pdf_to_gen(ctx, ap_obj))) ap_obj = NULL; if (ap_obj == NULL) { - ap_obj = pdf_new_xobject(doc, &trect, &mat); - pdf_dict_putp_drop(obj, "AP/N", ap_obj); + ap_obj = pdf_new_xobject(ctx, doc, &trect, &mat); + pdf_dict_putp_drop(ctx, obj, "AP/N", ap_obj); } else { - pdf_xref_ensure_incremental_object(doc, pdf_to_num(ap_obj)); + pdf_xref_ensure_incremental_object(ctx, doc, pdf_to_num(ctx, ap_obj)); /* Update bounding box and matrix in reused xobject obj */ - pdf_dict_puts_drop(ap_obj, "BBox", pdf_new_rect(doc, &trect)); - pdf_dict_puts_drop(ap_obj, "Matrix", pdf_new_matrix(doc, &mat)); + pdf_dict_puts_drop(ctx, ap_obj, "BBox", pdf_new_rect(ctx, doc, &trect)); + pdf_dict_puts_drop(ctx, ap_obj, "Matrix", pdf_new_matrix(ctx, doc, &mat)); } - dev = pdf_new_pdf_device(doc, ap_obj, pdf_dict_gets(ap_obj, "Resources"), &mat); - fz_run_display_list(disp_list, dev, &ctm, &fz_infinite_rect, NULL); - fz_drop_device(dev); + dev = pdf_new_pdf_device(ctx, doc, ap_obj, pdf_dict_gets(ctx, ap_obj, "Resources"), &mat); + fz_run_display_list(ctx, disp_list, dev, &ctm, &fz_infinite_rect, NULL); + fz_drop_device(ctx, dev); /* Mark the appearance as changed - required for partial update */ - xobj = pdf_load_xobject(doc, ap_obj); + xobj = pdf_load_xobject(ctx, doc, ap_obj); if (xobj) { /* Update bounding box and matrix also in the xobject structure */ @@ -1406,23 +1395,22 @@ void pdf_set_annot_appearance(pdf_document *doc, pdf_annot *annot, fz_rect *rect } fz_catch(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_rethrow(ctx); } } static fz_point * -quadpoints(pdf_document *doc, pdf_obj *annot, int *nout) +quadpoints(fz_context *ctx, pdf_document *doc, pdf_obj *annot, int *nout) { - fz_context *ctx = doc->ctx; - pdf_obj *quad = pdf_dict_gets(annot, "QuadPoints"); + pdf_obj *quad = pdf_dict_gets(ctx, annot, "QuadPoints"); fz_point *qp = NULL; int i, n; if (!quad) return NULL; - n = pdf_array_len(quad); + n = pdf_array_len(ctx, quad); if (n%8 != 0) return NULL; @@ -1434,8 +1422,8 @@ quadpoints(pdf_document *doc, pdf_obj *annot, int *nout) for (i = 0; i < n; i += 2) { - qp[i/2].x = pdf_to_real(pdf_array_get(quad, i)); - qp[i/2].y = pdf_to_real(pdf_array_get(quad, i+1)); + qp[i/2].x = pdf_to_real(ctx, pdf_array_get(ctx, quad, i)); + qp[i/2].y = pdf_to_real(ctx, pdf_array_get(ctx, quad, i+1)); } } fz_catch(ctx) @@ -1449,16 +1437,15 @@ quadpoints(pdf_document *doc, pdf_obj *annot, int *nout) return qp; } -void pdf_set_markup_appearance(pdf_document *doc, pdf_annot *annot, float color[3], float alpha, float line_thickness, float line_height) +void pdf_set_markup_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot, float color[3], float alpha, float line_thickness, float line_height) { - fz_context *ctx = doc->ctx; const fz_matrix *page_ctm = &annot->page->ctm; fz_path *path = NULL; fz_stroke_state *stroke = NULL; fz_device *dev = NULL; fz_display_list *strike_list = NULL; int i, n; - fz_point *qp = quadpoints(doc, annot->obj, &n); + fz_point *qp = quadpoints(ctx, doc, annot->obj, &n); if (!qp || n <= 0) return; @@ -1501,7 +1488,7 @@ void pdf_set_markup_appearance(pdf_document *doc, pdf_annot *annot, float color[ if (stroke) { // assert(path) - fz_stroke_path(dev, path, stroke, page_ctm, fz_device_rgb(ctx), color, alpha); + fz_stroke_path(ctx, dev, path, stroke, page_ctm, fz_device_rgb(ctx), color, alpha); fz_drop_stroke_state(ctx, stroke); stroke = NULL; fz_drop_path(ctx, path); @@ -1519,16 +1506,16 @@ void pdf_set_markup_appearance(pdf_document *doc, pdf_annot *annot, float color[ if (stroke) { - fz_stroke_path(dev, path, stroke, page_ctm, fz_device_rgb(ctx), color, alpha); + fz_stroke_path(ctx, dev, path, stroke, page_ctm, fz_device_rgb(ctx), color, alpha); } fz_transform_rect(&rect, page_ctm); - pdf_set_annot_appearance(doc, annot, &rect, strike_list); + pdf_set_annot_appearance(ctx, doc, annot, &rect, strike_list); } fz_always(ctx) { fz_free(ctx, qp); - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_drop_stroke_state(ctx, stroke); fz_drop_path(ctx, path); fz_drop_display_list(ctx, strike_list); @@ -1539,28 +1526,27 @@ void pdf_set_markup_appearance(pdf_document *doc, pdf_annot *annot, float color[ } } -static fz_colorspace *pdf_to_color(pdf_document *doc, pdf_obj *col, float color[4]) +static fz_colorspace *pdf_to_color(fz_context *ctx, pdf_document *doc, pdf_obj *col, float color[4]) { fz_colorspace *cs; - int i, ncol = pdf_array_len(col); + int i, ncol = pdf_array_len(ctx, col); switch (ncol) { - case 1: cs = fz_device_gray(doc->ctx); break; - case 3: cs = fz_device_rgb(doc->ctx); break; - case 4: cs = fz_device_cmyk(doc->ctx); break; + case 1: cs = fz_device_gray(ctx); break; + case 3: cs = fz_device_rgb(ctx); break; + case 4: cs = fz_device_cmyk(ctx); break; default: return NULL; } for (i = 0; i < ncol; i++) - color[i] = pdf_to_real(pdf_array_get(col, i)); + color[i] = pdf_to_real(ctx, pdf_array_get(ctx, col, i)); return cs; } -void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) +void pdf_update_ink_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { - fz_context *ctx = doc->ctx; const fz_matrix *page_ctm = &annot->page->ctm; fz_path *path = NULL; fz_stroke_state *stroke = NULL; @@ -1582,7 +1568,7 @@ void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) int n, m, i, j; int empty = 1; - cs = pdf_to_color(doc, pdf_dict_gets(annot->obj, "C"), color); + cs = pdf_to_color(ctx, doc, pdf_dict_gets(ctx, annot->obj, "C"), color); if (!cs) { cs = fz_device_rgb(ctx); @@ -1591,13 +1577,13 @@ void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) color[2] = 0.0f; } - width = pdf_to_real(pdf_dict_gets(pdf_dict_gets(annot->obj, "BS"), "W")); + width = pdf_to_real(ctx, pdf_dict_gets(ctx, pdf_dict_gets(ctx, annot->obj, "BS"), "W")); if (width == 0.0f) width = 1.0f; - list = pdf_dict_gets(annot->obj, "InkList"); + list = pdf_dict_gets(ctx, annot->obj, "InkList"); - n = pdf_array_len(list); + n = pdf_array_len(ctx, list); strike_list = fz_new_display_list(ctx); dev = fz_new_list_device(ctx, strike_list); @@ -1610,14 +1596,14 @@ void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) for (i = 0; i < n; i ++) { fz_point pt_last; - pdf_obj *arc = pdf_array_get(list, i); - m = pdf_array_len(arc); + pdf_obj *arc = pdf_array_get(ctx, list, i); + m = pdf_array_len(ctx, arc); for (j = 0; j < m-1; j += 2) { fz_point pt; - pt.x = pdf_to_real(pdf_array_get(arc, j)); - pt.y = pdf_to_real(pdf_array_get(arc, j+1)); + pt.x = pdf_to_real(ctx, pdf_array_get(ctx, arc, j)); + pt.y = pdf_to_real(ctx, pdf_array_get(ctx, arc, j+1)); if (i == 0 && j == 0) { @@ -1639,7 +1625,7 @@ void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) fz_lineto(ctx, path, pt_last.x, pt_last.y); } - fz_stroke_path(dev, path, stroke, page_ctm, cs, color, 1.0f); + fz_stroke_path(ctx, dev, path, stroke, page_ctm, cs, color, 1.0f); fz_expand_rect(&rect, width); /* @@ -1657,12 +1643,12 @@ void pdf_update_ink_appearance(pdf_document *doc, pdf_annot *annot) fz_transform_rect(&rect, page_ctm); - pdf_set_annot_appearance(doc, annot, &rect, strike_list); + pdf_set_annot_appearance(ctx, doc, annot, &rect, strike_list); } fz_always(ctx) { fz_drop_colorspace(ctx, cs); - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_drop_stroke_state(ctx, stroke); fz_drop_path(ctx, path); fz_drop_display_list(ctx, strike_list); @@ -1847,12 +1833,12 @@ static void draw_speech_bubble(fz_context *ctx, fz_path *path) fz_closepath(ctx, path); } -void pdf_update_text_annot_appearance(pdf_document *doc, pdf_annot *annot) +void pdf_update_text_annot_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { static float white[3] = {1.0, 1.0, 1.0}; static float yellow[3] = {1.0, 1.0, 0.0}; static float black[3] = {0.0, 0.0, 0.0}; - fz_context *ctx = doc->ctx; + const fz_matrix *page_ctm = &annot->page->ctm; fz_display_list *dlist = NULL; fz_device *dev = NULL; @@ -1871,7 +1857,7 @@ void pdf_update_text_annot_appearance(pdf_document *doc, pdf_annot *annot) fz_rect bounds; fz_matrix tm; - pdf_to_rect(ctx, pdf_dict_gets(annot->obj, "Rect"), &rect); + pdf_to_rect(ctx, pdf_dict_gets(ctx, annot->obj, "Rect"), &rect); dlist = fz_new_display_list(ctx); dev = fz_new_list_device(ctx, dlist); stroke = fz_new_stroke_state(ctx); @@ -1885,18 +1871,18 @@ void pdf_update_text_annot_appearance(pdf_document *doc, pdf_annot *annot) center_rect_within_rect(&bounds, &rect, &tm); fz_concat(&tm, &tm, page_ctm); cs = fz_device_rgb(ctx); - fz_fill_path(dev, path, 0, &tm, cs, yellow, 1.0f); - fz_stroke_path(dev, path, stroke, &tm, cs, black, 1.0f); + fz_fill_path(ctx, dev, path, 0, &tm, cs, yellow, 1.0f); + fz_stroke_path(ctx, dev, path, stroke, &tm, cs, black, 1.0f); fz_drop_path(ctx, path); path = NULL; path = fz_new_path(ctx); draw_speech_bubble(ctx, path); - fz_fill_path(dev, path, 0, &tm, cs, white, 1.0f); - fz_stroke_path(dev, path, stroke, &tm, cs, black, 1.0f); + fz_fill_path(ctx, dev, path, 0, &tm, cs, white, 1.0f); + fz_stroke_path(ctx, dev, path, stroke, &tm, cs, black, 1.0f); fz_transform_rect(&rect, page_ctm); - pdf_set_annot_appearance(doc, annot, &rect, dlist); + pdf_set_annot_appearance(ctx, doc, annot, &rect, dlist); /* Drop the cached xobject from the annotation structure to * force a redraw on next pdf_update_page call */ @@ -1905,7 +1891,7 @@ void pdf_update_text_annot_appearance(pdf_document *doc, pdf_annot *annot) } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_drop_display_list(ctx, dlist); fz_drop_stroke_state(ctx, stroke); fz_drop_path(ctx, path); @@ -1917,12 +1903,11 @@ void pdf_update_text_annot_appearance(pdf_document *doc, pdf_annot *annot) } } -void pdf_update_free_text_annot_appearance(pdf_document *doc, pdf_annot *annot) +void pdf_update_free_text_annot_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { - fz_context *ctx = doc->ctx; const fz_matrix *page_ctm = &annot->page->ctm; pdf_obj *obj = annot->obj; - pdf_obj *dr = pdf_dict_getp(annot->page->me, "Resources"); + pdf_obj *dr = pdf_dict_getp(ctx, annot->page->me, "Resources"); fz_display_list *dlist = NULL; fz_device *dev = NULL; font_info font_rec; @@ -1941,18 +1926,18 @@ void pdf_update_free_text_annot_appearance(pdf_document *doc, pdf_annot *annot) fz_var(cs); fz_try(ctx) { - char *contents = pdf_to_str_buf(pdf_dict_gets(obj, "Contents")); - char *da = pdf_to_str_buf(pdf_dict_gets(obj, "DA")); + char *contents = pdf_to_str_buf(ctx, pdf_dict_gets(ctx, obj, "Contents")); + char *da = pdf_to_str_buf(ctx, pdf_dict_gets(ctx, obj, "DA")); fz_rect rect = annot->rect; fz_point pos; - get_font_info(doc, dr, da, &font_rec); + get_font_info(ctx, doc, dr, da, &font_rec); switch (font_rec.da_rec.col_size) { - default: cs = fz_device_gray(doc->ctx); break; - case 3: cs = fz_device_rgb(doc->ctx); break; - case 4: cs = fz_device_cmyk(doc->ctx); break; + default: cs = fz_device_gray(ctx); break; + case 3: cs = fz_device_rgb(ctx); break; + case 4: cs = fz_device_cmyk(ctx); break; } /* Adjust for the descender */ @@ -1963,14 +1948,14 @@ void pdf_update_free_text_annot_appearance(pdf_document *doc, pdf_annot *annot) dlist = fz_new_display_list(ctx); dev = fz_new_list_device(ctx, dlist); - fz_fill_text(dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); + fz_fill_text(ctx, dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); fz_transform_rect(&rect, page_ctm); - pdf_set_annot_appearance(doc, annot, &rect, dlist); + pdf_set_annot_appearance(ctx, doc, annot, &rect, dlist); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_drop_display_list(ctx, dlist); font_info_fin(ctx, &font_rec); fz_drop_text(ctx, text); @@ -2042,17 +2027,16 @@ static void draw_logo(fz_context *ctx, fz_path *path) fz_closepath(ctx, path); }; -static void insert_signature_appearance_layers(pdf_document *doc, pdf_annot *annot) +static void insert_signature_appearance_layers(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { - fz_context *ctx = doc->ctx; - pdf_obj *ap = pdf_dict_getp(annot->obj, "AP/N"); + pdf_obj *ap = pdf_dict_getp(ctx, annot->obj, "AP/N"); pdf_obj *main_ap = NULL; pdf_obj *frm = NULL; pdf_obj *n0 = NULL; fz_rect bbox; fz_buffer *fzbuf = NULL; - pdf_to_rect(ctx, pdf_dict_gets(ap, "BBox"), &bbox); + pdf_to_rect(ctx, pdf_dict_gets(ctx, ap, "BBox"), &bbox); fz_var(main_ap); fz_var(frm); @@ -2060,41 +2044,41 @@ static void insert_signature_appearance_layers(pdf_document *doc, pdf_annot *ann fz_var(fzbuf); fz_try(ctx) { - main_ap = pdf_new_xobject(doc, &bbox, &fz_identity); - frm = pdf_new_xobject(doc, &bbox, &fz_identity); - n0 = pdf_new_xobject(doc, &bbox, &fz_identity); + main_ap = pdf_new_xobject(ctx, doc, &bbox, &fz_identity); + frm = pdf_new_xobject(ctx, doc, &bbox, &fz_identity); + n0 = pdf_new_xobject(ctx, doc, &bbox, &fz_identity); - pdf_dict_putp(main_ap, "Resources/XObject/FRM", frm); + pdf_dict_putp(ctx, main_ap, "Resources/XObject/FRM", frm); fzbuf = fz_new_buffer(ctx, 8); fz_buffer_printf(ctx, fzbuf, "/FRM Do"); - pdf_update_stream(doc, pdf_to_num(main_ap), fzbuf); - pdf_dict_puts_drop(main_ap, "Length", pdf_new_int(doc, fzbuf->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, main_ap), fzbuf); + pdf_dict_puts_drop(ctx, main_ap, "Length", pdf_new_int(ctx, doc, fzbuf->len)); fz_drop_buffer(ctx, fzbuf); fzbuf = NULL; - pdf_dict_putp(frm, "Resources/XObject/n0", n0); - pdf_dict_putp(frm, "Resources/XObject/n2", ap); + pdf_dict_putp(ctx, frm, "Resources/XObject/n0", n0); + pdf_dict_putp(ctx, frm, "Resources/XObject/n2", ap); fzbuf = fz_new_buffer(ctx, 8); fz_buffer_printf(ctx, fzbuf, "q 1 0 0 1 0 0 cm /n0 Do Q q 1 0 0 1 0 0 cm /n2 Do Q"); - pdf_update_stream(doc, pdf_to_num(frm), fzbuf); - pdf_dict_puts_drop(frm, "Length", pdf_new_int(doc, fzbuf->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, frm), fzbuf); + pdf_dict_puts_drop(ctx, frm, "Length", pdf_new_int(ctx, doc, fzbuf->len)); fz_drop_buffer(ctx, fzbuf); fzbuf = NULL; fzbuf = fz_new_buffer(ctx, 8); fz_buffer_printf(ctx, fzbuf, "%% DSBlank"); - pdf_update_stream(doc, pdf_to_num(n0), fzbuf); - pdf_dict_puts_drop(n0, "Length", pdf_new_int(doc, fzbuf->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, n0), fzbuf); + pdf_dict_puts_drop(ctx, n0, "Length", pdf_new_int(ctx, doc, fzbuf->len)); fz_drop_buffer(ctx, fzbuf); fzbuf = NULL; - pdf_dict_putp(annot->obj, "AP/N", main_ap); + pdf_dict_putp(ctx, annot->obj, "AP/N", main_ap); } fz_always(ctx) { - pdf_drop_obj(main_ap); - pdf_drop_obj(frm); - pdf_drop_obj(n0); + pdf_drop_obj(ctx, main_ap); + pdf_drop_obj(ctx, frm); + pdf_drop_obj(ctx, n0); } fz_catch(ctx) { @@ -2106,12 +2090,11 @@ static void insert_signature_appearance_layers(pdf_document *doc, pdf_annot *ann /* MuPDF blue */ static float logo_color[3] = {(float)0x25/(float)0xFF, (float)0x72/(float)0xFF, (float)0xAC/(float)0xFF}; -void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *name, char *dn, char *date) +void pdf_set_signature_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot, char *name, char *dn, char *date) { - fz_context *ctx = doc->ctx; const fz_matrix *page_ctm = &annot->page->ctm; pdf_obj *obj = annot->obj; - pdf_obj *dr = pdf_dict_getp(pdf_trailer(doc), "Root/AcroForm/DR"); + pdf_obj *dr = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/DR"); fz_display_list *dlist = NULL; fz_device *dev = NULL; font_info font_rec; @@ -2121,7 +2104,7 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam fz_buffer *fzbuf = NULL; if (!dr) - pdf_dict_putp_drop(pdf_trailer(doc), "Root/AcroForm/DR", pdf_new_dict(doc, 1)); + pdf_dict_putp_drop(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/DR", pdf_new_dict(ctx, doc, 1)); memset(&font_rec, 0, sizeof(font_rec)); @@ -2133,7 +2116,7 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam fz_var(fzbuf); fz_try(ctx) { - char *da = pdf_to_str_buf(pdf_dict_gets(obj, "DA")); + char *da = pdf_to_str_buf(ctx, pdf_dict_gets(ctx, obj, "DA")); fz_rect rect = annot->rect; fz_rect logo_bounds; fz_matrix logo_tm; @@ -2148,11 +2131,11 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam center_rect_within_rect(&logo_bounds, &rect, &logo_tm); fz_concat(&logo_tm, &logo_tm, page_ctm); cs = fz_device_rgb(ctx); - fz_fill_path(dev, path, 0, &logo_tm, cs, logo_color, 1.0f); + fz_fill_path(ctx, dev, path, 0, &logo_tm, cs, logo_color, 1.0f); fz_drop_colorspace(ctx, cs); cs = NULL; - get_font_info(doc, dr, da, &font_rec); + get_font_info(ctx, doc, dr, da, &font_rec); switch (font_rec.da_rec.col_size) { @@ -2164,7 +2147,7 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam /* Display the name in the left-hand half of the form field */ rect.x1 = (rect.x0 + rect.x1)/2.0f; text = fit_text(ctx, &font_rec, name, &rect); - fz_fill_text(dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); + fz_fill_text(ctx, dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); fz_drop_text(ctx, text); text = NULL; @@ -2178,22 +2161,22 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam rect = annot->rect; rect.x0 = (rect.x0 + rect.x1)/2.0f; text = fit_text(ctx, &font_rec, (char *)bufstr, &rect); - fz_fill_text(dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); + fz_fill_text(ctx, dev, text, page_ctm, cs, font_rec.da_rec.col, 1.0f); rect = annot->rect; fz_transform_rect(&rect, page_ctm); - pdf_set_annot_appearance(doc, annot, &rect, dlist); + pdf_set_annot_appearance(ctx, doc, annot, &rect, dlist); /* Drop the cached xobject from the annotation structure to * force a redraw on next pdf_update_page call */ pdf_drop_xobject(ctx, annot->ap); annot->ap = NULL; - insert_signature_appearance_layers(doc, annot); + insert_signature_appearance_layers(ctx, doc, annot); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); fz_drop_display_list(ctx, dlist); font_info_fin(ctx, &font_rec); fz_drop_path(ctx, path); @@ -2207,29 +2190,27 @@ void pdf_set_signature_appearance(pdf_document *doc, pdf_annot *annot, char *nam } } -void pdf_update_appearance(pdf_document *doc, pdf_annot *annot) +void pdf_update_appearance(fz_context *ctx, pdf_document *doc, pdf_annot *annot) { pdf_obj *obj = annot->obj; - if (!pdf_dict_gets(obj, "AP") || pdf_obj_is_dirty(obj)) + if (!pdf_dict_gets(ctx, obj, "AP") || pdf_obj_is_dirty(ctx, obj)) { - fz_annot_type type = pdf_annot_obj_type(obj); + fz_annot_type type = pdf_annot_obj_type(ctx, obj); switch (type) { case FZ_ANNOT_WIDGET: - switch (pdf_field_type(doc, obj)) + switch (pdf_field_type(ctx, doc, obj)) { case PDF_WIDGET_TYPE_TEXT: { #if 0 - pdf_obj *formatting = pdf_dict_getp(obj, "AA/F"); + pdf_obj *formatting = pdf_dict_getp(ctx, obj, "AA/F"); if (formatting && doc->js) { /* Apply formatting */ pdf_js_event e; - fz_context *ctx = doc->ctx; - e.target = obj; - e.value = pdf_field_value(doc, obj); + e.value = pdf_field_value(ctx, doc, obj); fz_try(ctx) { pdf_js_setup_event(doc->js, &e); @@ -2242,47 +2223,47 @@ void pdf_update_appearance(pdf_document *doc, pdf_annot *annot) { fz_rethrow(ctx); } - execute_action(doc, obj, formatting); + execute_action(ctx, doc, obj, formatting); /* Update appearance from JS event.value */ - pdf_update_text_appearance(doc, obj, pdf_js_get_event(doc->js)->value); + pdf_update_text_appearance(ctx, doc, obj, pdf_js_get_event(doc->js)->value); } else #endif { /* Update appearance from field value */ - pdf_update_text_appearance(doc, obj, NULL); + pdf_update_text_appearance(ctx, doc, obj, NULL); } } break; case PDF_WIDGET_TYPE_PUSHBUTTON: - pdf_update_pushbutton_appearance(doc, obj); + pdf_update_pushbutton_appearance(ctx, doc, obj); break; case PDF_WIDGET_TYPE_LISTBOX: case PDF_WIDGET_TYPE_COMBOBOX: /* Treating listbox and combobox identically for now, * and the behaviour is most appropriate for a combobox */ - pdf_update_combobox_appearance(doc, obj); + pdf_update_combobox_appearance(ctx, doc, obj); break; } break; case FZ_ANNOT_TEXT: - pdf_update_text_annot_appearance(doc, annot); + pdf_update_text_annot_appearance(ctx, doc, annot); break; case FZ_ANNOT_FREETEXT: - pdf_update_free_text_annot_appearance(doc, annot); + pdf_update_free_text_annot_appearance(ctx, doc, annot); break; case FZ_ANNOT_STRIKEOUT: case FZ_ANNOT_UNDERLINE: case FZ_ANNOT_HIGHLIGHT: - pdf_update_text_markup_appearance(doc, annot, type); + pdf_update_text_markup_appearance(ctx, doc, annot, type); break; case FZ_ANNOT_INK: - pdf_update_ink_appearance(doc, annot); + pdf_update_ink_appearance(ctx, doc, annot); break; default: break; } - pdf_clean_obj(obj); + pdf_clean_obj(ctx, obj); } } diff --git a/source/pdf/pdf-clean.c b/source/pdf/pdf-clean.c index 51a8b6de..89926832 100644 --- a/source/pdf/pdf-clean.c +++ b/source/pdf/pdf-clean.c @@ -1,9 +1,8 @@ #include "pdf-interpret-imp.h" static void -pdf_clean_stream_object(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int own_res) +pdf_clean_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int own_res) { - fz_context *ctx = doc->ctx; pdf_process process, process2; fz_buffer *buffer; int num; @@ -22,33 +21,33 @@ pdf_clean_stream_object(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_c { if (own_res) { - pdf_obj *r = pdf_dict_gets(obj, "Resources"); + pdf_obj *r = pdf_dict_gets(ctx, obj, "Resources"); if (r) orig_res = r; } - res = pdf_new_dict(doc, 1); + res = pdf_new_dict(ctx, doc, 1); - pdf_process_buffer(&process2, ctx, buffer); - pdf_process_filter(&process, ctx, &process2, res); + pdf_init_process_buffer(ctx, &process2, buffer); + pdf_init_process_filter(ctx, &process, &process2, res); - pdf_process_stream_object(doc, obj, &process, orig_res, cookie); + pdf_process_stream_object(ctx, doc, obj, &process, orig_res, cookie); - num = pdf_to_num(obj); - pdf_dict_dels(obj, "Filter"); - pdf_update_stream(doc, num, buffer); + num = pdf_to_num(ctx, obj); + pdf_dict_dels(ctx, obj, "Filter"); + pdf_update_stream(ctx, doc, num, buffer); if (own_res) { - ref = pdf_new_ref(doc, res); - pdf_dict_puts(obj, "Resources", ref); + ref = pdf_new_ref(ctx, doc, res); + pdf_dict_puts(ctx, obj, "Resources", ref); } } fz_always(ctx) { fz_drop_buffer(ctx, buffer); - pdf_drop_obj(res); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, res); + pdf_drop_obj(ctx, ref); } fz_catch(ctx) { @@ -57,9 +56,8 @@ pdf_clean_stream_object(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_c } static void -pdf_clean_type3(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie) +pdf_clean_type3(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; pdf_process process, process2; fz_buffer *buffer; int num, i, l; @@ -72,46 +70,46 @@ pdf_clean_type3(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *c fz_try(ctx) { - res = pdf_dict_gets(obj, "Resources"); + res = pdf_dict_gets(ctx, obj, "Resources"); if (res) orig_res = res; res = NULL; - res = pdf_new_dict(doc, 1); + res = pdf_new_dict(ctx, doc, 1); - charprocs = pdf_dict_gets(obj, "CharProcs"); - l = pdf_dict_len(charprocs); + charprocs = pdf_dict_gets(ctx, obj, "CharProcs"); + l = pdf_dict_len(ctx, charprocs); for (i = 0; i < l; i++) { - pdf_obj *key = pdf_dict_get_key(charprocs, i); - pdf_obj *val = pdf_dict_get_val(charprocs, i); + pdf_obj *key = pdf_dict_get_key(ctx, charprocs, i); + pdf_obj *val = pdf_dict_get_val(ctx, charprocs, i); buffer = fz_new_buffer(ctx, 1024); - pdf_process_buffer(&process2, ctx, buffer); - pdf_process_filter(&process, ctx, &process2, res); + pdf_init_process_buffer(ctx, &process2, buffer); + pdf_init_process_filter(ctx, &process, &process2, res); - pdf_process_stream_object(doc, val, &process, orig_res, cookie); + pdf_process_stream_object(ctx, doc, val, &process, orig_res, cookie); - num = pdf_to_num(val); - pdf_dict_dels(val, "Filter"); - pdf_update_stream(doc, num, buffer); - pdf_dict_put(charprocs, key, val); + num = pdf_to_num(ctx, val); + pdf_dict_dels(ctx, val, "Filter"); + pdf_update_stream(ctx, doc, num, buffer); + pdf_dict_put(ctx, charprocs, key, val); fz_drop_buffer(ctx, buffer); buffer = NULL; } /* ProcSet - no cleaning possible. Inherit this from the old dict. */ - pdf_dict_puts(res, "ProcSet", pdf_dict_gets(orig_res, "ProcSet")); + pdf_dict_puts(ctx, res, "ProcSet", pdf_dict_gets(ctx, orig_res, "ProcSet")); - ref = pdf_new_ref(doc, res); - pdf_dict_puts(obj, "Resources", ref); + ref = pdf_new_ref(ctx, doc, res); + pdf_dict_puts(ctx, obj, "Resources", ref); } fz_always(ctx) { fz_drop_buffer(ctx, buffer); - pdf_drop_obj(res); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, res); + pdf_drop_obj(ctx, ref); } fz_catch(ctx) { @@ -119,9 +117,8 @@ pdf_clean_type3(pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *c } } -void pdf_clean_page_contents(pdf_document *doc, pdf_page *page, fz_cookie *cookie) +void pdf_clean_page_contents(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; pdf_process process, process2; fz_buffer *buffer = fz_new_buffer(ctx, 1024); int num; @@ -139,37 +136,37 @@ void pdf_clean_page_contents(pdf_document *doc, pdf_page *page, fz_cookie *cooki fz_try(ctx) { - res = pdf_new_dict(doc, 1); + res = pdf_new_dict(ctx, doc, 1); - pdf_process_buffer(&process2, ctx, buffer); - pdf_process_filter(&process, ctx, &process2, res); + pdf_init_process_buffer(ctx, &process2, buffer); + pdf_init_process_filter(ctx, &process, &process2, res); - pdf_process_stream_object(doc, page->contents, &process, page->resources, cookie); + pdf_process_stream_object(ctx, doc, page->contents, &process, page->resources, cookie); contents = page->contents; - if (pdf_is_array(contents)) + if (pdf_is_array(ctx, contents)) { - int n = pdf_array_len(contents); + int n = pdf_array_len(ctx, contents); int i; for (i = n-1; i > 0; i--) - pdf_array_delete(contents, i); + pdf_array_delete(ctx, contents, i); /* We cannot rewrite the 0th entry of contents * directly as it may occur in other pages content * dictionaries too. We therefore clone it and make * a new object reference. */ - new_obj = pdf_copy_dict(pdf_array_get(contents, 0)); - new_ref = pdf_new_ref(doc, new_obj); - num = pdf_to_num(new_ref); - pdf_array_put(contents, 0, new_ref); - pdf_dict_dels(new_obj, "Filter"); + new_obj = pdf_copy_dict(ctx, pdf_array_get(ctx, contents, 0)); + new_ref = pdf_new_ref(ctx, doc, new_obj); + num = pdf_to_num(ctx, new_ref); + pdf_array_put(ctx, contents, 0, new_ref); + pdf_dict_dels(ctx, new_obj, "Filter"); } else { - num = pdf_to_num(contents); - pdf_dict_dels(contents, "Filter"); + num = pdf_to_num(ctx, contents); + pdf_dict_dels(ctx, contents, "Filter"); } - pdf_update_stream(doc, num, buffer); + pdf_update_stream(ctx, doc, num, buffer); /* Now deal with resources. The spec allows for Type3 fonts and form * XObjects to omit a resource dictionary and look in the parent. @@ -177,104 +174,104 @@ void pdf_clean_page_contents(pdf_document *doc, pdf_page *page, fz_cookie *cooki * conceivably cause changes in rendering, but we don't care. */ /* ExtGState */ - obj = pdf_dict_gets(res, "ExtGState"); + obj = pdf_dict_gets(ctx, res, "ExtGState"); if (obj) { int i, l; - l = pdf_dict_len(obj); + l = pdf_dict_len(ctx, obj); for (i = 0; i < l; i++) { - pdf_obj *o = pdf_dict_gets(pdf_dict_get_val(obj, i), "SMask"); + pdf_obj *o = pdf_dict_gets(ctx, pdf_dict_get_val(ctx, obj, i), "SMask"); if (!o) continue; - o = pdf_dict_gets(o, "G"); + o = pdf_dict_gets(ctx, o, "G"); if (!o) continue; /* Transparency group XObject */ - pdf_clean_stream_object(doc, o, page->resources, cookie, 1); + pdf_clean_stream_object(ctx, doc, o, page->resources, cookie, 1); } } /* ColorSpace - no cleaning possible */ /* Pattern */ - obj = pdf_dict_gets(res, "Pattern"); + obj = pdf_dict_gets(ctx, res, "Pattern"); if (obj) { int i, l; - l = pdf_dict_len(obj); + l = pdf_dict_len(ctx, obj); for (i = 0; i < l; i++) { - pdf_obj *pat = pdf_dict_get_val(obj, i); + pdf_obj *pat = pdf_dict_get_val(ctx, obj, i); if (!pat) continue; - if (pdf_to_int(pdf_dict_gets(pat, "PatternType")) == 1) - pdf_clean_stream_object(doc, pat, page->resources, cookie, 0); + if (pdf_to_int(ctx, pdf_dict_gets(ctx, pat, "PatternType")) == 1) + pdf_clean_stream_object(ctx, doc, pat, page->resources, cookie, 0); } } /* Shading - no cleaning possible */ /* XObject */ - obj = pdf_dict_gets(res, "XObject"); + obj = pdf_dict_gets(ctx, res, "XObject"); if (obj) { int i, l; - l = pdf_dict_len(obj); + l = pdf_dict_len(ctx, obj); for (i = 0; i < l; i++) { - pdf_obj *xobj = pdf_dict_get_val(obj, i); + pdf_obj *xobj = pdf_dict_get_val(ctx, obj, i); - if (strcmp(pdf_to_name(pdf_dict_gets(xobj, "Subtype")), "Form")) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, xobj, "Subtype")), "Form")) continue; - pdf_clean_stream_object(doc, xobj, page->resources, cookie, 1); + pdf_clean_stream_object(ctx, doc, xobj, page->resources, cookie, 1); } } /* Font */ - obj = pdf_dict_gets(res, "Font"); + obj = pdf_dict_gets(ctx, res, "Font"); if (obj) { int i, l; - l = pdf_dict_len(obj); + l = pdf_dict_len(ctx, obj); for (i = 0; i < l; i++) { - pdf_obj *o = pdf_dict_get_val(obj, i); + pdf_obj *o = pdf_dict_get_val(ctx, obj, i); - if (!strcmp(pdf_to_name(pdf_dict_gets(o, "Subtype")), "Type3")) + if (!strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, o, "Subtype")), "Type3")) { - pdf_clean_type3(doc, o, page->resources, cookie); + pdf_clean_type3(ctx, doc, o, page->resources, cookie); } } } /* ProcSet - no cleaning possible. Inherit this from the old dict. */ - obj = pdf_dict_gets(page->resources, "ProcSet"); + obj = pdf_dict_gets(ctx, page->resources, "ProcSet"); if (obj) - pdf_dict_puts(res, "ProcSet", obj); + pdf_dict_puts(ctx, res, "ProcSet", obj); /* Properties - no cleaning possible. */ - pdf_drop_obj(page->resources); - ref = pdf_new_ref(doc, res); - page->resources = pdf_keep_obj(ref); - pdf_dict_puts(page->me, "Resources", ref); + pdf_drop_obj(ctx, page->resources); + ref = pdf_new_ref(ctx, doc, res); + page->resources = pdf_keep_obj(ctx, ref); + pdf_dict_puts(ctx, page->me, "Resources", ref); } fz_always(ctx) { fz_drop_buffer(ctx, buffer); - pdf_drop_obj(new_obj); - pdf_drop_obj(new_ref); - pdf_drop_obj(res); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, new_obj); + pdf_drop_obj(ctx, new_ref); + pdf_drop_obj(ctx, res); + pdf_drop_obj(ctx, ref); } fz_catch(ctx) { diff --git a/source/pdf/pdf-cmap-load.c b/source/pdf/pdf-cmap-load.c index e3bf943d..46338539 100644 --- a/source/pdf/pdf-cmap-load.c +++ b/source/pdf/pdf-cmap-load.c @@ -18,14 +18,13 @@ pdf_cmap_size(fz_context *ctx, pdf_cmap *cmap) * Load CMap stream in PDF file */ pdf_cmap * -pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj) +pdf_load_embedded_cmap(fz_context *ctx, pdf_document *doc, pdf_obj *stmobj) { fz_stream *file = NULL; pdf_cmap *cmap = NULL; pdf_cmap *usecmap; pdf_obj *wmode; pdf_obj *obj = NULL; - fz_context *ctx = doc->ctx; int phase = 0; fz_var(phase); @@ -33,7 +32,7 @@ pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj) fz_var(file); fz_var(cmap); - if (pdf_obj_marked(stmobj)) + if (pdf_obj_marked(ctx, stmobj)) fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in embedded cmap"); if ((cmap = pdf_find_item(ctx, pdf_drop_cmap_imp, stmobj)) != NULL) @@ -43,29 +42,29 @@ pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj) fz_try(ctx) { - file = pdf_open_stream(doc, pdf_to_num(stmobj), pdf_to_gen(stmobj)); + file = pdf_open_stream(ctx, doc, pdf_to_num(ctx, stmobj), pdf_to_gen(ctx, stmobj)); phase = 1; cmap = pdf_load_cmap(ctx, file); phase = 2; - fz_drop_stream(file); + fz_drop_stream(ctx, file); file = NULL; - wmode = pdf_dict_gets(stmobj, "WMode"); - if (pdf_is_int(wmode)) - pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(wmode)); - obj = pdf_dict_gets(stmobj, "UseCMap"); - if (pdf_is_name(obj)) + wmode = pdf_dict_gets(ctx, stmobj, "WMode"); + if (pdf_is_int(ctx, wmode)) + pdf_set_cmap_wmode(ctx, cmap, pdf_to_int(ctx, wmode)); + obj = pdf_dict_gets(ctx, stmobj, "UseCMap"); + if (pdf_is_name(ctx, obj)) { - usecmap = pdf_load_system_cmap(ctx, pdf_to_name(obj)); + usecmap = pdf_load_system_cmap(ctx, pdf_to_name(ctx, obj)); pdf_set_usecmap(ctx, cmap, usecmap); pdf_drop_cmap(ctx, usecmap); } - else if (pdf_is_indirect(obj)) + else if (pdf_is_indirect(ctx, obj)) { phase = 3; - pdf_mark_obj(obj); - usecmap = pdf_load_embedded_cmap(doc, obj); - pdf_unmark_obj(obj); + pdf_mark_obj(ctx, obj); + usecmap = pdf_load_embedded_cmap(ctx, doc, obj); + pdf_unmark_obj(ctx, obj); phase = 4; pdf_set_usecmap(ctx, cmap, usecmap); pdf_drop_cmap(ctx, usecmap); @@ -76,20 +75,20 @@ pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *stmobj) fz_catch(ctx) { if (file) - fz_drop_stream(file); + fz_drop_stream(ctx, file); if (cmap) pdf_drop_cmap(ctx, cmap); if (phase < 1) - fz_rethrow_message(ctx, "cannot open cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj)); + fz_rethrow_message(ctx, "cannot open cmap stream (%d %d R)", pdf_to_num(ctx, stmobj), pdf_to_gen(ctx, stmobj)); else if (phase < 2) - fz_rethrow_message(ctx, "cannot parse cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj)); + fz_rethrow_message(ctx, "cannot parse cmap stream (%d %d R)", pdf_to_num(ctx, stmobj), pdf_to_gen(ctx, stmobj)); else if (phase < 3) - fz_rethrow_message(ctx, "cannot load system usecmap '%s'", pdf_to_name(obj)); + fz_rethrow_message(ctx, "cannot load system usecmap '%s'", pdf_to_name(ctx, obj)); else { if (phase == 3) - pdf_unmark_obj(obj); - fz_rethrow_message(ctx, "cannot load embedded usecmap (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + pdf_unmark_obj(ctx, obj); + fz_rethrow_message(ctx, "cannot load embedded usecmap (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } } diff --git a/source/pdf/pdf-cmap-parse.c b/source/pdf/pdf-cmap-parse.c index 361c512f..c502ffe5 100644 --- a/source/pdf/pdf-cmap-parse.c +++ b/source/pdf/pdf-cmap-parse.c @@ -18,7 +18,7 @@ pdf_parse_cmap_name(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf { pdf_token tok; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_NAME) fz_strlcpy(cmap->cmap_name, buf->scratch, sizeof(cmap->cmap_name)); @@ -31,7 +31,7 @@ pdf_parse_wmode(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf *bu { pdf_token tok; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_INT) pdf_set_cmap_wmode(ctx, cmap, buf->i); @@ -47,7 +47,7 @@ pdf_parse_codespace_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_ while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "endcodespacerange")) return; @@ -55,7 +55,7 @@ pdf_parse_codespace_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_ else if (tok == PDF_TOK_STRING) { lo = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_STRING) { hi = pdf_code_from_string(buf->scratch, buf->len); @@ -78,7 +78,7 @@ pdf_parse_cid_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "endcidrange")) return; @@ -88,13 +88,13 @@ pdf_parse_cid_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf lo = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_STRING) fz_throw(ctx, FZ_ERROR_GENERIC, "expected string"); hi = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "expected integer"); @@ -112,7 +112,7 @@ pdf_parse_cid_char(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "endcidchar")) return; @@ -122,7 +122,7 @@ pdf_parse_cid_char(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf src = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "expected integer"); @@ -141,7 +141,7 @@ pdf_parse_bf_range_array(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_l while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_CLOSE_ARRAY) return; @@ -171,7 +171,7 @@ pdf_parse_bf_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "endbfrange")) return; @@ -181,7 +181,7 @@ pdf_parse_bf_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf lo = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_STRING) fz_throw(ctx, FZ_ERROR_GENERIC, "expected string"); @@ -192,7 +192,7 @@ pdf_parse_bf_range(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf return; } - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_STRING) { @@ -244,7 +244,7 @@ pdf_parse_bf_char(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf * while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "endbfchar")) return; @@ -254,7 +254,7 @@ pdf_parse_bf_char(fz_context *ctx, pdf_cmap *cmap, fz_stream *file, pdf_lexbuf * src = pdf_code_from_string(buf->scratch, buf->len); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); /* Note: does not handle /dstName */ if (tok != PDF_TOK_STRING) fz_throw(ctx, FZ_ERROR_GENERIC, "expected string"); @@ -286,7 +286,7 @@ pdf_load_cmap(fz_context *ctx, fz_stream *file) { while (1) { - tok = pdf_lex(file, &buf); + tok = pdf_lex(ctx, file, &buf); if (tok == PDF_TOK_EOF) break; @@ -332,7 +332,7 @@ pdf_load_cmap(fz_context *ctx, fz_stream *file) } fz_always(ctx) { - pdf_lexbuf_fin(&buf); + pdf_lexbuf_fin(ctx, &buf); } fz_catch(ctx) { diff --git a/source/pdf/pdf-colorspace.c b/source/pdf/pdf-colorspace.c index 50a6f9d1..a58dc961 100644 --- a/source/pdf/pdf-colorspace.c +++ b/source/pdf/pdf-colorspace.c @@ -3,14 +3,13 @@ /* ICCBased */ static fz_colorspace * -load_icc_based(pdf_document *doc, pdf_obj *dict) +load_icc_based(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { int n; pdf_obj *obj; - fz_context *ctx = doc->ctx; - n = pdf_to_int(pdf_dict_gets(dict, "N")); - obj = pdf_dict_gets(dict, "Alternate"); + n = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "N")); + obj = pdf_dict_gets(ctx, dict, "Alternate"); if (obj) { @@ -18,7 +17,7 @@ load_icc_based(pdf_document *doc, pdf_obj *dict) fz_try(ctx) { - cs_alt = pdf_load_colorspace(doc, obj); + cs_alt = pdf_load_colorspace(ctx, doc, obj); if (cs_alt->n != n) { fz_drop_colorspace(ctx, cs_alt); @@ -114,14 +113,13 @@ free_separation(fz_context *ctx, fz_colorspace *cs) } static fz_colorspace * -load_separation(pdf_document *doc, pdf_obj *array) +load_separation(fz_context *ctx, pdf_document *doc, pdf_obj *array) { fz_colorspace *cs; struct separation *sep = NULL; - fz_context *ctx = doc->ctx; - pdf_obj *nameobj = pdf_array_get(array, 1); - pdf_obj *baseobj = pdf_array_get(array, 2); - pdf_obj *tintobj = pdf_array_get(array, 3); + pdf_obj *nameobj = pdf_array_get(ctx, array, 1); + pdf_obj *baseobj = pdf_array_get(ctx, array, 2); + pdf_obj *tintobj = pdf_array_get(ctx, array, 3); fz_colorspace *base; fz_function *tint = NULL; int n; @@ -129,21 +127,21 @@ load_separation(pdf_document *doc, pdf_obj *array) fz_var(tint); fz_var(sep); - if (pdf_is_array(nameobj)) - n = pdf_array_len(nameobj); + if (pdf_is_array(ctx, nameobj)) + n = pdf_array_len(ctx, nameobj); else n = 1; if (n > FZ_MAX_COLORS) fz_throw(ctx, FZ_ERROR_GENERIC, "too many components in colorspace"); - base = pdf_load_colorspace(doc, baseobj); + base = pdf_load_colorspace(ctx, doc, baseobj); fz_try(ctx) { - tint = pdf_load_function(doc, tintobj, n, base->n); + tint = pdf_load_function(ctx, doc, tintobj, n, base->n); /* RJW: fz_drop_colorspace(ctx, base); - * "cannot load tint function (%d %d R)", pdf_to_num(tintobj), pdf_to_gen(tintobj) */ + * "cannot load tint function (%d %d R)", pdf_to_num(ctx, tintobj), pdf_to_gen(ctx, tintobj) */ sep = fz_malloc_struct(ctx, struct separation); sep->base = base; @@ -153,7 +151,7 @@ load_separation(pdf_document *doc, pdf_obj *array) cs->to_rgb = separation_to_rgb; cs->free_data = free_separation; cs->data = sep; - cs->size += sizeof(struct separation) + (base ? base->size : 0) + fz_function_size(tint); + cs->size += sizeof(struct separation) + (base ? base->size : 0) + fz_function_size(ctx, tint); } fz_catch(ctx) { @@ -167,7 +165,7 @@ load_separation(pdf_document *doc, pdf_obj *array) } int -pdf_is_tint_colorspace(fz_colorspace *cs) +pdf_is_tint_colorspace(fz_context *ctx, fz_colorspace *cs) { return cs && cs->to_rgb == separation_to_rgb; } @@ -175,12 +173,11 @@ pdf_is_tint_colorspace(fz_colorspace *cs) /* Indexed */ static fz_colorspace * -load_indexed(pdf_document *doc, pdf_obj *array) +load_indexed(fz_context *ctx, pdf_document *doc, pdf_obj *array) { - fz_context *ctx = doc->ctx; - pdf_obj *baseobj = pdf_array_get(array, 1); - pdf_obj *highobj = pdf_array_get(array, 2); - pdf_obj *lookupobj = pdf_array_get(array, 3); + pdf_obj *baseobj = pdf_array_get(ctx, array, 1); + pdf_obj *highobj = pdf_array_get(ctx, array, 2); + pdf_obj *lookupobj = pdf_array_get(ctx, array, 3); fz_colorspace *base = NULL; fz_colorspace *cs; int i, n, high; @@ -191,20 +188,20 @@ load_indexed(pdf_document *doc, pdf_obj *array) fz_try(ctx) { - base = pdf_load_colorspace(doc, baseobj); + base = pdf_load_colorspace(ctx, doc, baseobj); - high = pdf_to_int(highobj); + high = pdf_to_int(ctx, highobj); high = fz_clampi(high, 0, 255); n = base->n * (high + 1); lookup = fz_malloc_array(ctx, 1, n); - if (pdf_is_string(lookupobj) && pdf_to_str_len(lookupobj) >= n) + if (pdf_is_string(ctx, lookupobj) && pdf_to_str_len(ctx, lookupobj) >= n) { - unsigned char *buf = (unsigned char *) pdf_to_str_buf(lookupobj); + unsigned char *buf = (unsigned char *) pdf_to_str_buf(ctx, lookupobj); for (i = 0; i < n; i++) lookup[i] = buf[i]; } - else if (pdf_is_indirect(lookupobj)) + else if (pdf_is_indirect(ctx, lookupobj)) { fz_stream *file = NULL; @@ -212,18 +209,18 @@ load_indexed(pdf_document *doc, pdf_obj *array) fz_try(ctx) { - file = pdf_open_stream(doc, pdf_to_num(lookupobj), pdf_to_gen(lookupobj)); - i = fz_read(file, lookup, n); + file = pdf_open_stream(ctx, doc, pdf_to_num(ctx, lookupobj), pdf_to_gen(ctx, lookupobj)); + i = fz_read(ctx, file, lookup, n); if (i < n) memset(lookup+i, 0, n-i); } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { - fz_rethrow_message(ctx, "cannot open colorspace lookup table (%d 0 R)", pdf_to_num(lookupobj)); + fz_rethrow_message(ctx, "cannot open colorspace lookup table (%d 0 R)", pdf_to_num(ctx, lookupobj)); } } else @@ -246,16 +243,15 @@ load_indexed(pdf_document *doc, pdf_obj *array) /* Parse and create colorspace from PDF object */ static fz_colorspace * -pdf_load_colorspace_imp(pdf_document *doc, pdf_obj *obj) +pdf_load_colorspace_imp(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; - if (pdf_obj_marked(obj)) + if (pdf_obj_marked(ctx, obj)) fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in colorspace definition"); - if (pdf_is_name(obj)) + if (pdf_is_name(ctx, obj)) { - const char *str = pdf_to_name(obj); + const char *str = pdf_to_name(ctx, obj); if (!strcmp(str, "Pattern")) return fz_device_gray(ctx); else if (!strcmp(str, "G")) @@ -271,15 +267,15 @@ pdf_load_colorspace_imp(pdf_document *doc, pdf_obj *obj) else if (!strcmp(str, "DeviceCMYK")) return fz_device_cmyk(ctx); else - fz_throw(ctx, FZ_ERROR_GENERIC, "unknown colorspace: %s", pdf_to_name(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown colorspace: %s", pdf_to_name(ctx, obj)); } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { - pdf_obj *name = pdf_array_get(obj, 0); - const char *str = pdf_to_name(name); + pdf_obj *name = pdf_array_get(ctx, obj, 0); + const char *str = pdf_to_name(ctx, name); - if (pdf_is_name(name)) + if (pdf_is_name(ctx, name)) { /* load base colorspace instead */ if (!strcmp(str, "G")) @@ -307,39 +303,39 @@ pdf_load_colorspace_imp(pdf_document *doc, pdf_obj *obj) fz_colorspace *cs; fz_try(ctx) { - pdf_mark_obj(obj); + pdf_mark_obj(ctx, obj); if (!strcmp(str, "ICCBased")) - cs = load_icc_based(doc, pdf_array_get(obj, 1)); + cs = load_icc_based(ctx, doc, pdf_array_get(ctx, obj, 1)); else if (!strcmp(str, "Indexed")) - cs = load_indexed(doc, obj); + cs = load_indexed(ctx, doc, obj); else if (!strcmp(str, "I")) - cs = load_indexed(doc, obj); + cs = load_indexed(ctx, doc, obj); else if (!strcmp(str, "Separation")) - cs = load_separation(doc, obj); + cs = load_separation(ctx, doc, obj); else if (!strcmp(str, "DeviceN")) - cs = load_separation(doc, obj); + cs = load_separation(ctx, doc, obj); else if (!strcmp(str, "Pattern")) { pdf_obj *pobj; - pobj = pdf_array_get(obj, 1); + pobj = pdf_array_get(ctx, obj, 1); if (!pobj) { cs = fz_device_gray(ctx); break; } - cs = pdf_load_colorspace(doc, pobj); + cs = pdf_load_colorspace(ctx, doc, pobj); } else fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: unknown colorspace %s", str); } fz_always(ctx) { - pdf_unmark_obj(obj); + pdf_unmark_obj(ctx, obj); } fz_catch(ctx) { @@ -350,13 +346,12 @@ pdf_load_colorspace_imp(pdf_document *doc, pdf_obj *obj) } } - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "syntaxerror: could not parse color space (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: could not parse color space (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } fz_colorspace * -pdf_load_colorspace(pdf_document *doc, pdf_obj *obj) +pdf_load_colorspace(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; fz_colorspace *cs; if ((cs = pdf_find_item(ctx, fz_drop_colorspace_imp, obj)) != NULL) @@ -364,7 +359,7 @@ pdf_load_colorspace(pdf_document *doc, pdf_obj *obj) return cs; } - cs = pdf_load_colorspace_imp(doc, obj); + cs = pdf_load_colorspace_imp(ctx, doc, obj); pdf_store_item(ctx, obj, cs, cs->size); diff --git a/source/pdf/pdf-crypt.c b/source/pdf/pdf-crypt.c index 621885d0..4519657f 100644 --- a/source/pdf/pdf-crypt.c +++ b/source/pdf/pdf-crypt.c @@ -55,22 +55,22 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) /* Common to all security handlers (PDF 1.7 table 3.18) */ - obj = pdf_dict_gets(dict, "Filter"); - if (!pdf_is_name(obj)) + obj = pdf_dict_gets(ctx, dict, "Filter"); + if (!pdf_is_name(ctx, obj)) { pdf_drop_crypt(ctx, crypt); fz_throw(ctx, FZ_ERROR_GENERIC, "unspecified encryption handler"); } - if (strcmp(pdf_to_name(obj), "Standard") != 0) + if (strcmp(pdf_to_name(ctx, obj), "Standard") != 0) { pdf_drop_crypt(ctx, crypt); - fz_throw(ctx, FZ_ERROR_GENERIC, "unknown encryption handler: '%s'", pdf_to_name(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown encryption handler: '%s'", pdf_to_name(ctx, obj)); } crypt->v = 0; - obj = pdf_dict_gets(dict, "V"); - if (pdf_is_int(obj)) - crypt->v = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "V"); + if (pdf_is_int(ctx, obj)) + crypt->v = pdf_to_int(ctx, obj); if (crypt->v != 1 && crypt->v != 2 && crypt->v != 4 && crypt->v != 5) { pdf_drop_crypt(ctx, crypt); @@ -79,9 +79,9 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) /* Standard security handler (PDF 1.7 table 3.19) */ - obj = pdf_dict_gets(dict, "R"); - if (pdf_is_int(obj)) - crypt->r = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "R"); + if (pdf_is_int(ctx, obj)) + crypt->r = pdf_to_int(ctx, obj); else if (crypt->v <= 4) { fz_warn(ctx, "encryption dictionary missing revision value, guessing..."); @@ -104,28 +104,28 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) fz_throw(ctx, FZ_ERROR_GENERIC, "unknown crypt revision %d", r); } - obj = pdf_dict_gets(dict, "O"); - if (pdf_is_string(obj) && pdf_to_str_len(obj) == 32) - memcpy(crypt->o, pdf_to_str_buf(obj), 32); + obj = pdf_dict_gets(ctx, dict, "O"); + if (pdf_is_string(ctx, obj) && pdf_to_str_len(ctx, obj) == 32) + memcpy(crypt->o, pdf_to_str_buf(ctx, obj), 32); /* /O and /U are supposed to be 48 bytes long for revision 5 and 6, they're often longer, though */ - else if (crypt->r >= 5 && pdf_is_string(obj) && pdf_to_str_len(obj) >= 48) - memcpy(crypt->o, pdf_to_str_buf(obj), 48); + else if (crypt->r >= 5 && pdf_is_string(ctx, obj) && pdf_to_str_len(ctx, obj) >= 48) + memcpy(crypt->o, pdf_to_str_buf(ctx, obj), 48); else { pdf_drop_crypt(ctx, crypt); fz_throw(ctx, FZ_ERROR_GENERIC, "encryption dictionary missing owner password"); } - obj = pdf_dict_gets(dict, "U"); - if (pdf_is_string(obj) && pdf_to_str_len(obj) == 32) - memcpy(crypt->u, pdf_to_str_buf(obj), 32); + obj = pdf_dict_gets(ctx, dict, "U"); + if (pdf_is_string(ctx, obj) && pdf_to_str_len(ctx, obj) == 32) + memcpy(crypt->u, pdf_to_str_buf(ctx, obj), 32); /* /O and /U are supposed to be 48 bytes long for revision 5 and 6, they're often longer, though */ - else if (crypt->r >= 5 && pdf_is_string(obj) && pdf_to_str_len(obj) >= 48) - memcpy(crypt->u, pdf_to_str_buf(obj), 48); - else if (pdf_is_string(obj) && pdf_to_str_len(obj) < 32) + else if (crypt->r >= 5 && pdf_is_string(ctx, obj) && pdf_to_str_len(ctx, obj) >= 48) + memcpy(crypt->u, pdf_to_str_buf(ctx, obj), 48); + else if (pdf_is_string(ctx, obj) && pdf_to_str_len(ctx, obj) < 32) { - fz_warn(ctx, "encryption password key too short (%d)", pdf_to_str_len(obj)); - memcpy(crypt->u, pdf_to_str_buf(obj), pdf_to_str_len(obj)); + fz_warn(ctx, "encryption password key too short (%d)", pdf_to_str_len(ctx, obj)); + memcpy(crypt->u, pdf_to_str_buf(ctx, obj), pdf_to_str_len(ctx, obj)); } else { @@ -133,9 +133,9 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) fz_throw(ctx, FZ_ERROR_GENERIC, "encryption dictionary missing user password"); } - obj = pdf_dict_gets(dict, "P"); - if (pdf_is_int(obj)) - crypt->p = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "P"); + if (pdf_is_int(ctx, obj)) + crypt->p = pdf_to_int(ctx, obj); else { fz_warn(ctx, "encryption dictionary missing permissions"); @@ -144,35 +144,35 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) if (crypt->r == 5 || crypt->r == 6) { - obj = pdf_dict_gets(dict, "OE"); - if (!pdf_is_string(obj) || pdf_to_str_len(obj) != 32) + obj = pdf_dict_gets(ctx, dict, "OE"); + if (!pdf_is_string(ctx, obj) || pdf_to_str_len(ctx, obj) != 32) { pdf_drop_crypt(ctx, crypt); fz_throw(ctx, FZ_ERROR_GENERIC, "encryption dictionary missing owner encryption key"); } - memcpy(crypt->oe, pdf_to_str_buf(obj), 32); + memcpy(crypt->oe, pdf_to_str_buf(ctx, obj), 32); - obj = pdf_dict_gets(dict, "UE"); - if (!pdf_is_string(obj) || pdf_to_str_len(obj) != 32) + obj = pdf_dict_gets(ctx, dict, "UE"); + if (!pdf_is_string(ctx, obj) || pdf_to_str_len(ctx, obj) != 32) { pdf_drop_crypt(ctx, crypt); fz_throw(ctx, FZ_ERROR_GENERIC, "encryption dictionary missing user encryption key"); } - memcpy(crypt->ue, pdf_to_str_buf(obj), 32); + memcpy(crypt->ue, pdf_to_str_buf(ctx, obj), 32); } crypt->encrypt_metadata = 1; - obj = pdf_dict_gets(dict, "EncryptMetadata"); - if (pdf_is_bool(obj)) - crypt->encrypt_metadata = pdf_to_bool(obj); + obj = pdf_dict_gets(ctx, dict, "EncryptMetadata"); + if (pdf_is_bool(ctx, obj)) + crypt->encrypt_metadata = pdf_to_bool(ctx, obj); /* Extract file identifier string */ - if (pdf_is_array(id) && pdf_array_len(id) == 2) + if (pdf_is_array(ctx, id) && pdf_array_len(ctx, id) == 2) { - obj = pdf_array_get(id, 0); - if (pdf_is_string(obj)) - crypt->id = pdf_keep_obj(obj); + obj = pdf_array_get(ctx, id, 0); + if (pdf_is_string(ctx, obj)) + crypt->id = pdf_keep_obj(ctx, obj); } else fz_warn(ctx, "missing file identifier, may not be able to do decryption"); @@ -182,9 +182,9 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) crypt->length = 40; if (crypt->v == 2 || crypt->v == 4) { - obj = pdf_dict_gets(dict, "Length"); - if (pdf_is_int(obj)) - crypt->length = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "Length"); + if (pdf_is_int(ctx, obj)) + crypt->length = pdf_to_int(ctx, obj); /* work-around for pdf generators that assume length is in bytes */ if (crypt->length < 40) @@ -222,10 +222,10 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) crypt->strf.method = PDF_CRYPT_NONE; crypt->strf.length = crypt->length; - obj = pdf_dict_gets(dict, "CF"); - if (pdf_is_dict(obj)) + obj = pdf_dict_gets(ctx, dict, "CF"); + if (pdf_is_dict(ctx, obj)) { - crypt->cf = pdf_keep_obj(obj); + crypt->cf = pdf_keep_obj(ctx, obj); } else { @@ -234,18 +234,18 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) fz_try(ctx) { - obj = pdf_dict_gets(dict, "StmF"); - if (pdf_is_name(obj)) - pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt, pdf_to_name(obj)); + obj = pdf_dict_gets(ctx, dict, "StmF"); + if (pdf_is_name(ctx, obj)) + pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt, pdf_to_name(ctx, obj)); - obj = pdf_dict_gets(dict, "StrF"); - if (pdf_is_name(obj)) - pdf_parse_crypt_filter(ctx, &crypt->strf, crypt, pdf_to_name(obj)); + obj = pdf_dict_gets(ctx, dict, "StrF"); + if (pdf_is_name(ctx, obj)) + pdf_parse_crypt_filter(ctx, &crypt->strf, crypt, pdf_to_name(ctx, obj)); } fz_catch(ctx) { pdf_drop_crypt(ctx, crypt); - fz_rethrow_message(ctx, "cannot parse string crypt filter (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_rethrow_message(ctx, "cannot parse string crypt filter (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } /* in crypt revision 4, the crypt filter determines the key length */ @@ -259,8 +259,8 @@ pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id) void pdf_drop_crypt(fz_context *ctx, pdf_crypt *crypt) { - pdf_drop_obj(crypt->id); - pdf_drop_obj(crypt->cf); + pdf_drop_obj(ctx, crypt->id); + pdf_drop_obj(ctx, crypt->cf); fz_free(ctx, crypt); } @@ -277,7 +277,7 @@ pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, pdf_crypt *crypt, int is_stdcf = (!is_identity && (strcmp(name, "StdCF") == 0)); if (!is_identity && !is_stdcf) - fz_throw(ctx, FZ_ERROR_GENERIC, "Crypt Filter not Identity or StdCF (%d %d R)", pdf_to_num(crypt->cf), pdf_to_gen(crypt->cf)); + fz_throw(ctx, FZ_ERROR_GENERIC, "Crypt Filter not Identity or StdCF (%d %d R)", pdf_to_num(ctx, crypt->cf), pdf_to_gen(ctx, crypt->cf)); cf->method = PDF_CRYPT_NONE; cf->length = crypt->length; @@ -288,28 +288,28 @@ pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, pdf_crypt *crypt, return; } - dict = pdf_dict_gets(crypt->cf, name); - if (!pdf_is_dict(dict)) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot parse crypt filter (%d %d R)", pdf_to_num(crypt->cf), pdf_to_gen(crypt->cf)); + dict = pdf_dict_gets(ctx, crypt->cf, name); + if (!pdf_is_dict(ctx, dict)) + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot parse crypt filter (%d %d R)", pdf_to_num(ctx, crypt->cf), pdf_to_gen(ctx, crypt->cf)); - obj = pdf_dict_gets(dict, "CFM"); - if (pdf_is_name(obj)) + obj = pdf_dict_gets(ctx, dict, "CFM"); + if (pdf_is_name(ctx, obj)) { - if (!strcmp(pdf_to_name(obj), "None")) + if (!strcmp(pdf_to_name(ctx, obj), "None")) cf->method = PDF_CRYPT_NONE; - else if (!strcmp(pdf_to_name(obj), "V2")) + else if (!strcmp(pdf_to_name(ctx, obj), "V2")) cf->method = PDF_CRYPT_RC4; - else if (!strcmp(pdf_to_name(obj), "AESV2")) + else if (!strcmp(pdf_to_name(ctx, obj), "AESV2")) cf->method = PDF_CRYPT_AESV2; - else if (!strcmp(pdf_to_name(obj), "AESV3")) + else if (!strcmp(pdf_to_name(ctx, obj), "AESV3")) cf->method = PDF_CRYPT_AESV3; else - fz_warn(ctx, "unknown encryption method: %s", pdf_to_name(obj)); + fz_warn(ctx, "unknown encryption method: %s", pdf_to_name(ctx, obj)); } - obj = pdf_dict_gets(dict, "Length"); - if (pdf_is_int(obj)) - cf->length = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "Length"); + if (pdf_is_int(ctx, obj)) + cf->length = pdf_to_int(ctx, obj); /* the length for crypt filters is supposed to be in bytes not bits */ if (cf->length < 40) @@ -338,7 +338,7 @@ static const unsigned char padding[32] = }; static void -pdf_compute_encryption_key(pdf_crypt *crypt, unsigned char *password, int pwlen, unsigned char *key) +pdf_compute_encryption_key(fz_context *ctx, pdf_crypt *crypt, unsigned char *password, int pwlen, unsigned char *key) { unsigned char buf[32]; unsigned int p; @@ -369,7 +369,7 @@ pdf_compute_encryption_key(pdf_crypt *crypt, unsigned char *password, int pwlen, fz_md5_update(&md5, buf, 4); /* Step 5 - pass first element of ID array */ - fz_md5_update(&md5, (unsigned char *)pdf_to_str_buf(crypt->id), pdf_to_str_len(crypt->id)); + fz_md5_update(&md5, (unsigned char *)pdf_to_str_buf(ctx, crypt->id), pdf_to_str_len(ctx, crypt->id)); /* Step 6 (revision 4 or greater) - if metadata is not encrypted pass 0xFFFFFFFF */ if (crypt->r >= 4) @@ -558,7 +558,7 @@ pdf_compute_user_password(fz_context *ctx, pdf_crypt *crypt, unsigned char *pass { fz_arc4 arc4; - pdf_compute_encryption_key(crypt, password, pwlen, crypt->key); + pdf_compute_encryption_key(ctx, crypt, password, pwlen, crypt->key); fz_arc4_init(&arc4, crypt->key, crypt->length / 8); fz_arc4_encrypt(&arc4, output, padding, 32); } @@ -573,11 +573,11 @@ pdf_compute_user_password(fz_context *ctx, pdf_crypt *crypt, unsigned char *pass n = crypt->length / 8; - pdf_compute_encryption_key(crypt, password, pwlen, crypt->key); + pdf_compute_encryption_key(ctx, crypt, password, pwlen, crypt->key); fz_md5_init(&md5); fz_md5_update(&md5, padding, 32); - fz_md5_update(&md5, (unsigned char*)pdf_to_str_buf(crypt->id), pdf_to_str_len(crypt->id)); + fz_md5_update(&md5, (unsigned char*)pdf_to_str_buf(ctx, crypt->id), pdf_to_str_len(ctx, crypt->id)); fz_md5_final(&md5, digest); fz_arc4_init(&arc4, crypt->key, n); @@ -730,7 +730,7 @@ static void pdf_saslprep_from_utf8(char *password, const char *utf8, int n) } int -pdf_authenticate_password(pdf_document *doc, const char *pwd_utf8) +pdf_authenticate_password(fz_context *ctx, pdf_document *doc, const char *pwd_utf8) { char password[2048]; @@ -745,9 +745,9 @@ pdf_authenticate_password(pdf_document *doc, const char *pwd_utf8) pdf_saslprep_from_utf8(password, pwd_utf8, sizeof password); } - if (pdf_authenticate_user_password(doc->ctx, doc->crypt, (unsigned char *)password, strlen(password))) + if (pdf_authenticate_user_password(ctx, doc->crypt, (unsigned char *)password, strlen(password))) return 1; - if (pdf_authenticate_owner_password(doc->ctx, doc->crypt, (unsigned char *)password, strlen(password))) + if (pdf_authenticate_owner_password(ctx, doc->crypt, (unsigned char *)password, strlen(password))) return 1; return 0; } @@ -755,17 +755,17 @@ pdf_authenticate_password(pdf_document *doc, const char *pwd_utf8) } int -pdf_needs_password(pdf_document *doc) +pdf_needs_password(fz_context *ctx, pdf_document *doc) { if (!doc->crypt) return 0; - if (pdf_authenticate_password(doc, "")) + if (pdf_authenticate_password(ctx, doc, "")) return 0; return 1; } int -pdf_has_permission(pdf_document *doc, int p) +pdf_has_permission(fz_context *ctx, pdf_document *doc, int p) { if (!doc->crypt) return 1; @@ -773,7 +773,7 @@ pdf_has_permission(pdf_document *doc, int p) } unsigned char * -pdf_crypt_key(pdf_document *doc) +pdf_crypt_key(fz_context *ctx, pdf_document *doc) { if (doc->crypt) return doc->crypt->key; @@ -781,14 +781,14 @@ pdf_crypt_key(pdf_document *doc) } int -pdf_crypt_version(pdf_document *doc) +pdf_crypt_version(fz_context *ctx, pdf_document *doc) { if (doc->crypt) return doc->crypt->v; return 0; } -int pdf_crypt_revision(pdf_document *doc) +int pdf_crypt_revision(fz_context *ctx, pdf_document *doc) { if (doc->crypt) return doc->crypt->r; @@ -796,7 +796,7 @@ int pdf_crypt_revision(pdf_document *doc) } char * -pdf_crypt_method(pdf_document *doc) +pdf_crypt_method(fz_context *ctx, pdf_document *doc) { if (doc->crypt) { @@ -813,7 +813,7 @@ pdf_crypt_method(pdf_document *doc) } int -pdf_crypt_length(pdf_document *doc) +pdf_crypt_length(fz_context *ctx, pdf_document *doc) { if (doc->crypt) return doc->crypt->length; @@ -878,13 +878,13 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, unsigned char unsigned char *s; int i, n; - if (pdf_is_indirect(obj)) + if (pdf_is_indirect(ctx, obj)) return; - if (pdf_is_string(obj)) + if (pdf_is_string(ctx, obj)) { - s = (unsigned char *)pdf_to_str_buf(obj); - n = pdf_to_str_len(obj); + s = (unsigned char *)pdf_to_str_buf(ctx, obj); + n = pdf_to_str_len(ctx, obj); if (crypt->strf.method == PDF_CRYPT_RC4) { @@ -913,26 +913,26 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, unsigned char if (s[n - 17] < 1 || s[n - 17] > 16) fz_warn(ctx, "aes padding out of range"); else - pdf_set_str_len(obj, n - 16 - s[n - 17]); + pdf_set_str_len(ctx, obj, n - 16 - s[n - 17]); } } } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { - n = pdf_array_len(obj); + n = pdf_array_len(ctx, obj); for (i = 0; i < n; i++) { - pdf_crypt_obj_imp(ctx, crypt, pdf_array_get(obj, i), key, keylen); + pdf_crypt_obj_imp(ctx, crypt, pdf_array_get(ctx, obj, i), key, keylen); } } - else if (pdf_is_dict(obj)) + else if (pdf_is_dict(ctx, obj)) { - n = pdf_dict_len(obj); + n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) { - pdf_crypt_obj_imp(ctx, crypt, pdf_dict_get_val(obj, i), key, keylen); + pdf_crypt_obj_imp(ctx, crypt, pdf_dict_get_val(ctx, obj, i), key, keylen); } } } @@ -954,7 +954,7 @@ pdf_crypt_obj(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, int num, int gen) * Create filter suitable for de/encrypting a stream. */ static fz_stream * -pdf_open_crypt_imp(fz_stream *chain, pdf_crypt *crypt, pdf_crypt_filter *stmf, int num, int gen) +pdf_open_crypt_imp(fz_context *ctx, fz_stream *chain, pdf_crypt *crypt, pdf_crypt_filter *stmf, int num, int gen) { unsigned char key[32]; int len; @@ -962,34 +962,34 @@ pdf_open_crypt_imp(fz_stream *chain, pdf_crypt *crypt, pdf_crypt_filter *stmf, i len = pdf_compute_object_key(crypt, stmf, num, gen, key, 32); if (stmf->method == PDF_CRYPT_RC4) - return fz_open_arc4(chain, key, len); + return fz_open_arc4(ctx, chain, key, len); if (stmf->method == PDF_CRYPT_AESV2 || stmf->method == PDF_CRYPT_AESV3) - return fz_open_aesd(chain, key, len); + return fz_open_aesd(ctx, chain, key, len); - return fz_open_copy(chain); + return fz_open_copy(ctx, chain); } fz_stream * -pdf_open_crypt(fz_stream *chain, pdf_crypt *crypt, int num, int gen) +pdf_open_crypt(fz_context *ctx, fz_stream *chain, pdf_crypt *crypt, int num, int gen) { - return pdf_open_crypt_imp(chain, crypt, &crypt->stmf, num, gen); + return pdf_open_crypt_imp(ctx, chain, crypt, &crypt->stmf, num, gen); } fz_stream * -pdf_open_crypt_with_filter(fz_stream *chain, pdf_crypt *crypt, char *name, int num, int gen) +pdf_open_crypt_with_filter(fz_context *ctx, fz_stream *chain, pdf_crypt *crypt, char *name, int num, int gen) { if (strcmp(name, "Identity")) { pdf_crypt_filter cf; - pdf_parse_crypt_filter(chain->ctx, &cf, crypt, name); - return pdf_open_crypt_imp(chain, crypt, &cf, num, gen); + pdf_parse_crypt_filter(ctx, &cf, crypt, name); + return pdf_open_crypt_imp(ctx, chain, crypt, &cf, num, gen); } return chain; } #ifndef NDEBUG -void pdf_print_crypt(pdf_crypt *crypt) +void pdf_print_crypt(fz_context *ctx, pdf_crypt *crypt) { int i; diff --git a/source/pdf/pdf-device.c b/source/pdf/pdf-device.c index 0d8974be..471aaced 100644 --- a/source/pdf/pdf-device.c +++ b/source/pdf/pdf-device.c @@ -16,7 +16,7 @@ struct gstate_s * they are recorded here as they are fundamentally intertwined with * the push/pulling of the gstates. */ fz_buffer *buf; - void (*on_pop)(pdf_device*,void *); + void (*on_pop)(fz_context*,pdf_device*,void *); void *on_pop_arg; /* The graphics state proper */ fz_colorspace *colorspace[2]; @@ -72,7 +72,6 @@ struct group_entry_s struct pdf_device_s { - fz_context *ctx; pdf_document *doc; pdf_obj *contents; pdf_obj *resources; @@ -108,9 +107,8 @@ struct pdf_device_s /* Helper functions */ static int -send_image(pdf_device *pdev, fz_image *image, int mask, int smask) +send_image(fz_context *ctx, pdf_device *pdev, fz_image *image, int mask, int smask) { - fz_context *ctx = pdev->ctx; fz_pixmap *pixmap = NULL; pdf_obj *imobj = NULL; pdf_obj *imref = NULL; @@ -197,21 +195,21 @@ send_image(pdf_device *pdev, fz_image *image, int mask, int smask) memcpy(pdev->images[num].digest,digest,16); pdev->images[num].ref = NULL; /* Will be filled in later */ - imobj = pdf_new_dict(doc, 3); - pdf_dict_puts_drop(imobj, "Type", pdf_new_name(doc, "XObject")); - pdf_dict_puts_drop(imobj, "Subtype", pdf_new_name(doc, "Image")); - pdf_dict_puts_drop(imobj, "Width", pdf_new_int(doc, image->w)); - pdf_dict_puts_drop(imobj, "Height", pdf_new_int(doc, image->h)); + imobj = pdf_new_dict(ctx, doc, 3); + pdf_dict_puts_drop(ctx, imobj, "Type", pdf_new_name(ctx, doc, "XObject")); + pdf_dict_puts_drop(ctx, imobj, "Subtype", pdf_new_name(ctx, doc, "Image")); + pdf_dict_puts_drop(ctx, imobj, "Width", pdf_new_int(ctx, doc, image->w)); + pdf_dict_puts_drop(ctx, imobj, "Height", pdf_new_int(ctx, doc, image->h)); if (mask) {} else if (!colorspace || colorspace->n == 1) - pdf_dict_puts_drop(imobj, "ColorSpace", pdf_new_name(doc, "DeviceGray")); + pdf_dict_puts_drop(ctx, imobj, "ColorSpace", pdf_new_name(ctx, doc, "DeviceGray")); else if (colorspace->n == 3) - pdf_dict_puts_drop(imobj, "ColorSpace", pdf_new_name(doc, "DeviceRGB")); + pdf_dict_puts_drop(ctx, imobj, "ColorSpace", pdf_new_name(ctx, doc, "DeviceRGB")); else if (colorspace->n == 4) - pdf_dict_puts_drop(imobj, "ColorSpace", pdf_new_name(doc, "DeviceCMYK")); + pdf_dict_puts_drop(ctx, imobj, "ColorSpace", pdf_new_name(ctx, doc, "DeviceCMYK")); if (!mask) - pdf_dict_puts_drop(imobj, "BitsPerComponent", pdf_new_int(doc, image->bpc)); + pdf_dict_puts_drop(ctx, imobj, "BitsPerComponent", pdf_new_int(ctx, doc, image->bpc)); switch (cp ? cp->type : FZ_IMAGE_UNKNOWN) { case FZ_IMAGE_UNKNOWN: /* Unknown also means raw */ @@ -219,32 +217,32 @@ send_image(pdf_device *pdev, fz_image *image, int mask, int smask) break; case FZ_IMAGE_JPEG: if (cp->u.jpeg.color_transform != -1) - pdf_dict_puts_drop(imobj, "ColorTransform", pdf_new_int(doc, cp->u.jpeg.color_transform)); - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "DCTDecode")); + pdf_dict_puts_drop(ctx, imobj, "ColorTransform", pdf_new_int(ctx, doc, cp->u.jpeg.color_transform)); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "DCTDecode")); break; case FZ_IMAGE_JPX: if (cp->u.jpx.smask_in_data) - pdf_dict_puts_drop(imobj, "SMaskInData", pdf_new_int(doc, cp->u.jpx.smask_in_data)); - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "JPXDecode")); + pdf_dict_puts_drop(ctx, imobj, "SMaskInData", pdf_new_int(ctx, doc, cp->u.jpx.smask_in_data)); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "JPXDecode")); break; case FZ_IMAGE_FAX: if (cp->u.fax.columns) - pdf_dict_puts_drop(imobj, "Columns", pdf_new_int(doc, cp->u.fax.columns)); + pdf_dict_puts_drop(ctx, imobj, "Columns", pdf_new_int(ctx, doc, cp->u.fax.columns)); if (cp->u.fax.rows) - pdf_dict_puts_drop(imobj, "Rows", pdf_new_int(doc, cp->u.fax.rows)); + pdf_dict_puts_drop(ctx, imobj, "Rows", pdf_new_int(ctx, doc, cp->u.fax.rows)); if (cp->u.fax.k) - pdf_dict_puts_drop(imobj, "K", pdf_new_int(doc, cp->u.fax.k)); + pdf_dict_puts_drop(ctx, imobj, "K", pdf_new_int(ctx, doc, cp->u.fax.k)); if (cp->u.fax.end_of_line) - pdf_dict_puts_drop(imobj, "EndOfLine", pdf_new_int(doc, cp->u.fax.end_of_line)); + pdf_dict_puts_drop(ctx, imobj, "EndOfLine", pdf_new_int(ctx, doc, cp->u.fax.end_of_line)); if (cp->u.fax.encoded_byte_align) - pdf_dict_puts_drop(imobj, "EncodedByteAlign", pdf_new_int(doc, cp->u.fax.encoded_byte_align)); + pdf_dict_puts_drop(ctx, imobj, "EncodedByteAlign", pdf_new_int(ctx, doc, cp->u.fax.encoded_byte_align)); if (cp->u.fax.end_of_block) - pdf_dict_puts_drop(imobj, "EndOfBlock", pdf_new_int(doc, cp->u.fax.end_of_block)); + pdf_dict_puts_drop(ctx, imobj, "EndOfBlock", pdf_new_int(ctx, doc, cp->u.fax.end_of_block)); if (cp->u.fax.black_is_1) - pdf_dict_puts_drop(imobj, "BlackIs1", pdf_new_int(doc, cp->u.fax.black_is_1)); + pdf_dict_puts_drop(ctx, imobj, "BlackIs1", pdf_new_int(ctx, doc, cp->u.fax.black_is_1)); if (cp->u.fax.damaged_rows_before_error) - pdf_dict_puts_drop(imobj, "DamagedRowsBeforeError", pdf_new_int(doc, cp->u.fax.damaged_rows_before_error)); - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "CCITTFaxDecode")); + pdf_dict_puts_drop(ctx, imobj, "DamagedRowsBeforeError", pdf_new_int(ctx, doc, cp->u.fax.damaged_rows_before_error)); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "CCITTFaxDecode")); break; case FZ_IMAGE_JBIG2: /* FIXME - jbig2globals */ @@ -252,68 +250,67 @@ send_image(pdf_device *pdev, fz_image *image, int mask, int smask) break; case FZ_IMAGE_FLATE: if (cp->u.flate.columns) - pdf_dict_puts_drop(imobj, "Columns", pdf_new_int(doc, cp->u.flate.columns)); + pdf_dict_puts_drop(ctx, imobj, "Columns", pdf_new_int(ctx, doc, cp->u.flate.columns)); if (cp->u.flate.colors) - pdf_dict_puts_drop(imobj, "Colors", pdf_new_int(doc, cp->u.flate.colors)); + pdf_dict_puts_drop(ctx, imobj, "Colors", pdf_new_int(ctx, doc, cp->u.flate.colors)); if (cp->u.flate.predictor) - pdf_dict_puts_drop(imobj, "Predictor", pdf_new_int(doc, cp->u.flate.predictor)); - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "FlateDecode")); - pdf_dict_puts_drop(imobj, "BitsPerComponent", pdf_new_int(doc, image->bpc)); + pdf_dict_puts_drop(ctx, imobj, "Predictor", pdf_new_int(ctx, doc, cp->u.flate.predictor)); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "FlateDecode")); + pdf_dict_puts_drop(ctx, imobj, "BitsPerComponent", pdf_new_int(ctx, doc, image->bpc)); break; case FZ_IMAGE_LZW: if (cp->u.lzw.columns) - pdf_dict_puts_drop(imobj, "Columns", pdf_new_int(doc, cp->u.lzw.columns)); + pdf_dict_puts_drop(ctx, imobj, "Columns", pdf_new_int(ctx, doc, cp->u.lzw.columns)); if (cp->u.lzw.colors) - pdf_dict_puts_drop(imobj, "Colors", pdf_new_int(doc, cp->u.lzw.colors)); + pdf_dict_puts_drop(ctx, imobj, "Colors", pdf_new_int(ctx, doc, cp->u.lzw.colors)); if (cp->u.lzw.predictor) - pdf_dict_puts_drop(imobj, "Predictor", pdf_new_int(doc, cp->u.lzw.predictor)); + pdf_dict_puts_drop(ctx, imobj, "Predictor", pdf_new_int(ctx, doc, cp->u.lzw.predictor)); if (cp->u.lzw.early_change) - pdf_dict_puts_drop(imobj, "EarlyChange", pdf_new_int(doc, cp->u.lzw.early_change)); - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "LZWDecode")); + pdf_dict_puts_drop(ctx, imobj, "EarlyChange", pdf_new_int(ctx, doc, cp->u.lzw.early_change)); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "LZWDecode")); break; case FZ_IMAGE_RLD: - pdf_dict_puts_drop(imobj, "Filter", pdf_new_name(doc, "RunLengthDecode")); + pdf_dict_puts_drop(ctx, imobj, "Filter", pdf_new_name(ctx, doc, "RunLengthDecode")); break; } if (mask) { - pdf_dict_puts_drop(imobj, "ImageMask", pdf_new_bool(doc, 1)); + pdf_dict_puts_drop(ctx, imobj, "ImageMask", pdf_new_bool(ctx, doc, 1)); } if (image->mask) { - int smasknum = send_image(pdev, image->mask, 0, 1); - pdf_dict_puts(imobj, "SMask", pdev->images[smasknum].ref); + int smasknum = send_image(ctx, pdev, image->mask, 0, 1); + pdf_dict_puts(ctx, imobj, "SMask", pdev->images[smasknum].ref); } - imref = pdf_new_ref(doc, imobj); - pdf_update_stream(doc, pdf_to_num(imref), buffer); - pdf_dict_puts_drop(imobj, "Length", pdf_new_int(doc, buffer->len)); + imref = pdf_new_ref(ctx, doc, imobj); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, imref), buffer); + pdf_dict_puts_drop(ctx, imobj, "Length", pdf_new_int(ctx, doc, buffer->len)); { char text[32]; snprintf(text, sizeof(text), "XObject/Img%d", num); - pdf_dict_putp(pdev->resources, text, imref); + pdf_dict_putp(ctx, pdev->resources, text, imref); } pdev->images[num].ref = imref; } fz_always(ctx) { fz_drop_buffer(ctx, buffer); - pdf_drop_obj(imobj); + pdf_drop_obj(ctx, imobj); fz_drop_pixmap(ctx, pixmap); } fz_catch(ctx) { - pdf_drop_obj(imref); + pdf_drop_obj(ctx, imref); fz_rethrow(ctx); } return num; } static void -pdf_dev_stroke_state(pdf_device *pdev, fz_stroke_state *stroke_state) +pdf_dev_stroke_state(fz_context *ctx, pdf_device *pdev, fz_stroke_state *stroke_state) { - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); if (stroke_state == gs->stroke_state) @@ -361,9 +358,8 @@ pdf_dev_stroke_state(pdf_device *pdev, fz_stroke_state *stroke_state) } static void -pdf_dev_path(pdf_device *pdev, fz_path *path) +pdf_dev_path(fz_context *ctx, pdf_device *pdev, fz_path *path) { - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); float x, y; int i = 0, k = 0; @@ -400,7 +396,7 @@ pdf_dev_path(pdf_device *pdev, fz_path *path) } static void -pdf_dev_ctm(pdf_device *pdev, const fz_matrix *ctm) +pdf_dev_ctm(fz_context *ctx, pdf_device *pdev, const fz_matrix *ctm) { fz_matrix inverse; gstate *gs = CURRENT_GSTATE(pdev); @@ -410,16 +406,15 @@ pdf_dev_ctm(pdf_device *pdev, const fz_matrix *ctm) fz_invert_matrix(&inverse, &gs->ctm); fz_concat(&inverse, ctm, &inverse); memcpy(&gs->ctm, ctm, sizeof(*ctm)); - fz_buffer_printf(pdev->ctx, gs->buf, "%f %f %f %f %f %f cm\n", inverse.a, inverse.b, inverse.c, inverse.d, inverse.e, inverse.f); + fz_buffer_printf(ctx, gs->buf, "%f %f %f %f %f %f cm\n", inverse.a, inverse.b, inverse.c, inverse.d, inverse.e, inverse.f); } static void -pdf_dev_color(pdf_device *pdev, fz_colorspace *colorspace, float *color, int stroke) +pdf_dev_color(fz_context *ctx, pdf_device *pdev, fz_colorspace *colorspace, float *color, int stroke) { int diff = 0; int i; int cspace = 0; - fz_context *ctx = pdev->ctx; float rgb[FZ_MAX_COLORS]; gstate *gs = CURRENT_GSTATE(pdev); @@ -478,10 +473,9 @@ pdf_dev_color(pdf_device *pdev, fz_colorspace *colorspace, float *color, int str } static void -pdf_dev_alpha(pdf_device *pdev, float alpha, int stroke) +pdf_dev_alpha(fz_context *ctx, pdf_device *pdev, float alpha, int stroke) { int i; - fz_context *ctx = pdev->ctx; pdf_document *doc = pdev->doc; gstate *gs = CURRENT_GSTATE(pdev); @@ -513,19 +507,19 @@ pdf_dev_alpha(pdf_device *pdev, float alpha, int stroke) pdev->alphas[i].alpha = alpha; pdev->alphas[i].stroke = stroke; - o = pdf_new_dict(doc, 1); + o = pdf_new_dict(ctx, doc, 1); fz_try(ctx) { char text[32]; - pdf_dict_puts_drop(o, (stroke ? "CA" : "ca"), pdf_new_real(doc, alpha)); - ref = pdf_new_ref(doc, o); + pdf_dict_puts_drop(ctx, o, (stroke ? "CA" : "ca"), pdf_new_real(ctx, doc, alpha)); + ref = pdf_new_ref(ctx, doc, o); snprintf(text, sizeof(text), "ExtGState/Alp%d", i); - pdf_dict_putp(pdev->resources, text, ref); + pdf_dict_putp(ctx, pdev->resources, text, ref); } fz_always(ctx) { - pdf_drop_obj(o); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, o); + pdf_drop_obj(ctx, ref); } fz_catch(ctx) { @@ -537,11 +531,10 @@ pdf_dev_alpha(pdf_device *pdev, float alpha, int stroke) } static void -pdf_dev_font(pdf_device *pdev, fz_font *font, float size) +pdf_dev_font(fz_context *ctx, pdf_device *pdev, fz_font *font, float size) { int i; pdf_document *doc = pdev->doc; - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); /* If the font is unchanged, nothing to do */ @@ -549,7 +542,7 @@ pdf_dev_font(pdf_device *pdev, fz_font *font, float size) return; if (font->ft_buffer != NULL || font->ft_substitute) - fz_throw(pdev->ctx, FZ_ERROR_GENERIC, "pdf device supports only base 14 fonts currently"); + fz_throw(ctx, FZ_ERROR_GENERIC, "pdf device supports only base 14 fonts currently"); /* Have we sent such a font before? */ for (i = 0; i < pdev->num_fonts; i++) @@ -574,22 +567,22 @@ pdf_dev_font(pdf_device *pdev, fz_font *font, float size) } pdev->fonts[i].font = fz_keep_font(ctx, font); - o = pdf_new_dict(doc, 3); + o = pdf_new_dict(ctx, doc, 3); fz_try(ctx) { char text[32]; - pdf_dict_puts_drop(o, "Type", pdf_new_name(doc, "Font")); - pdf_dict_puts_drop(o, "Subtype", pdf_new_name(doc, "Type1")); - pdf_dict_puts_drop(o, "BaseFont", pdf_new_name(doc, font->name)); - pdf_dict_puts_drop(o, "Encoding", pdf_new_name(doc, "WinAnsiEncoding")); - ref = pdf_new_ref(doc, o); + pdf_dict_puts_drop(ctx, o, "Type", pdf_new_name(ctx, doc, "Font")); + pdf_dict_puts_drop(ctx, o, "Subtype", pdf_new_name(ctx, doc, "Type1")); + pdf_dict_puts_drop(ctx, o, "BaseFont", pdf_new_name(ctx, doc, font->name)); + pdf_dict_puts_drop(ctx, o, "Encoding", pdf_new_name(ctx, doc, "WinAnsiEncoding")); + ref = pdf_new_ref(ctx, doc, o); snprintf(text, sizeof(text), "Font/F%d", i); - pdf_dict_putp(pdev->resources, text, ref); + pdf_dict_putp(ctx, pdev->resources, text, ref); } fz_always(ctx) { - pdf_drop_obj(o); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, o); + pdf_drop_obj(ctx, ref); } fz_catch(ctx) { @@ -601,21 +594,19 @@ pdf_dev_font(pdf_device *pdev, fz_font *font, float size) } static void -pdf_dev_tm(pdf_device *pdev, const fz_matrix *tm) +pdf_dev_tm(fz_context *ctx, pdf_device *pdev, const fz_matrix *tm) { gstate *gs = CURRENT_GSTATE(pdev); if (memcmp(&gs->tm, tm, sizeof(*tm)) == 0) return; - fz_buffer_printf(pdev->ctx, gs->buf, "%f %f %f %f %f %f Tm\n", tm->a, tm->b, tm->c, tm->d, tm->e, tm->f); + fz_buffer_printf(ctx, gs->buf, "%f %f %f %f %f %f Tm\n", tm->a, tm->b, tm->c, tm->d, tm->e, tm->f); gs->tm = *tm; } static void -pdf_dev_push_new_buf(pdf_device *pdev, fz_buffer *buf, void (*on_pop)(pdf_device*,void *), void *on_pop_arg) +pdf_dev_push_new_buf(fz_context *ctx, pdf_device *pdev, fz_buffer *buf, void (*on_pop)(fz_context*,pdf_device*,void*), void *on_pop_arg) { - fz_context *ctx = pdev->ctx; - if (pdev->num_gstates == pdev->max_gstates) { int newmax = pdev->max_gstates*2; @@ -636,21 +627,20 @@ pdf_dev_push_new_buf(pdf_device *pdev, fz_buffer *buf, void (*on_pop)(pdf_device } static void -pdf_dev_push(pdf_device *pdev) +pdf_dev_push(fz_context *ctx, pdf_device *pdev) { - pdf_dev_push_new_buf(pdev, NULL, NULL, NULL); + pdf_dev_push_new_buf(ctx, pdev, NULL, NULL, NULL); } static void * -pdf_dev_pop(pdf_device *pdev) +pdf_dev_pop(fz_context *ctx, pdf_device *pdev) { - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); void *arg = gs->on_pop_arg; - fz_buffer_printf(pdev->ctx, gs->buf, "Q\n"); + fz_buffer_printf(ctx, gs->buf, "Q\n"); if (gs->on_pop) - gs->on_pop(pdev, arg); + gs->on_pop(ctx, pdev, arg); pdev->num_gstates--; fz_drop_stroke_state(ctx, pdev->gstates[pdev->num_gstates].stroke_state); fz_drop_buffer(ctx, pdev->gstates[pdev->num_gstates].buf); @@ -658,7 +648,7 @@ pdf_dev_pop(pdf_device *pdev) } static void -pdf_dev_text(pdf_device *pdev, fz_text *text, float size) +pdf_dev_text(fz_context *ctx, pdf_device *pdev, fz_text *text, float size) { int mask = FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM; int i; @@ -689,7 +679,7 @@ pdf_dev_text(pdf_device *pdev, fz_text *text, float size) fz_transform_point(&delta, &inverse); if (delta.x != 0 || delta.y != 0) { - fz_buffer_printf(pdev->ctx, gs->buf, "%f %f Td ", delta.x, delta.y); + fz_buffer_printf(ctx, gs->buf, "%f %f Td ", delta.x, delta.y); trm.e = it->x; trm.f = it->y; } @@ -711,38 +701,38 @@ pdf_dev_text(pdf_device *pdev, fz_text *text, float size) } } - fz_buffer_printf(pdev->ctx, gs->buf, "<"); + fz_buffer_printf(ctx, gs->buf, "<"); for (/* i from its current value */; i < j; i++) { /* FIXME: should use it->gid, rather than it->ucs, and convert * to the correct encoding */ - fz_buffer_printf(pdev->ctx, gs->buf, "%02x", text->items[i].ucs); + fz_buffer_printf(ctx, gs->buf, "%02x", text->items[i].ucs); } - fz_buffer_printf(pdev->ctx, gs->buf, "> Tj\n"); + fz_buffer_printf(ctx, gs->buf, "> Tj\n"); } gs->tm.e = trm.e; gs->tm.f = trm.f; } static void -pdf_dev_trm(pdf_device *pdev, int trm) +pdf_dev_trm(fz_context *ctx, pdf_device *pdev, int trm) { gstate *gs = CURRENT_GSTATE(pdev); if (gs->text_rendering_mode == trm) return; gs->text_rendering_mode = trm; - fz_buffer_printf(pdev->ctx, gs->buf, "%d Tr\n", trm); + fz_buffer_printf(ctx, gs->buf, "%d Tr\n", trm); } static void -pdf_dev_begin_text(pdf_device *pdev, const fz_matrix *tm, int trm) +pdf_dev_begin_text(fz_context *ctx, pdf_device *pdev, const fz_matrix *tm, int trm) { - pdf_dev_trm(pdev, trm); + pdf_dev_trm(ctx, pdev, trm); if (!pdev->in_text) { gstate *gs = CURRENT_GSTATE(pdev); - fz_buffer_printf(pdev->ctx, gs->buf, "BT\n"); + fz_buffer_printf(ctx, gs->buf, "BT\n"); gs->tm.a = 1; gs->tm.b = 0; gs->tm.c = 0; @@ -751,24 +741,23 @@ pdf_dev_begin_text(pdf_device *pdev, const fz_matrix *tm, int trm) gs->tm.f = 0; pdev->in_text = 1; } - pdf_dev_tm(pdev, tm); + pdf_dev_tm(ctx, pdev, tm); } static void -pdf_dev_end_text(pdf_device *pdev) +pdf_dev_end_text(fz_context *ctx, pdf_device *pdev) { gstate *gs = CURRENT_GSTATE(pdev); if (!pdev->in_text) return; pdev->in_text = 0; - fz_buffer_printf(pdev->ctx, gs->buf, "ET\n"); + fz_buffer_printf(ctx, gs->buf, "ET\n"); } static int -pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int isolated, int knockout, float alpha, fz_colorspace *colorspace) +pdf_dev_new_form(fz_context *ctx, pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int isolated, int knockout, float alpha, fz_colorspace *colorspace) { - fz_context *ctx = pdev->ctx; pdf_document *doc = pdev->doc; int num; pdf_obj *group_ref; @@ -805,26 +794,26 @@ pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int pdev->groups[num].alpha = alpha; pdev->groups[num].colorspace = fz_keep_colorspace(ctx, colorspace); pdev->groups[num].ref = NULL; - group = pdf_new_dict(doc, 5); + group = pdf_new_dict(ctx, doc, 5); fz_try(ctx) { - pdf_dict_puts_drop(group, "Type", pdf_new_name(doc, "Group")); - pdf_dict_puts_drop(group, "S", pdf_new_name(doc, "Transparency")); - pdf_dict_puts_drop(group, "K", pdf_new_bool(doc, knockout)); - pdf_dict_puts_drop(group, "I", pdf_new_bool(doc, isolated)); + pdf_dict_puts_drop(ctx, group, "Type", pdf_new_name(ctx, doc, "Group")); + pdf_dict_puts_drop(ctx, group, "S", pdf_new_name(ctx, doc, "Transparency")); + pdf_dict_puts_drop(ctx, group, "K", pdf_new_bool(ctx, doc, knockout)); + pdf_dict_puts_drop(ctx, group, "I", pdf_new_bool(ctx, doc, isolated)); if (!colorspace) {} else if (colorspace->n == 1) - pdf_dict_puts_drop(group, "CS", pdf_new_name(doc, "DeviceGray")); + pdf_dict_puts_drop(ctx, group, "CS", pdf_new_name(ctx, doc, "DeviceGray")); else if (colorspace->n == 4) - pdf_dict_puts_drop(group, "CS", pdf_new_name(doc, "DeviceCMYK")); + pdf_dict_puts_drop(ctx, group, "CS", pdf_new_name(ctx, doc, "DeviceCMYK")); else - pdf_dict_puts_drop(group, "CS", pdf_new_name(doc, "DeviceRGB")); - group_ref = pdev->groups[num].ref = pdf_new_ref(doc, group); + pdf_dict_puts_drop(ctx, group, "CS", pdf_new_name(ctx, doc, "DeviceRGB")); + group_ref = pdev->groups[num].ref = pdf_new_ref(ctx, doc, group); } fz_always(ctx) { - pdf_drop_obj(group); + pdf_drop_obj(ctx, group); } fz_catch(ctx) { @@ -834,18 +823,18 @@ pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int /* Make us a new Forms object that points to that group, and change * to writing into the buffer for that Forms object. */ - form = pdf_new_dict(doc, 4); + form = pdf_new_dict(ctx, doc, 4); fz_try(ctx) { - pdf_dict_puts_drop(form, "Subtype", pdf_new_name(doc, "Form")); - pdf_dict_puts(form, "Group", group_ref); - pdf_dict_puts_drop(form, "FormType", pdf_new_int(doc, 1)); - pdf_dict_puts_drop(form, "BBox", pdf_new_rect(doc, bbox)); - *form_ref = pdf_new_ref(doc, form); + pdf_dict_puts_drop(ctx, form, "Subtype", pdf_new_name(ctx, doc, "Form")); + pdf_dict_puts(ctx, form, "Group", group_ref); + pdf_dict_puts_drop(ctx, form, "FormType", pdf_new_int(ctx, doc, 1)); + pdf_dict_puts_drop(ctx, form, "BBox", pdf_new_rect(ctx, doc, bbox)); + *form_ref = pdf_new_ref(ctx, doc, form); } fz_catch(ctx) { - pdf_drop_obj(form); + pdf_drop_obj(ctx, form); fz_rethrow(ctx); } @@ -854,7 +843,7 @@ pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int char text[32]; num = pdev->num_forms++; snprintf(text, sizeof(text), "XObject/Fm%d", num); - pdf_dict_putp(pdev->resources, text, *form_ref); + pdf_dict_putp(ctx, pdev->resources, text, *form_ref); } return num; @@ -863,70 +852,70 @@ pdf_dev_new_form(pdf_obj **form_ref, pdf_device *pdev, const fz_rect *bbox, int /* Entry points */ static void -pdf_dev_fill_path(fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, +pdf_dev_fill_path(fz_context *ctx, fz_device *dev, fz_path *path, int even_odd, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { pdf_device *pdev = dev->user; gstate *gs = CURRENT_GSTATE(pdev); - pdf_dev_end_text(pdev); - pdf_dev_alpha(pdev, alpha, 0); - pdf_dev_color(pdev, colorspace, color, 0); - pdf_dev_ctm(pdev, ctm); - pdf_dev_path(pdev, path); - fz_buffer_printf(dev->ctx, gs->buf, (even_odd ? "f*\n" : "f\n")); + pdf_dev_end_text(ctx, pdev); + pdf_dev_alpha(ctx, pdev, alpha, 0); + pdf_dev_color(ctx, pdev, colorspace, color, 0); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_path(ctx, pdev, path); + fz_buffer_printf(ctx, gs->buf, (even_odd ? "f*\n" : "f\n")); } static void -pdf_dev_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, +pdf_dev_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { pdf_device *pdev = dev->user; gstate *gs = CURRENT_GSTATE(pdev); - pdf_dev_end_text(pdev); - pdf_dev_alpha(pdev, alpha, 1); - pdf_dev_color(pdev, colorspace, color, 1); - pdf_dev_ctm(pdev, ctm); - pdf_dev_stroke_state(pdev, stroke); - pdf_dev_path(pdev, path); - fz_buffer_printf(dev->ctx, gs->buf, "S\n"); + pdf_dev_end_text(ctx, pdev); + pdf_dev_alpha(ctx, pdev, alpha, 1); + pdf_dev_color(ctx, pdev, colorspace, color, 1); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_stroke_state(ctx, pdev, stroke); + pdf_dev_path(ctx, pdev, path); + fz_buffer_printf(ctx, gs->buf, "S\n"); } static void -pdf_dev_clip_path(fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) +pdf_dev_clip_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, int even_odd, const fz_matrix *ctm) { pdf_device *pdev = dev->user; gstate *gs; - pdf_dev_end_text(pdev); - pdf_dev_push(pdev); - pdf_dev_ctm(pdev, ctm); - pdf_dev_path(pdev, path); + pdf_dev_end_text(ctx, pdev); + pdf_dev_push(ctx, pdev); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_path(ctx, pdev, path); gs = CURRENT_GSTATE(pdev); - fz_buffer_printf(dev->ctx, gs->buf, (even_odd ? "W* n\n" : "W n\n")); + fz_buffer_printf(ctx, gs->buf, (even_odd ? "W* n\n" : "W n\n")); } static void -pdf_dev_clip_stroke_path(fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) +pdf_dev_clip_stroke_path(fz_context *ctx, fz_device *dev, fz_path *path, const fz_rect *rect, fz_stroke_state *stroke, const fz_matrix *ctm) { pdf_device *pdev = dev->user; gstate *gs; - pdf_dev_end_text(pdev); - pdf_dev_push(pdev); + pdf_dev_end_text(ctx, pdev); + pdf_dev_push(ctx, pdev); /* FIXME: Need to push a group, select a pattern (or shading) here, * stroke with the pattern/shading. Then move to defining that pattern * with the next calls to the device interface until the next pop * when we pop the group. */ - pdf_dev_ctm(pdev, ctm); - pdf_dev_path(pdev, path); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_path(ctx, pdev, path); gs = CURRENT_GSTATE(pdev); - fz_buffer_printf(dev->ctx, gs->buf, "W n\n"); + fz_buffer_printf(ctx, gs->buf, "W n\n"); } static void -pdf_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, +pdf_dev_fill_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { pdf_device *pdev = dev->user; @@ -935,16 +924,16 @@ pdf_dev_fill_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, fz_pre_scale(&trm, 1/size, 1/size); - pdf_dev_begin_text(pdev, &trm, 0); - pdf_dev_font(pdev, text->font, size); - pdf_dev_ctm(pdev, ctm); - pdf_dev_alpha(pdev, alpha, 0); - pdf_dev_color(pdev, colorspace, color, 0); - pdf_dev_text(pdev, text, size); + pdf_dev_begin_text(ctx, pdev, &trm, 0); + pdf_dev_font(ctx, pdev, text->font, size); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_alpha(ctx, pdev, alpha, 0); + pdf_dev_color(ctx, pdev, colorspace, color, 0); + pdf_dev_text(ctx, pdev, text, size); } static void -pdf_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, +pdf_dev_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { pdf_device *pdev = dev->user; @@ -953,16 +942,16 @@ pdf_dev_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, cons fz_pre_scale(&trm, 1/size, 1/size); - pdf_dev_begin_text(pdev, &text->trm, 1); - pdf_dev_font(pdev, text->font, 1); - pdf_dev_ctm(pdev, ctm); - pdf_dev_alpha(pdev, alpha, 1); - pdf_dev_color(pdev, colorspace, color, 1); - pdf_dev_text(pdev, text, size); + pdf_dev_begin_text(ctx, pdev, &text->trm, 1); + pdf_dev_font(ctx, pdev, text->font, 1); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_alpha(ctx, pdev, alpha, 1); + pdf_dev_color(ctx, pdev, colorspace, color, 1); + pdf_dev_text(ctx, pdev, text, size); } static void -pdf_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) +pdf_dev_clip_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm, int accumulate) { pdf_device *pdev = dev->user; fz_matrix trm = text->trm; @@ -970,14 +959,14 @@ pdf_dev_clip_text(fz_device *dev, fz_text *text, const fz_matrix *ctm, int accum fz_pre_scale(&trm, 1/size, 1/size); - pdf_dev_begin_text(pdev, &text->trm, 0); - pdf_dev_ctm(pdev, ctm); - pdf_dev_font(pdev, text->font, 7); - pdf_dev_text(pdev, text, size); + pdf_dev_begin_text(ctx, pdev, &text->trm, 0); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_font(ctx, pdev, text->font, 7); + pdf_dev_text(ctx, pdev, text, size); } static void -pdf_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) +pdf_dev_clip_stroke_text(fz_context *ctx, fz_device *dev, fz_text *text, fz_stroke_state *stroke, const fz_matrix *ctm) { pdf_device *pdev = dev->user; fz_matrix trm = text->trm; @@ -985,14 +974,14 @@ pdf_dev_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_pre_scale(&trm, 1/size, 1/size); - pdf_dev_begin_text(pdev, &text->trm, 0); - pdf_dev_font(pdev, text->font, 5); - pdf_dev_ctm(pdev, ctm); - pdf_dev_text(pdev, text, size); + pdf_dev_begin_text(ctx, pdev, &text->trm, 0); + pdf_dev_font(ctx, pdev, text->font, 5); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_text(ctx, pdev, text, size); } static void -pdf_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) +pdf_dev_ignore_text(fz_context *ctx, fz_device *dev, fz_text *text, const fz_matrix *ctm) { pdf_device *pdev = dev->user; fz_matrix trm = text->trm; @@ -1000,86 +989,85 @@ pdf_dev_ignore_text(fz_device *dev, fz_text *text, const fz_matrix *ctm) fz_pre_scale(&trm, 1/size, 1/size); - pdf_dev_begin_text(pdev, &text->trm, 0); - pdf_dev_ctm(pdev, ctm); - pdf_dev_font(pdev, text->font, 3); - pdf_dev_text(pdev, text, size); + pdf_dev_begin_text(ctx, pdev, &text->trm, 0); + pdf_dev_ctm(ctx, pdev, ctm); + pdf_dev_font(ctx, pdev, text->font, 3); + pdf_dev_text(ctx, pdev, text, size); } static void -pdf_dev_fill_image(fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) +pdf_dev_fill_image(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, float alpha) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; int num; gstate *gs = CURRENT_GSTATE(pdev); fz_matrix local_ctm = *ctm; - pdf_dev_end_text(pdev); - num = send_image(pdev, image, 0, 0); - pdf_dev_alpha(pdev, alpha, 0); + pdf_dev_end_text(ctx, pdev); + num = send_image(ctx, pdev, image, 0, 0); + pdf_dev_alpha(ctx, pdev, alpha, 0); /* PDF images are upside down, so fiddle the ctm */ fz_pre_scale(&local_ctm, 1, -1); fz_pre_translate(&local_ctm, 0, -1); - pdf_dev_ctm(pdev, &local_ctm); - fz_buffer_printf(dev->ctx, gs->buf, "/Img%d Do\n", num); + pdf_dev_ctm(ctx, pdev, &local_ctm); + fz_buffer_printf(ctx, gs->buf, "/Img%d Do\n", num); } static void -pdf_dev_fill_shade(fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) +pdf_dev_fill_shade(fz_context *ctx, fz_device *dev, fz_shade *shade, const fz_matrix *ctm, float alpha) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; /* FIXME */ - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); } static void -pdf_dev_fill_image_mask(fz_device *dev, fz_image *image, const fz_matrix *ctm, +pdf_dev_fill_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_matrix *ctm, fz_colorspace *colorspace, float *color, float alpha) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; gstate *gs = CURRENT_GSTATE(pdev); int num; fz_matrix local_ctm = *ctm; - pdf_dev_end_text(pdev); - num = send_image(pdev, image, 1, 0); - fz_buffer_printf(dev->ctx, gs->buf, "q\n"); - pdf_dev_alpha(pdev, alpha, 0); - pdf_dev_color(pdev, colorspace, color, 0); + pdf_dev_end_text(ctx, pdev); + num = send_image(ctx, pdev, image, 1, 0); + fz_buffer_printf(ctx, gs->buf, "q\n"); + pdf_dev_alpha(ctx, pdev, alpha, 0); + pdf_dev_color(ctx, pdev, colorspace, color, 0); /* PDF images are upside down, so fiddle the ctm */ fz_pre_scale(&local_ctm, 1, -1); fz_pre_translate(&local_ctm, 0, -1); - pdf_dev_ctm(pdev, &local_ctm); - fz_buffer_printf(dev->ctx, gs->buf, "/Img%d Do Q\n", num); + pdf_dev_ctm(ctx, pdev, &local_ctm); + fz_buffer_printf(ctx, gs->buf, "/Img%d Do Q\n", num); } static void -pdf_dev_clip_image_mask(fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) +pdf_dev_clip_image_mask(fz_context *ctx, fz_device *dev, fz_image *image, const fz_rect *rect, const fz_matrix *ctm) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; /* FIXME */ - pdf_dev_end_text(pdev); - pdf_dev_push(pdev); + pdf_dev_end_text(ctx, pdev); + pdf_dev_push(ctx, pdev); } static void -pdf_dev_pop_clip(fz_device *dev) +pdf_dev_pop_clip(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; /* FIXME */ - pdf_dev_end_text(pdev); - pdf_dev_pop(pdev); + pdf_dev_end_text(ctx, pdev); + pdf_dev_pop(ctx, pdev); } static void -pdf_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) +pdf_dev_begin_mask(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int luminosity, fz_colorspace *colorspace, float *color) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; pdf_document *doc = pdev->doc; - fz_context *ctx = pdev->ctx; gstate *gs; pdf_obj *smask = NULL; pdf_obj *egs = NULL; @@ -1092,163 +1080,159 @@ pdf_dev_begin_mask(fz_device *dev, const fz_rect *bbox, int luminosity, fz_color fz_var(egs); fz_var(color_obj); - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); /* Make a new form to contain the contents of the softmask */ - pdf_dev_new_form(&form_ref, pdev, bbox, 0, 0, 1, colorspace); + pdf_dev_new_form(ctx, &form_ref, pdev, bbox, 0, 0, 1, colorspace); fz_try(ctx) { - smask = pdf_new_dict(doc, 4); - pdf_dict_puts_drop(smask, "Type", pdf_new_name(doc, "Mask")); - pdf_dict_puts_drop(smask, "S", pdf_new_name(doc, (luminosity ? "Luminosity" : "Alpha"))); - pdf_dict_puts(smask, "G", form_ref); - color_obj = pdf_new_array(doc, colorspace->n); + smask = pdf_new_dict(ctx, doc, 4); + pdf_dict_puts_drop(ctx, smask, "Type", pdf_new_name(ctx, doc, "Mask")); + pdf_dict_puts_drop(ctx, smask, "S", pdf_new_name(ctx, doc, (luminosity ? "Luminosity" : "Alpha"))); + pdf_dict_puts(ctx, smask, "G", form_ref); + color_obj = pdf_new_array(ctx, doc, colorspace->n); for (i = 0; i < colorspace->n; i++) - pdf_array_push(color_obj, pdf_new_real(doc, color[i])); - pdf_dict_puts_drop(smask, "BC", color_obj); + pdf_array_push(ctx, color_obj, pdf_new_real(ctx, doc, color[i])); + pdf_dict_puts_drop(ctx, smask, "BC", color_obj); color_obj = NULL; - egs = pdf_new_dict(doc, 5); - pdf_dict_puts_drop(egs, "Type", pdf_new_name(doc, "ExtGState")); - pdf_dict_puts_drop(egs, "SMask", pdf_new_ref(doc, smask)); - egs_ref = pdf_new_ref(doc, egs); + egs = pdf_new_dict(ctx, doc, 5); + pdf_dict_puts_drop(ctx, egs, "Type", pdf_new_name(ctx, doc, "ExtGState")); + pdf_dict_puts_drop(ctx, egs, "SMask", pdf_new_ref(ctx, doc, smask)); + egs_ref = pdf_new_ref(ctx, doc, egs); { char text[32]; snprintf(text, sizeof(text), "ExtGState/SM%d", pdev->num_smasks++); - pdf_dict_putp(pdev->resources, text, egs_ref); - pdf_drop_obj(egs_ref); + pdf_dict_putp(ctx, pdev->resources, text, egs_ref); + pdf_drop_obj(ctx, egs_ref); } gs = CURRENT_GSTATE(pdev); - fz_buffer_printf(dev->ctx, gs->buf, "/SM%d gs\n", pdev->num_smasks-1); + fz_buffer_printf(ctx, gs->buf, "/SM%d gs\n", pdev->num_smasks-1); } fz_always(ctx) { - pdf_drop_obj(smask); + pdf_drop_obj(ctx, smask); } fz_catch(ctx) { - pdf_drop_obj(form_ref); - pdf_drop_obj(color_obj); + pdf_drop_obj(ctx, form_ref); + pdf_drop_obj(ctx, color_obj); fz_rethrow(ctx); } /* Now, everything we get until the end_mask needs to go into a * new buffer, which will be the stream contents for the form. */ - pdf_dev_push_new_buf(pdev, fz_new_buffer(ctx, 1024), NULL, form_ref); + pdf_dev_push_new_buf(ctx, pdev, fz_new_buffer(ctx, 1024), NULL, form_ref); } static void -pdf_dev_end_mask(fz_device *dev) +pdf_dev_end_mask(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; pdf_document *doc = pdev->doc; - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); fz_buffer *buf = fz_keep_buffer(ctx, gs->buf); pdf_obj *form_ref = (pdf_obj *)gs->on_pop_arg; /* Here we do part of the pop, but not all of it. */ - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); fz_buffer_printf(ctx, buf, "Q\n"); - pdf_dict_puts_drop(form_ref, "Length", pdf_new_int(doc, buf->len)); - pdf_update_stream(doc, pdf_to_num(form_ref), buf); + pdf_dict_puts_drop(ctx, form_ref, "Length", pdf_new_int(ctx, doc, buf->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, form_ref), buf); fz_drop_buffer(ctx, buf); gs->buf = fz_keep_buffer(ctx, gs[-1].buf); gs->on_pop_arg = NULL; - pdf_drop_obj(form_ref); + pdf_drop_obj(ctx, form_ref); fz_buffer_printf(ctx, gs->buf, "q\n"); } static void -pdf_dev_begin_group(fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) +pdf_dev_begin_group(fz_context *ctx, fz_device *dev, const fz_rect *bbox, int isolated, int knockout, int blendmode, float alpha) { - pdf_device *pdev = (pdf_device *)dev->user; - fz_context *ctx = pdev->ctx; + pdf_device *pdev = dev->user; pdf_document *doc = pdev->doc; int num; pdf_obj *form_ref; gstate *gs; - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); - num = pdf_dev_new_form(&form_ref, pdev, bbox, isolated, knockout, alpha, NULL); + num = pdf_dev_new_form(ctx, &form_ref, pdev, bbox, isolated, knockout, alpha, NULL); /* Do we have an appropriate blending extgstate already? */ { char text[32]; pdf_obj *obj; snprintf(text, sizeof(text), "ExtGState/BlendMode%d", blendmode); - obj = pdf_dict_getp(pdev->resources, text); + obj = pdf_dict_getp(ctx, pdev->resources, text); if (obj == NULL) { /* No, better make one */ - obj = pdf_new_dict(pdev->doc, 2); - pdf_dict_puts_drop(obj, "Type", pdf_new_name(doc, "ExtGState")); - pdf_dict_puts_drop(obj, "BM", pdf_new_name(doc, fz_blendmode_name(blendmode))); - pdf_dict_putp_drop(pdev->resources, text, obj); + obj = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts_drop(ctx, obj, "Type", pdf_new_name(ctx, doc, "ExtGState")); + pdf_dict_puts_drop(ctx, obj, "BM", pdf_new_name(ctx, doc, fz_blendmode_name(blendmode))); + pdf_dict_putp_drop(ctx, pdev->resources, text, obj); } } /* Add the call to this group */ gs = CURRENT_GSTATE(pdev); - fz_buffer_printf(dev->ctx, gs->buf, "/BlendMode%d gs /Fm%d Do\n", blendmode, num); + fz_buffer_printf(ctx, gs->buf, "/BlendMode%d gs /Fm%d Do\n", blendmode, num); /* Now, everything we get until the end of group needs to go into a * new buffer, which will be the stream contents for the form. */ - pdf_dev_push_new_buf(pdev, fz_new_buffer(ctx, 1024), NULL, form_ref); + pdf_dev_push_new_buf(ctx, pdev, fz_new_buffer(ctx, 1024), NULL, form_ref); } static void -pdf_dev_end_group(fz_device *dev) +pdf_dev_end_group(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; pdf_document *doc = pdev->doc; gstate *gs = CURRENT_GSTATE(pdev); - fz_context *ctx = pdev->ctx; fz_buffer *buf = fz_keep_buffer(ctx, gs->buf); pdf_obj *form_ref; - pdf_dev_end_text(pdev); - form_ref = (pdf_obj *)pdf_dev_pop(pdev); - pdf_dict_puts_drop(form_ref, "Length", pdf_new_int(doc, gs->buf->len)); - pdf_update_stream(doc, pdf_to_num(form_ref), buf); + pdf_dev_end_text(ctx, pdev); + form_ref = (pdf_obj *)pdf_dev_pop(ctx, pdev); + pdf_dict_puts_drop(ctx, form_ref, "Length", pdf_new_int(ctx, doc, gs->buf->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, form_ref), buf); fz_drop_buffer(ctx, buf); - pdf_drop_obj(form_ref); + pdf_drop_obj(ctx, form_ref); } static int -pdf_dev_begin_tile(fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) +pdf_dev_begin_tile(fz_context *ctx, fz_device *dev, const fz_rect *area, const fz_rect *view, float xstep, float ystep, const fz_matrix *ctm, int id) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; /* FIXME */ - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); return 0; } static void -pdf_dev_end_tile(fz_device *dev) +pdf_dev_end_tile(fz_context *ctx, fz_device *dev) { - pdf_device *pdev = (pdf_device *)dev->user; + pdf_device *pdev = dev->user; /* FIXME */ - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); } static void -pdf_dev_drop_user(fz_device *dev) +pdf_dev_drop_user(fz_context *ctx, fz_device *dev) { pdf_device *pdev = dev->user; pdf_document *doc = pdev->doc; - fz_context *ctx = pdev->ctx; gstate *gs = CURRENT_GSTATE(pdev); int i; - pdf_dev_end_text(pdev); + pdf_dev_end_text(ctx, pdev); - pdf_dict_puts_drop(pdev->contents, "Length", pdf_new_int(doc, gs->buf->len)); + pdf_dict_puts_drop(ctx, pdev->contents, "Length", pdf_new_int(ctx, doc, gs->buf->len)); for (i = pdev->num_gstates-1; i >= 0; i--) { @@ -1262,14 +1246,14 @@ pdf_dev_drop_user(fz_device *dev) for (i = pdev->num_imgs-1; i >= 0; i--) { - pdf_drop_obj(pdev->images[i].ref); + pdf_drop_obj(ctx, pdev->images[i].ref); } - pdf_update_stream(doc, pdf_to_num(pdev->contents), pdev->gstates[0].buf); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, pdev->contents), pdev->gstates[0].buf); fz_drop_buffer(ctx, pdev->gstates[0].buf); - pdf_drop_obj(pdev->contents); - pdf_drop_obj(pdev->resources); + pdf_drop_obj(ctx, pdev->contents); + pdf_drop_obj(ctx, pdev->resources); fz_free(ctx, pdev->images); fz_free(ctx, pdev->alphas); @@ -1277,26 +1261,16 @@ pdf_dev_drop_user(fz_device *dev) fz_free(ctx, pdev); } -static void -pdf_dev_rebind(fz_device *dev) -{ - pdf_device *pdev = dev->user; - - fz_rebind_document((fz_document *)pdev->doc, dev->ctx); -} - -fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *resources, const fz_matrix *ctm) +fz_device *pdf_new_pdf_device(fz_context *ctx, pdf_document *doc, pdf_obj *contents, pdf_obj *resources, const fz_matrix *ctm) { - fz_context *ctx = doc->ctx; pdf_device *pdev = fz_malloc_struct(ctx, pdf_device); fz_device *dev; fz_try(ctx) { - pdev->ctx = ctx; pdev->doc = doc; - pdev->contents = pdf_keep_obj(contents); - pdev->resources = pdf_keep_obj(resources); + pdev->contents = pdf_keep_obj(ctx, contents); + pdev->resources = pdf_keep_obj(ctx, resources); pdev->gstates = fz_malloc_struct(ctx, gstate); pdev->gstates[0].buf = fz_new_buffer(ctx, 256); pdev->gstates[0].ctm = *ctm; @@ -1321,7 +1295,6 @@ fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *res fz_rethrow(ctx); } - dev->rebind = pdf_dev_rebind; dev->drop_user = pdf_dev_drop_user; dev->fill_path = pdf_dev_fill_path; @@ -1353,30 +1326,29 @@ fz_device *pdf_new_pdf_device(pdf_document *doc, pdf_obj *contents, pdf_obj *res return dev; } -fz_device *pdf_page_write(pdf_document *doc, pdf_page *page) +fz_device *pdf_page_write(fz_context *ctx, pdf_document *doc, pdf_page *page) { - fz_context *ctx = doc->ctx; - pdf_obj *resources = pdf_dict_gets(page->me, "Resources"); + pdf_obj *resources = pdf_dict_gets(ctx, page->me, "Resources"); fz_matrix ctm; fz_pre_translate(fz_scale(&ctm, 1, -1), 0, page->mediabox.y0-page->mediabox.y1); if (resources == NULL) { - resources = pdf_new_dict(doc, 0); - pdf_dict_puts_drop(page->me, "Resources", resources); + resources = pdf_new_dict(ctx, doc, 0); + pdf_dict_puts_drop(ctx, page->me, "Resources", resources); } if (page->contents == NULL) { - pdf_obj *obj = pdf_new_dict(doc, 0); + pdf_obj *obj = pdf_new_dict(ctx, doc, 0); fz_try(ctx) { - page->contents = pdf_new_ref(doc, obj); - pdf_dict_puts(page->me, "Contents", page->contents); + page->contents = pdf_new_ref(ctx, doc, obj); + pdf_dict_puts(ctx, page->me, "Contents", page->contents); } fz_always(ctx) { - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } fz_catch(ctx) { @@ -1384,5 +1356,5 @@ fz_device *pdf_page_write(pdf_document *doc, pdf_page *page) } } - return pdf_new_pdf_device(doc, page->contents, resources, &ctm); + return pdf_new_pdf_device(ctx, doc, page->contents, resources, &ctm); } diff --git a/source/pdf/pdf-event.c b/source/pdf/pdf-event.c index dc908985..b031dd72 100644 --- a/source/pdf/pdf-event.c +++ b/source/pdf/pdf-event.c @@ -7,7 +7,7 @@ typedef struct pdf_alert_event alert; } pdf_alert_event_internal; -pdf_alert_event *pdf_access_alert_event(pdf_doc_event *event) +pdf_alert_event *pdf_access_alert_event(fz_context *ctx, pdf_doc_event *event) { pdf_alert_event *alert = NULL; @@ -17,7 +17,7 @@ pdf_alert_event *pdf_access_alert_event(pdf_doc_event *event) return alert; } -void pdf_event_issue_alert(pdf_document *doc, pdf_alert_event *alert) +void pdf_event_issue_alert(fz_context *ctx, pdf_document *doc, pdf_alert_event *alert) { if (doc->event_cb) { @@ -25,20 +25,20 @@ void pdf_event_issue_alert(pdf_document *doc, pdf_alert_event *alert) ievent.base.type = PDF_DOCUMENT_EVENT_ALERT; ievent.alert = *alert; - doc->event_cb((pdf_doc_event *)&ievent, doc->event_cb_data); + doc->event_cb(ctx, doc, (pdf_doc_event *)&ievent, doc->event_cb_data); *alert = ievent.alert; } } -void pdf_event_issue_print(pdf_document *doc) +void pdf_event_issue_print(fz_context *ctx, pdf_document *doc) { pdf_doc_event e; e.type = PDF_DOCUMENT_EVENT_PRINT; if (doc->event_cb) - doc->event_cb(&e, doc->event_cb_data); + doc->event_cb(ctx, doc, &e, doc->event_cb_data); } typedef struct @@ -47,7 +47,7 @@ typedef struct char *item; } pdf_exec_menu_item_event_internal; -char *pdf_access_exec_menu_item_event(pdf_doc_event *event) +char *pdf_access_exec_menu_item_event(fz_context *ctx, pdf_doc_event *event) { char *item = NULL; @@ -57,7 +57,7 @@ char *pdf_access_exec_menu_item_event(pdf_doc_event *event) return item; } -void pdf_event_issue_exec_menu_item(pdf_document *doc, char *item) +void pdf_event_issue_exec_menu_item(fz_context *ctx, pdf_document *doc, char *item) { if (doc->event_cb) { @@ -65,18 +65,18 @@ void pdf_event_issue_exec_menu_item(pdf_document *doc, char *item) ievent.base.type = PDF_DOCUMENT_EVENT_EXEC_MENU_ITEM; ievent.item = item; - doc->event_cb((pdf_doc_event *)&ievent, doc->event_cb_data); + doc->event_cb(ctx, doc, (pdf_doc_event *)&ievent, doc->event_cb_data); } } -void pdf_event_issue_exec_dialog(pdf_document *doc) +void pdf_event_issue_exec_dialog(fz_context *ctx, pdf_document *doc) { pdf_doc_event e; e.type = PDF_DOCUMENT_EVENT_EXEC_DIALOG; if (doc->event_cb) - doc->event_cb(&e, doc->event_cb_data); + doc->event_cb(ctx, doc, &e, doc->event_cb_data); } typedef struct @@ -85,7 +85,7 @@ typedef struct pdf_launch_url_event launch_url; } pdf_launch_url_event_internal; -pdf_launch_url_event *pdf_access_launch_url_event(pdf_doc_event *event) +pdf_launch_url_event *pdf_access_launch_url_event(fz_context *ctx, pdf_doc_event *event) { pdf_launch_url_event *launch_url = NULL; @@ -95,7 +95,7 @@ pdf_launch_url_event *pdf_access_launch_url_event(pdf_doc_event *event) return launch_url; } -void pdf_event_issue_launch_url(pdf_document *doc, char *url, int new_frame) +void pdf_event_issue_launch_url(fz_context *ctx, pdf_document *doc, char *url, int new_frame) { if (doc->event_cb) { @@ -104,7 +104,7 @@ void pdf_event_issue_launch_url(pdf_document *doc, char *url, int new_frame) e.base.type = PDF_DOCUMENT_EVENT_LAUNCH_URL; e.launch_url.url = url; e.launch_url.new_frame = new_frame; - doc->event_cb((pdf_doc_event *)&e, doc->event_cb_data); + doc->event_cb(ctx, doc, (pdf_doc_event *)&e, doc->event_cb_data); } } @@ -114,7 +114,7 @@ typedef struct pdf_mail_doc_event mail_doc; } pdf_mail_doc_event_internal; -pdf_mail_doc_event *pdf_access_mail_doc_event(pdf_doc_event *event) +pdf_mail_doc_event *pdf_access_mail_doc_event(fz_context *ctx, pdf_doc_event *event) { pdf_mail_doc_event *mail_doc = NULL; @@ -124,7 +124,7 @@ pdf_mail_doc_event *pdf_access_mail_doc_event(pdf_doc_event *event) return mail_doc; } -void pdf_event_issue_mail_doc(pdf_document *doc, pdf_mail_doc_event *event) +void pdf_event_issue_mail_doc(fz_context *ctx, pdf_document *doc, pdf_mail_doc_event *event) { if (doc->event_cb) { @@ -133,11 +133,11 @@ void pdf_event_issue_mail_doc(pdf_document *doc, pdf_mail_doc_event *event) e.base.type = PDF_DOCUMENT_EVENT_MAIL_DOC; e.mail_doc = *event; - doc->event_cb((pdf_doc_event *)&e, doc->event_cb_data); + doc->event_cb(ctx, doc, (pdf_doc_event *)&e, doc->event_cb_data); } } -void pdf_set_doc_event_callback(pdf_document *doc, pdf_doc_event_cb *fn, void *data) +void pdf_set_doc_event_callback(fz_context *ctx, pdf_document *doc, pdf_doc_event_cb *fn, void *data) { doc->event_cb = fn; doc->event_cb_data = data; diff --git a/source/pdf/pdf-field.c b/source/pdf/pdf-field.c index e8f2508f..5105125a 100644 --- a/source/pdf/pdf-field.c +++ b/source/pdf/pdf-field.c @@ -1,23 +1,22 @@ #include "mupdf/pdf.h" -pdf_obj *pdf_get_inheritable(pdf_document *doc, pdf_obj *obj, char *key) +pdf_obj *pdf_get_inheritable(fz_context *ctx, pdf_document *doc, pdf_obj *obj, char *key) { pdf_obj *fobj = NULL; while (!fobj && obj) { - fobj = pdf_dict_gets(obj, key); + fobj = pdf_dict_gets(ctx, obj, key); if (!fobj) - obj = pdf_dict_gets(obj, "Parent"); + obj = pdf_dict_gets(ctx, obj, "Parent"); } - return fobj ? fobj : pdf_dict_gets(pdf_dict_gets(pdf_dict_gets(pdf_trailer(doc), "Root"), "AcroForm"), key); + return fobj ? fobj : pdf_dict_gets(ctx, pdf_dict_gets(ctx, pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"), "AcroForm"), key); } -char *pdf_get_string_or_stream(pdf_document *doc, pdf_obj *obj) +char *pdf_get_string_or_stream(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; int len = 0; char *buf = NULL; fz_buffer *strmbuf = NULL; @@ -27,14 +26,14 @@ char *pdf_get_string_or_stream(pdf_document *doc, pdf_obj *obj) fz_var(text); fz_try(ctx) { - if (pdf_is_string(obj)) + if (pdf_is_string(ctx, obj)) { - len = pdf_to_str_len(obj); - buf = pdf_to_str_buf(obj); + len = pdf_to_str_len(ctx, obj); + buf = pdf_to_str_buf(ctx, obj); } - else if (pdf_is_stream(doc, pdf_to_num(obj), pdf_to_gen(obj))) + else if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj))) { - strmbuf = pdf_load_stream(doc, pdf_to_num(obj), pdf_to_gen(obj)); + strmbuf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); len = fz_buffer_storage(ctx, strmbuf, (unsigned char **)&buf); } @@ -58,25 +57,25 @@ char *pdf_get_string_or_stream(pdf_document *doc, pdf_obj *obj) return text; } -char *pdf_field_value(pdf_document *doc, pdf_obj *field) +char *pdf_field_value(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - return pdf_get_string_or_stream(doc, pdf_get_inheritable(doc, field, "V")); + return pdf_get_string_or_stream(ctx, doc, pdf_get_inheritable(ctx, doc, field, "V")); } -int pdf_get_field_flags(pdf_document *doc, pdf_obj *obj) +int pdf_get_field_flags(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - return pdf_to_int(pdf_get_inheritable(doc, obj, "Ff")); + return pdf_to_int(ctx, pdf_get_inheritable(ctx, doc, obj, "Ff")); } -static char *get_field_type_name(pdf_document *doc, pdf_obj *obj) +static char *get_field_type_name(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - return pdf_to_name(pdf_get_inheritable(doc, obj, "FT")); + return pdf_to_name(ctx, pdf_get_inheritable(ctx, doc, obj, "FT")); } -int pdf_field_type(pdf_document *doc, pdf_obj *obj) +int pdf_field_type(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - char *type = get_field_type_name(doc, obj); - int flags = pdf_get_field_flags(doc, obj); + char *type = get_field_type_name(ctx, doc, obj); + int flags = pdf_get_field_flags(ctx, doc, obj); if (!strcmp(type, "Btn")) { @@ -102,7 +101,7 @@ int pdf_field_type(pdf_document *doc, pdf_obj *obj) return PDF_WIDGET_TYPE_NOT_WIDGET; } -void pdf_set_field_type(pdf_document *doc, pdf_obj *obj, int type) +void pdf_set_field_type(fz_context *ctx, pdf_document *doc, pdf_obj *obj, int type) { int setbits = 0; int clearbits = 0; @@ -140,13 +139,13 @@ void pdf_set_field_type(pdf_document *doc, pdf_obj *obj, int type) } if (typename) - pdf_dict_puts_drop(obj, "FT", pdf_new_name(doc, typename)); + pdf_dict_puts_drop(ctx, obj, "FT", pdf_new_name(ctx, doc, typename)); if (setbits != 0 || clearbits != 0) { - int bits = pdf_to_int(pdf_dict_gets(obj, "Ff")); + int bits = pdf_to_int(ctx, pdf_dict_gets(ctx, obj, "Ff")); bits &= ~clearbits; bits |= setbits; - pdf_dict_puts_drop(obj, "Ff", pdf_new_int(doc, bits)); + pdf_dict_puts_drop(ctx, obj, "Ff", pdf_new_int(ctx, doc, bits)); } } diff --git a/source/pdf/pdf-font.c b/source/pdf/pdf-font.c index a0ee8bee..5e3f1e19 100644 --- a/source/pdf/pdf-font.c +++ b/source/pdf/pdf-font.c @@ -4,7 +4,7 @@ #include FT_FREETYPE_H #include FT_XFREE86_H -static void pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *doc, pdf_obj *dict, char *collection, char *basefont, int iscidfont); +static void pdf_load_font_descriptor(fz_context *ctx, pdf_document *doc, pdf_font_desc *fontdesc, pdf_obj *dict, char *collection, char *basefont, int iscidfont); static const char *base_font_names[][10] = { @@ -184,7 +184,7 @@ pdf_load_builtin_font(fz_context *ctx, pdf_font_desc *fontdesc, char *fontname, unsigned char *data; unsigned int len; - data = pdf_lookup_builtin_font(clean_name, &len); + data = pdf_lookup_builtin_font(ctx, clean_name, &len); if (!data) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find builtin font: '%s'", fontname); @@ -208,7 +208,7 @@ pdf_load_substitute_font(fz_context *ctx, pdf_font_desc *fontdesc, char *fontnam unsigned char *data; unsigned int len; - data = pdf_lookup_substitute_font(mono, serif, bold, italic, &len); + data = pdf_lookup_substitute_font(ctx, mono, serif, bold, italic, &len); if (!data) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find substitute font"); @@ -230,7 +230,7 @@ pdf_load_substitute_cjk_font(fz_context *ctx, pdf_font_desc *fontdesc, char *fon unsigned int len; int index; - data = pdf_lookup_substitute_cjk_font(ros, serif, fontdesc->wmode, &len, &index); + data = pdf_lookup_substitute_cjk_font(ctx, ros, serif, fontdesc->wmode, &len, &index); if (!data) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find builtin CJK font"); @@ -289,18 +289,17 @@ pdf_load_system_font(fz_context *ctx, pdf_font_desc *fontdesc, char *fontname, c } static void -pdf_load_embedded_font(pdf_document *doc, pdf_font_desc *fontdesc, char *fontname, pdf_obj *stmref) +pdf_load_embedded_font(fz_context *ctx, pdf_document *doc, pdf_font_desc *fontdesc, char *fontname, pdf_obj *stmref) { fz_buffer *buf; - fz_context *ctx = doc->ctx; fz_try(ctx) { - buf = pdf_load_stream(doc, pdf_to_num(stmref), pdf_to_gen(stmref)); + buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, stmref), pdf_to_gen(ctx, stmref)); } fz_catch(ctx) { - fz_rethrow_message(ctx, "cannot load font stream (%d %d R)", pdf_to_num(stmref), pdf_to_gen(stmref)); + fz_rethrow_message(ctx, "cannot load font stream (%d %d R)", pdf_to_num(ctx, stmref), pdf_to_gen(ctx, stmref)); } fz_try(ctx) @@ -313,7 +312,7 @@ pdf_load_embedded_font(pdf_document *doc, pdf_font_desc *fontdesc, char *fontnam } fz_catch(ctx) { - fz_rethrow_message(ctx, "cannot load embedded font (%d %d R)", pdf_to_num(stmref), pdf_to_gen(stmref)); + fz_rethrow_message(ctx, "cannot load embedded font (%d %d R)", pdf_to_num(ctx, stmref), pdf_to_gen(ctx, stmref)); } fontdesc->size += buf->len; @@ -413,7 +412,7 @@ pdf_new_font_desc(fz_context *ctx) */ static pdf_font_desc * -pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) +pdf_load_simple_font_by_name(fz_context *ctx, pdf_document *doc, pdf_obj *dict, char *basefont) { pdf_obj *descriptor; pdf_obj *encoding; @@ -431,7 +430,6 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) int i, k, n; int fterr; int has_lock = 0; - fz_context *ctx = doc->ctx; fz_var(fontdesc); fz_var(etable); @@ -442,17 +440,17 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) { fontdesc = pdf_new_font_desc(ctx); - descriptor = pdf_dict_gets(dict, "FontDescriptor"); + descriptor = pdf_dict_gets(ctx, dict, "FontDescriptor"); if (descriptor) - pdf_load_font_descriptor(fontdesc, doc, descriptor, NULL, basefont, 0); + pdf_load_font_descriptor(ctx, doc, fontdesc, descriptor, NULL, basefont, 0); else pdf_load_builtin_font(ctx, fontdesc, basefont, 0); /* Some chinese documents mistakenly consider WinAnsiEncoding to be codepage 936 */ - if (descriptor && pdf_is_string(pdf_dict_gets(descriptor, "FontName")) && - !pdf_dict_gets(dict, "ToUnicode") && - !strcmp(pdf_to_name(pdf_dict_gets(dict, "Encoding")), "WinAnsiEncoding") && - pdf_to_int(pdf_dict_gets(descriptor, "Flags")) == 4) + if (descriptor && pdf_is_string(ctx, pdf_dict_gets(ctx, descriptor, "FontName")) && + !pdf_dict_gets(ctx, dict, "ToUnicode") && + !strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "Encoding")), "WinAnsiEncoding") && + pdf_to_int(ctx, pdf_dict_gets(ctx, descriptor, "Flags")) == 4) { char *cp936fonts[] = { "\xCB\xCE\xCC\xE5", "SimSun,Regular", @@ -471,7 +469,7 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) pdf_drop_font(ctx, fontdesc); fontdesc = NULL; fontdesc = pdf_new_font_desc(ctx); - pdf_load_font_descriptor(fontdesc, doc, descriptor, "Adobe-GB1", cp936fonts[i+1], 0); + pdf_load_font_descriptor(ctx, doc, fontdesc, descriptor, "Adobe-GB1", cp936fonts[i+1], 0); fontdesc->encoding = pdf_load_system_cmap(ctx, "GBK-EUC-H"); fontdesc->to_unicode = pdf_load_system_cmap(ctx, "Adobe-GB1-UCS2"); fontdesc->to_ttf_cmap = pdf_load_system_cmap(ctx, "Adobe-GB1-UCS2"); @@ -532,34 +530,34 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) etable[i] = 0; } - encoding = pdf_dict_gets(dict, "Encoding"); + encoding = pdf_dict_gets(ctx, dict, "Encoding"); if (encoding) { - if (pdf_is_name(encoding)) - pdf_load_encoding(estrings, pdf_to_name(encoding)); + if (pdf_is_name(ctx, encoding)) + pdf_load_encoding(estrings, pdf_to_name(ctx, encoding)); - if (pdf_is_dict(encoding)) + if (pdf_is_dict(ctx, encoding)) { pdf_obj *base, *diff, *item; - base = pdf_dict_gets(encoding, "BaseEncoding"); - if (pdf_is_name(base)) - pdf_load_encoding(estrings, pdf_to_name(base)); + base = pdf_dict_gets(ctx, encoding, "BaseEncoding"); + if (pdf_is_name(ctx, base)) + pdf_load_encoding(estrings, pdf_to_name(ctx, base)); else if (!fontdesc->is_embedded && !symbolic) pdf_load_encoding(estrings, "StandardEncoding"); - diff = pdf_dict_gets(encoding, "Differences"); - if (pdf_is_array(diff)) + diff = pdf_dict_gets(ctx, encoding, "Differences"); + if (pdf_is_array(ctx, diff)) { - n = pdf_array_len(diff); + n = pdf_array_len(ctx, diff); k = 0; for (i = 0; i < n; i++) { - item = pdf_array_get(diff, i); - if (pdf_is_int(item)) - k = pdf_to_int(item); - if (pdf_is_name(item) && k >= 0 && k < nelem(estrings)) - estrings[k++] = pdf_to_name(item); + item = pdf_array_get(ctx, diff, i); + if (pdf_is_int(ctx, item)) + k = pdf_to_int(ctx, item); + if (pdf_is_name(ctx, item) && k >= 0 && k < nelem(estrings)) + estrings[k++] = pdf_to_name(ctx, item); } } } @@ -575,7 +573,7 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) has_lock = 1; /* built-in and substitute fonts may be a different type than what the document expects */ - subtype = pdf_to_name(pdf_dict_gets(dict, "Subtype")); + subtype = pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "Subtype")); if (!strcmp(subtype, "Type1")) kind = TYPE1; else if (!strcmp(subtype, "MMType1")) @@ -705,7 +703,7 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) fz_try(ctx) { - pdf_load_to_unicode(doc, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode")); + pdf_load_to_unicode(ctx, doc, fontdesc, estrings, NULL, pdf_dict_gets(ctx, dict, "ToUnicode")); } fz_catch(ctx) { @@ -719,20 +717,20 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) pdf_set_default_hmtx(ctx, fontdesc, fontdesc->missing_width); - widths = pdf_dict_gets(dict, "Widths"); + widths = pdf_dict_gets(ctx, dict, "Widths"); if (widths) { int first, last; - first = pdf_to_int(pdf_dict_gets(dict, "FirstChar")); - last = pdf_to_int(pdf_dict_gets(dict, "LastChar")); + first = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "FirstChar")); + last = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "LastChar")); if (first < 0 || last > 255 || first > last) first = last = 0; for (i = 0; i < last - first + 1; i++) { - int wid = pdf_to_int(pdf_array_get(widths, i)); + int wid = pdf_to_int(ctx, pdf_array_get(ctx, widths, i)); pdf_add_hmtx(ctx, fontdesc, i + first, i + first, wid); } } @@ -760,21 +758,21 @@ pdf_load_simple_font_by_name(pdf_document *doc, pdf_obj *dict, char *basefont) if (fontdesc && etable != fontdesc->cid_to_gid) fz_free(ctx, etable); pdf_drop_font(ctx, fontdesc); - fz_rethrow_message(ctx, "cannot load simple font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load simple font (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } return fontdesc; } static pdf_font_desc * -pdf_load_simple_font(pdf_document *doc, pdf_obj *dict) +pdf_load_simple_font(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { - char *basefont = pdf_to_name(pdf_dict_gets(dict, "BaseFont")); + char *basefont = pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "BaseFont")); - return pdf_load_simple_font_by_name(doc, dict, basefont); + return pdf_load_simple_font_by_name(ctx, doc, dict, basefont); } static int -hail_mary_make_hash_key(fz_store_hash *hash, void *key_) +hail_mary_make_hash_key(fz_context *ctx, fz_store_hash *hash, void *key_) { hash->u.i.i0 = 0; hash->u.i.i1 = 0; @@ -794,14 +792,14 @@ hail_mary_drop_key(fz_context *ctx, void *key) } static int -hail_mary_cmp_key(void *k0, void *k1) +hail_mary_cmp_key(fz_context *ctx, void *k0, void *k1) { return k0 == k1; } #ifndef NDEBUG static void -hail_mary_debug_key(FILE *out, void *key_) +hail_mary_debug_key(fz_context *ctx, FILE *out, void *key_) { fprintf(out, "hail mary "); } @@ -819,9 +817,8 @@ static fz_store_type hail_mary_store_type = }; pdf_font_desc * -pdf_load_hail_mary_font(pdf_document *doc) +pdf_load_hail_mary_font(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; pdf_font_desc *fontdesc; pdf_font_desc *existing; @@ -831,7 +828,7 @@ pdf_load_hail_mary_font(pdf_document *doc) } /* FIXME: Get someone with a clue about fonts to fix this */ - fontdesc = pdf_load_simple_font_by_name(doc, NULL, "Helvetica"); + fontdesc = pdf_load_simple_font_by_name(ctx, doc, NULL, "Helvetica"); existing = fz_store_item(ctx, &hail_mary_store_type, fontdesc, fontdesc->size, &hail_mary_store_type); assert(existing == NULL); @@ -844,7 +841,7 @@ pdf_load_hail_mary_font(pdf_document *doc) */ static pdf_font_desc * -load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_unicode) +load_cid_font(fz_context *ctx, pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_unicode) { pdf_obj *widths; pdf_obj *descriptor; @@ -857,7 +854,6 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u pdf_obj *cidtogidmap; pdf_obj *obj; int dw; - fz_context *ctx = doc->ctx; fz_var(fontdesc); @@ -865,46 +861,46 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u { /* Get font name and CID collection */ - basefont = pdf_to_name(pdf_dict_gets(dict, "BaseFont")); + basefont = pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "BaseFont")); { pdf_obj *cidinfo; char tmpstr[64]; int tmplen; - cidinfo = pdf_dict_gets(dict, "CIDSystemInfo"); + cidinfo = pdf_dict_gets(ctx, dict, "CIDSystemInfo"); if (!cidinfo) fz_throw(ctx, FZ_ERROR_GENERIC, "cid font is missing info"); - obj = pdf_dict_gets(cidinfo, "Registry"); - tmplen = fz_mini(sizeof tmpstr - 1, pdf_to_str_len(obj)); - memcpy(tmpstr, pdf_to_str_buf(obj), tmplen); + obj = pdf_dict_gets(ctx, cidinfo, "Registry"); + tmplen = fz_mini(sizeof tmpstr - 1, pdf_to_str_len(ctx, obj)); + memcpy(tmpstr, pdf_to_str_buf(ctx, obj), tmplen); tmpstr[tmplen] = '\0'; fz_strlcpy(collection, tmpstr, sizeof collection); fz_strlcat(collection, "-", sizeof collection); - obj = pdf_dict_gets(cidinfo, "Ordering"); - tmplen = fz_mini(sizeof tmpstr - 1, pdf_to_str_len(obj)); - memcpy(tmpstr, pdf_to_str_buf(obj), tmplen); + obj = pdf_dict_gets(ctx, cidinfo, "Ordering"); + tmplen = fz_mini(sizeof tmpstr - 1, pdf_to_str_len(ctx, obj)); + memcpy(tmpstr, pdf_to_str_buf(ctx, obj), tmplen); tmpstr[tmplen] = '\0'; fz_strlcat(collection, tmpstr, sizeof collection); } /* Encoding */ - if (pdf_is_name(encoding)) + if (pdf_is_name(ctx, encoding)) { - if (!strcmp(pdf_to_name(encoding), "Identity-H")) + if (!strcmp(pdf_to_name(ctx, encoding), "Identity-H")) cmap = pdf_new_identity_cmap(ctx, 0, 2); - else if (!strcmp(pdf_to_name(encoding), "Identity-V")) + else if (!strcmp(pdf_to_name(ctx, encoding), "Identity-V")) cmap = pdf_new_identity_cmap(ctx, 1, 2); else - cmap = pdf_load_system_cmap(ctx, pdf_to_name(encoding)); + cmap = pdf_load_system_cmap(ctx, pdf_to_name(ctx, encoding)); } - else if (pdf_is_indirect(encoding)) + else if (pdf_is_indirect(ctx, encoding)) { - cmap = pdf_load_embedded_cmap(doc, encoding); + cmap = pdf_load_embedded_cmap(ctx, doc, encoding); } else { @@ -920,21 +916,21 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u pdf_set_font_wmode(ctx, fontdesc, pdf_cmap_wmode(ctx, fontdesc->encoding)); - descriptor = pdf_dict_gets(dict, "FontDescriptor"); + descriptor = pdf_dict_gets(ctx, dict, "FontDescriptor"); if (!descriptor) fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: missing font descriptor"); - pdf_load_font_descriptor(fontdesc, doc, descriptor, collection, basefont, 1); + pdf_load_font_descriptor(ctx, doc, fontdesc, descriptor, collection, basefont, 1); face = fontdesc->font->ft_face; /* Apply encoding */ - cidtogidmap = pdf_dict_gets(dict, "CIDToGIDMap"); - if (pdf_is_indirect(cidtogidmap)) + cidtogidmap = pdf_dict_gets(ctx, dict, "CIDToGIDMap"); + if (pdf_is_indirect(ctx, cidtogidmap)) { fz_buffer *buf; - buf = pdf_load_stream(doc, pdf_to_num(cidtogidmap), pdf_to_gen(cidtogidmap)); + buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, cidtogidmap), pdf_to_gen(ctx, cidtogidmap)); fontdesc->cid_to_gid_len = (buf->len) / 2; fontdesc->cid_to_gid = fz_malloc_array(ctx, fontdesc->cid_to_gid_len, sizeof(unsigned short)); @@ -968,7 +964,7 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u fontdesc->to_ttf_cmap = pdf_load_system_cmap(ctx, "Adobe-Korea1-UCS2"); } - pdf_load_to_unicode(doc, fontdesc, NULL, collection, to_unicode); + pdf_load_to_unicode(ctx, doc, fontdesc, NULL, collection, to_unicode); /* If we have an identity encoding, we're supposed to use the glyph ids directly. * If we only have a substitute font, that won't work. @@ -984,35 +980,35 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u /* Horizontal */ dw = 1000; - obj = pdf_dict_gets(dict, "DW"); + obj = pdf_dict_gets(ctx, dict, "DW"); if (obj) - dw = pdf_to_int(obj); + dw = pdf_to_int(ctx, obj); pdf_set_default_hmtx(ctx, fontdesc, dw); - widths = pdf_dict_gets(dict, "W"); + widths = pdf_dict_gets(ctx, dict, "W"); if (widths) { int c0, c1, w, n, m; - n = pdf_array_len(widths); + n = pdf_array_len(ctx, widths); for (i = 0; i < n; ) { - c0 = pdf_to_int(pdf_array_get(widths, i)); - obj = pdf_array_get(widths, i + 1); - if (pdf_is_array(obj)) + c0 = pdf_to_int(ctx, pdf_array_get(ctx, widths, i)); + obj = pdf_array_get(ctx, widths, i + 1); + if (pdf_is_array(ctx, obj)) { - m = pdf_array_len(obj); + m = pdf_array_len(ctx, obj); for (k = 0; k < m; k++) { - w = pdf_to_int(pdf_array_get(obj, k)); + w = pdf_to_int(ctx, pdf_array_get(ctx, obj, k)); pdf_add_hmtx(ctx, fontdesc, c0 + k, c0 + k, w); } i += 2; } else { - c1 = pdf_to_int(obj); - w = pdf_to_int(pdf_array_get(widths, i + 2)); + c1 = pdf_to_int(ctx, obj); + w = pdf_to_int(ctx, pdf_array_get(ctx, widths, i + 2)); pdf_add_hmtx(ctx, fontdesc, c0, c1, w); i += 3; } @@ -1028,43 +1024,43 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u int dw2y = 880; int dw2w = -1000; - obj = pdf_dict_gets(dict, "DW2"); + obj = pdf_dict_gets(ctx, dict, "DW2"); if (obj) { - dw2y = pdf_to_int(pdf_array_get(obj, 0)); - dw2w = pdf_to_int(pdf_array_get(obj, 1)); + dw2y = pdf_to_int(ctx, pdf_array_get(ctx, obj, 0)); + dw2w = pdf_to_int(ctx, pdf_array_get(ctx, obj, 1)); } pdf_set_default_vmtx(ctx, fontdesc, dw2y, dw2w); - widths = pdf_dict_gets(dict, "W2"); + widths = pdf_dict_gets(ctx, dict, "W2"); if (widths) { int c0, c1, w, x, y, n; - n = pdf_array_len(widths); + n = pdf_array_len(ctx, widths); for (i = 0; i < n; ) { - c0 = pdf_to_int(pdf_array_get(widths, i)); - obj = pdf_array_get(widths, i + 1); - if (pdf_is_array(obj)) + c0 = pdf_to_int(ctx, pdf_array_get(ctx, widths, i)); + obj = pdf_array_get(ctx, widths, i + 1); + if (pdf_is_array(ctx, obj)) { - int m = pdf_array_len(obj); + int m = pdf_array_len(ctx, obj); for (k = 0; k * 3 < m; k ++) { - w = pdf_to_int(pdf_array_get(obj, k * 3 + 0)); - x = pdf_to_int(pdf_array_get(obj, k * 3 + 1)); - y = pdf_to_int(pdf_array_get(obj, k * 3 + 2)); + w = pdf_to_int(ctx, pdf_array_get(ctx, obj, k * 3 + 0)); + x = pdf_to_int(ctx, pdf_array_get(ctx, obj, k * 3 + 1)); + y = pdf_to_int(ctx, pdf_array_get(ctx, obj, k * 3 + 2)); pdf_add_vmtx(ctx, fontdesc, c0 + k, c0 + k, x, y, w); } i += 2; } else { - c1 = pdf_to_int(obj); - w = pdf_to_int(pdf_array_get(widths, i + 2)); - x = pdf_to_int(pdf_array_get(widths, i + 3)); - y = pdf_to_int(pdf_array_get(widths, i + 4)); + c1 = pdf_to_int(ctx, obj); + w = pdf_to_int(ctx, pdf_array_get(ctx, widths, i + 2)); + x = pdf_to_int(ctx, pdf_array_get(ctx, widths, i + 3)); + y = pdf_to_int(ctx, pdf_array_get(ctx, widths, i + 4)); pdf_add_vmtx(ctx, fontdesc, c0, c1, x, y, w); i += 5; } @@ -1077,14 +1073,14 @@ load_cid_font(pdf_document *doc, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_u fz_catch(ctx) { pdf_drop_font(ctx, fontdesc); - fz_rethrow_message(ctx, "cannot load cid font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load cid font (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } return fontdesc; } static pdf_font_desc * -pdf_load_type0_font(pdf_document *doc, pdf_obj *dict) +pdf_load_type0_font(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { pdf_obj *dfonts; pdf_obj *dfont; @@ -1092,21 +1088,21 @@ pdf_load_type0_font(pdf_document *doc, pdf_obj *dict) pdf_obj *encoding; pdf_obj *to_unicode; - dfonts = pdf_dict_gets(dict, "DescendantFonts"); + dfonts = pdf_dict_gets(ctx, dict, "DescendantFonts"); if (!dfonts) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cid font is missing descendant fonts"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cid font is missing descendant fonts"); - dfont = pdf_array_get(dfonts, 0); + dfont = pdf_array_get(ctx, dfonts, 0); - subtype = pdf_dict_gets(dfont, "Subtype"); - encoding = pdf_dict_gets(dict, "Encoding"); - to_unicode = pdf_dict_gets(dict, "ToUnicode"); + subtype = pdf_dict_gets(ctx, dfont, "Subtype"); + encoding = pdf_dict_gets(ctx, dict, "Encoding"); + to_unicode = pdf_dict_gets(ctx, dict, "ToUnicode"); - if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType0")) - return load_cid_font(doc, dfont, encoding, to_unicode); - if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType2")) - return load_cid_font(doc, dfont, encoding, to_unicode); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "syntaxerror: unknown cid font type"); + if (pdf_is_name(ctx, subtype) && !strcmp(pdf_to_name(ctx, subtype), "CIDFontType0")) + return load_cid_font(ctx, doc, dfont, encoding, to_unicode); + if (pdf_is_name(ctx, subtype) && !strcmp(pdf_to_name(ctx, subtype), "CIDFontType2")) + return load_cid_font(ctx, doc, dfont, encoding, to_unicode); + fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: unknown cid font type"); } /* @@ -1114,34 +1110,33 @@ pdf_load_type0_font(pdf_document *doc, pdf_obj *dict) */ static void -pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *doc, pdf_obj *dict, char *collection, char *basefont, int iscidfont) +pdf_load_font_descriptor(fz_context *ctx, pdf_document *doc, pdf_font_desc *fontdesc, pdf_obj *dict, char *collection, char *basefont, int iscidfont) { pdf_obj *obj1, *obj2, *obj3, *obj; char *fontname; FT_Face face; - fz_context *ctx = doc->ctx; /* Prefer BaseFont; don't bother with FontName */ fontname = basefont; - fontdesc->flags = pdf_to_int(pdf_dict_gets(dict, "Flags")); - fontdesc->italic_angle = pdf_to_real(pdf_dict_gets(dict, "ItalicAngle")); - fontdesc->ascent = pdf_to_real(pdf_dict_gets(dict, "Ascent")); - fontdesc->descent = pdf_to_real(pdf_dict_gets(dict, "Descent")); - fontdesc->cap_height = pdf_to_real(pdf_dict_gets(dict, "CapHeight")); - fontdesc->x_height = pdf_to_real(pdf_dict_gets(dict, "XHeight")); - fontdesc->missing_width = pdf_to_real(pdf_dict_gets(dict, "MissingWidth")); - - obj1 = pdf_dict_gets(dict, "FontFile"); - obj2 = pdf_dict_gets(dict, "FontFile2"); - obj3 = pdf_dict_gets(dict, "FontFile3"); + fontdesc->flags = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "Flags")); + fontdesc->italic_angle = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "ItalicAngle")); + fontdesc->ascent = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "Ascent")); + fontdesc->descent = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "Descent")); + fontdesc->cap_height = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "CapHeight")); + fontdesc->x_height = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "XHeight")); + fontdesc->missing_width = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "MissingWidth")); + + obj1 = pdf_dict_gets(ctx, dict, "FontFile"); + obj2 = pdf_dict_gets(ctx, dict, "FontFile2"); + obj3 = pdf_dict_gets(ctx, dict, "FontFile3"); obj = obj1 ? obj1 : obj2 ? obj2 : obj3; - if (pdf_is_indirect(obj)) + if (pdf_is_indirect(ctx, obj)) { fz_try(ctx) { - pdf_load_embedded_font(doc, fontdesc, fontname, obj); + pdf_load_embedded_font(ctx, doc, fontdesc, fontname, obj); } fz_catch(ctx) { @@ -1212,12 +1207,11 @@ pdf_make_width_table(fz_context *ctx, pdf_font_desc *fontdesc) } pdf_font_desc * -pdf_load_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, int nested_depth) +pdf_load_font(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, int nested_depth) { char *subtype; pdf_obj *dfonts; pdf_obj *charprocs; - fz_context *ctx = doc->ctx; pdf_font_desc *fontdesc; int type3 = 0; @@ -1226,38 +1220,38 @@ pdf_load_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, int nested_depth) return fontdesc; } - subtype = pdf_to_name(pdf_dict_gets(dict, "Subtype")); - dfonts = pdf_dict_gets(dict, "DescendantFonts"); - charprocs = pdf_dict_gets(dict, "CharProcs"); + subtype = pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "Subtype")); + dfonts = pdf_dict_gets(ctx, dict, "DescendantFonts"); + charprocs = pdf_dict_gets(ctx, dict, "CharProcs"); if (subtype && !strcmp(subtype, "Type0")) - fontdesc = pdf_load_type0_font(doc, dict); + fontdesc = pdf_load_type0_font(ctx, doc, dict); else if (subtype && !strcmp(subtype, "Type1")) - fontdesc = pdf_load_simple_font(doc, dict); + fontdesc = pdf_load_simple_font(ctx, doc, dict); else if (subtype && !strcmp(subtype, "MMType1")) - fontdesc = pdf_load_simple_font(doc, dict); + fontdesc = pdf_load_simple_font(ctx, doc, dict); else if (subtype && !strcmp(subtype, "TrueType")) - fontdesc = pdf_load_simple_font(doc, dict); + fontdesc = pdf_load_simple_font(ctx, doc, dict); else if (subtype && !strcmp(subtype, "Type3")) { - fontdesc = pdf_load_type3_font(doc, rdb, dict); + fontdesc = pdf_load_type3_font(ctx, doc, rdb, dict); type3 = 1; } else if (charprocs) { fz_warn(ctx, "unknown font format, guessing type3."); - fontdesc = pdf_load_type3_font(doc, rdb, dict); + fontdesc = pdf_load_type3_font(ctx, doc, rdb, dict); type3 = 1; } else if (dfonts) { fz_warn(ctx, "unknown font format, guessing type0."); - fontdesc = pdf_load_type0_font(doc, dict); + fontdesc = pdf_load_type0_font(ctx, doc, dict); } else { fz_warn(ctx, "unknown font format, guessing type1 or truetype."); - fontdesc = pdf_load_simple_font(doc, dict); + fontdesc = pdf_load_simple_font(ctx, doc, dict); } /* Save the widths to stretch non-CJK substitute fonts */ @@ -1267,7 +1261,7 @@ pdf_load_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, int nested_depth) pdf_store_item(ctx, dict, fontdesc, fontdesc->size); if (type3) - pdf_load_type3_glyphs(doc, fontdesc, nested_depth); + pdf_load_type3_glyphs(ctx, doc, fontdesc, nested_depth); return fontdesc; } diff --git a/source/pdf/pdf-fontfile.c b/source/pdf/pdf-fontfile.c index cf62108b..86b6682b 100644 --- a/source/pdf/pdf-fontfile.c +++ b/source/pdf/pdf-fontfile.c @@ -26,7 +26,7 @@ #endif unsigned char * -pdf_lookup_builtin_font(const char *name, unsigned int *len) +pdf_lookup_builtin_font(fz_context *ctx, const char *name, unsigned int *len) { if (!strcmp("Courier", name)) { *len = sizeof pdf_font_NimbusMono_Regular; @@ -89,37 +89,37 @@ pdf_lookup_builtin_font(const char *name, unsigned int *len) } unsigned char * -pdf_lookup_substitute_font(int mono, int serif, int bold, int italic, unsigned int *len) +pdf_lookup_substitute_font(fz_context *ctx, int mono, int serif, int bold, int italic, unsigned int *len) { if (mono) { if (bold) { - if (italic) return pdf_lookup_builtin_font("Courier-BoldOblique", len); - else return pdf_lookup_builtin_font("Courier-Bold", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Courier-BoldOblique", len); + else return pdf_lookup_builtin_font(ctx, "Courier-Bold", len); } else { - if (italic) return pdf_lookup_builtin_font("Courier-Oblique", len); - else return pdf_lookup_builtin_font("Courier", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Courier-Oblique", len); + else return pdf_lookup_builtin_font(ctx, "Courier", len); } } else if (serif) { if (bold) { - if (italic) return pdf_lookup_builtin_font("Times-BoldItalic", len); - else return pdf_lookup_builtin_font("Times-Bold", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Times-BoldItalic", len); + else return pdf_lookup_builtin_font(ctx, "Times-Bold", len); } else { - if (italic) return pdf_lookup_builtin_font("Times-Italic", len); - else return pdf_lookup_builtin_font("Times-Roman", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Times-Italic", len); + else return pdf_lookup_builtin_font(ctx, "Times-Roman", len); } } else { if (bold) { - if (italic) return pdf_lookup_builtin_font("Helvetica-BoldOblique", len); - else return pdf_lookup_builtin_font("Helvetica-Bold", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Helvetica-BoldOblique", len); + else return pdf_lookup_builtin_font(ctx, "Helvetica-Bold", len); } else { - if (italic) return pdf_lookup_builtin_font("Helvetica-Oblique", len); - else return pdf_lookup_builtin_font("Helvetica", len); + if (italic) return pdf_lookup_builtin_font(ctx, "Helvetica-Oblique", len); + else return pdf_lookup_builtin_font(ctx, "Helvetica", len); } } } unsigned char * -pdf_lookup_substitute_cjk_font(int ros, int serif, int wmode, unsigned int *len, int *index) +pdf_lookup_substitute_cjk_font(fz_context *ctx, int ros, int serif, int wmode, unsigned int *len, int *index) { #ifndef NOCJKFONT #ifndef NOCJKFULL diff --git a/source/pdf/pdf-form.c b/source/pdf/pdf-form.c index 62e635ca..4caadd25 100644 --- a/source/pdf/pdf-form.c +++ b/source/pdf/pdf-form.c @@ -15,9 +15,9 @@ enum SigFlag_AppendOnly = 2 }; -static int pdf_field_dirties_document(pdf_document *doc, pdf_obj *field) +static int pdf_field_dirties_document(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - int ff = pdf_get_field_flags(doc, field); + int ff = pdf_get_field_flags(ctx, doc, field); if (ff & Ff_NoExport) return 0; if (ff & Ff_ReadOnly) return 0; return 1; @@ -25,33 +25,32 @@ static int pdf_field_dirties_document(pdf_document *doc, pdf_obj *field) /* Find the point in a field hierarchy where all descendents * share the same name */ -static pdf_obj *find_head_of_field_group(pdf_obj *obj) +static pdf_obj *find_head_of_field_group(fz_context *ctx, pdf_obj *obj) { - if (obj == NULL || pdf_dict_gets(obj, "T")) + if (obj == NULL || pdf_dict_gets(ctx, obj, "T")) return obj; else - return find_head_of_field_group(pdf_dict_gets(obj, "Parent")); + return find_head_of_field_group(ctx, pdf_dict_gets(ctx, obj, "Parent")); } -static void pdf_field_mark_dirty(pdf_document *doc, pdf_obj *field) +static void pdf_field_mark_dirty(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - pdf_obj *kids = pdf_dict_gets(field, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); if (kids) { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - pdf_field_mark_dirty(doc, pdf_array_get(kids, i)); + pdf_field_mark_dirty(ctx, doc, pdf_array_get(ctx, kids, i)); } else { - pdf_dirty_obj(field); + pdf_dirty_obj(ctx, field); } } -static void update_field_value(pdf_document *doc, pdf_obj *obj, char *text) +static void update_field_value(fz_context *ctx, pdf_document *doc, pdf_obj *obj, char *text) { - fz_context *ctx = doc->ctx; pdf_obj *sobj = NULL; pdf_obj *grp; @@ -60,40 +59,40 @@ static void update_field_value(pdf_document *doc, pdf_obj *obj, char *text) /* All fields of the same name should be updated, so * set the value at the head of the group */ - grp = find_head_of_field_group(obj); + grp = find_head_of_field_group(ctx, obj); if (grp) obj = grp; fz_var(sobj); fz_try(ctx) { - sobj = pdf_new_string(doc, text, strlen(text)); - pdf_dict_puts(obj, "V", sobj); + sobj = pdf_new_string(ctx, doc, text, strlen(text)); + pdf_dict_puts(ctx, obj, "V", sobj); } fz_always(ctx) { - pdf_drop_obj(sobj); + pdf_drop_obj(ctx, sobj); } fz_catch(ctx) { fz_rethrow(ctx); } - pdf_field_mark_dirty(doc, obj); + pdf_field_mark_dirty(ctx, doc, obj); } -static pdf_obj *find_field(pdf_obj *dict, char *name, int len) +static pdf_obj *find_field(fz_context *ctx, pdf_obj *dict, char *name, int len) { pdf_obj *field; - int i, n = pdf_array_len(dict); + int i, n = pdf_array_len(ctx, dict); for (i = 0; i < n; i++) { char *part; - field = pdf_array_get(dict, i); - part = pdf_to_str_buf(pdf_dict_gets(field, "T")); + field = pdf_array_get(ctx, dict, i); + part = pdf_to_str_buf(ctx, pdf_dict_gets(ctx, field, "T")); if (strlen(part) == (size_t)len && !memcmp(part, name, len)) return field; } @@ -101,7 +100,7 @@ static pdf_obj *find_field(pdf_obj *dict, char *name, int len) return NULL; } -pdf_obj *pdf_lookup_field(pdf_obj *form, char *name) +pdf_obj *pdf_lookup_field(fz_context *ctx, pdf_obj *form, char *name) { char *dot; char *namep; @@ -118,17 +117,16 @@ pdf_obj *pdf_lookup_field(pdf_obj *form, char *name) namep = dot + 1; dot = strchr(namep, '.'); len = dot ? dot - namep : strlen(namep); - dict = find_field(form, namep, len); + dict = find_field(ctx, form, namep, len); if (dot) - form = pdf_dict_gets(dict, "Kids"); + form = pdf_dict_gets(ctx, dict, "Kids"); } return dict; } -static void reset_field(pdf_document *doc, pdf_obj *field) +static void reset_field(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - fz_context *ctx = doc->ctx; /* Set V to DV whereever DV is present, and delete V where DV is not. * FIXME: we assume for now that V has not been set unequal * to DV higher in the hierarchy than "field". @@ -136,13 +134,13 @@ static void reset_field(pdf_document *doc, pdf_obj *field) * At the bottom of the hierarchy we may find widget annotations * that aren't also fields, but DV and V will not be present in their * dictionaries, and attempts to remove V will be harmless. */ - pdf_obj *dv = pdf_dict_gets(field, "DV"); - pdf_obj *kids = pdf_dict_gets(field, "Kids"); + pdf_obj *dv = pdf_dict_gets(ctx, field, "DV"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); if (dv) - pdf_dict_puts(field, "V", dv); + pdf_dict_puts(ctx, field, "V", dv); else - pdf_dict_dels(field, "V"); + pdf_dict_dels(ctx, field, "V"); if (kids == NULL) { @@ -150,25 +148,25 @@ static void reset_field(pdf_document *doc, pdf_obj *field) * In some cases we need to update the appearance state; * in others we need to mark the field as dirty so that * the appearance stream will be regenerated. */ - switch (pdf_field_type(doc, field)) + switch (pdf_field_type(ctx, doc, field)) { case PDF_WIDGET_TYPE_RADIOBUTTON: case PDF_WIDGET_TYPE_CHECKBOX: { - pdf_obj *leafv = pdf_get_inheritable(doc, field, "V"); + pdf_obj *leafv = pdf_get_inheritable(ctx, doc, field, "V"); if (leafv) - pdf_keep_obj(leafv); + pdf_keep_obj(ctx, leafv); else - leafv = pdf_new_name(doc, "Off"); + leafv = pdf_new_name(ctx, doc, "Off"); fz_try(ctx) { - pdf_dict_puts(field, "AS", leafv); + pdf_dict_puts(ctx, field, "AS", leafv); } fz_always(ctx) { - pdf_drop_obj(leafv); + pdf_drop_obj(ctx, leafv); } fz_catch(ctx) { @@ -181,46 +179,46 @@ static void reset_field(pdf_document *doc, pdf_obj *field) break; default: - pdf_field_mark_dirty(doc, field); + pdf_field_mark_dirty(ctx, doc, field); break; } } - if (pdf_field_dirties_document(doc, field)) + if (pdf_field_dirties_document(ctx, doc, field)) doc->dirty = 1; } -void pdf_field_reset(pdf_document *doc, pdf_obj *field) +void pdf_field_reset(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - pdf_obj *kids = pdf_dict_gets(field, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); - reset_field(doc, field); + reset_field(ctx, doc, field); if (kids) { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - pdf_field_reset(doc, pdf_array_get(kids, i)); + pdf_field_reset(ctx, doc, pdf_array_get(ctx, kids, i)); } } -static void add_field_hierarchy_to_array(pdf_obj *array, pdf_obj *field) +static void add_field_hierarchy_to_array(fz_context *ctx, pdf_obj *array, pdf_obj *field) { - pdf_obj *kids = pdf_dict_gets(field, "Kids"); - pdf_obj *exclude = pdf_dict_gets(field, "Exclude"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); + pdf_obj *exclude = pdf_dict_gets(ctx, field, "Exclude"); if (exclude) return; - pdf_array_push(array, field); + pdf_array_push(ctx, array, field); if (kids) { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - add_field_hierarchy_to_array(array, pdf_array_get(kids, i)); + add_field_hierarchy_to_array(ctx, array, pdf_array_get(ctx, kids, i)); } } @@ -231,12 +229,11 @@ static void add_field_hierarchy_to_array(pdf_obj *array, pdf_obj *field) the array. specified_fields interprets this information and produces the array of fields to be acted upon. */ -static pdf_obj *specified_fields(pdf_document *doc, pdf_obj *fields, int exclude) +static pdf_obj *specified_fields(fz_context *ctx, pdf_document *doc, pdf_obj *fields, int exclude) { - fz_context *ctx = doc->ctx; - pdf_obj *form = pdf_dict_getp(pdf_trailer(doc), "Root/AcroForm/Fields"); + pdf_obj *form = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/Fields"); int i, n; - pdf_obj *result = pdf_new_array(doc, 0); + pdf_obj *result = pdf_new_array(ctx, doc, 0); pdf_obj *nil = NULL; fz_var(nil); @@ -247,85 +244,84 @@ static pdf_obj *specified_fields(pdf_document *doc, pdf_obj *fields, int exclude if (exclude || !fields) { /* mark the fields we don't want to act upon */ - nil = pdf_new_null(doc); + nil = pdf_new_null(ctx, doc); - n = pdf_array_len(fields); + n = pdf_array_len(ctx, fields); for (i = 0; i < n; i++) { - pdf_obj *field = pdf_array_get(fields, i); + pdf_obj *field = pdf_array_get(ctx, fields, i); - if (pdf_is_string(field)) - field = pdf_lookup_field(form, pdf_to_str_buf(field)); + if (pdf_is_string(ctx, field)) + field = pdf_lookup_field(ctx, form, pdf_to_str_buf(ctx, field)); if (field) - pdf_dict_puts(field, "Exclude", nil); + pdf_dict_puts(ctx, field, "Exclude", nil); } /* Act upon all unmarked fields */ - n = pdf_array_len(form); + n = pdf_array_len(ctx, form); for (i = 0; i < n; i++) - add_field_hierarchy_to_array(result, pdf_array_get(form, i)); + add_field_hierarchy_to_array(ctx, result, pdf_array_get(ctx, form, i)); /* Unmark the marked fields */ - n = pdf_array_len(fields); + n = pdf_array_len(ctx, fields); for (i = 0; i < n; i++) { - pdf_obj *field = pdf_array_get(fields, i); + pdf_obj *field = pdf_array_get(ctx, fields, i); - if (pdf_is_string(field)) - field = pdf_lookup_field(form, pdf_to_str_buf(field)); + if (pdf_is_string(ctx, field)) + field = pdf_lookup_field(ctx, form, pdf_to_str_buf(ctx, field)); if (field) - pdf_dict_dels(field, "Exclude"); + pdf_dict_dels(ctx, field, "Exclude"); } } else { - n = pdf_array_len(fields); + n = pdf_array_len(ctx, fields); for (i = 0; i < n; i++) { - pdf_obj *field = pdf_array_get(fields, i); + pdf_obj *field = pdf_array_get(ctx, fields, i); - if (pdf_is_string(field)) - field = pdf_lookup_field(form, pdf_to_str_buf(field)); + if (pdf_is_string(ctx, field)) + field = pdf_lookup_field(ctx, form, pdf_to_str_buf(ctx, field)); if (field) - add_field_hierarchy_to_array(result, field); + add_field_hierarchy_to_array(ctx, result, field); } } } fz_always(ctx) { - pdf_drop_obj(nil); + pdf_drop_obj(ctx, nil); } fz_catch(ctx) { - pdf_drop_obj(result); + pdf_drop_obj(ctx, result); fz_rethrow(ctx); } return result; } -static void reset_form(pdf_document *doc, pdf_obj *fields, int exclude) +static void reset_form(fz_context *ctx, pdf_document *doc, pdf_obj *fields, int exclude) { - fz_context *ctx = doc->ctx; - pdf_obj *sfields = specified_fields(doc, fields, exclude); + pdf_obj *sfields = specified_fields(ctx, doc, fields, exclude); fz_try(ctx) { - int i, n = pdf_array_len(sfields); + int i, n = pdf_array_len(ctx, sfields); for (i = 0; i < n; i++) - reset_field(doc, pdf_array_get(sfields, i)); + reset_field(ctx, doc, pdf_array_get(ctx, sfields, i)); } fz_always(ctx) { - pdf_drop_obj(sfields); + pdf_drop_obj(ctx, sfields); } fz_catch(ctx) { @@ -333,19 +329,18 @@ static void reset_form(pdf_document *doc, pdf_obj *fields, int exclude) } } -static void execute_action(pdf_document *doc, pdf_obj *obj, pdf_obj *a) +static void execute_action(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *a) { - fz_context *ctx = doc->ctx; if (a) { - char *type = pdf_to_name(pdf_dict_gets(a, "S")); + char *type = pdf_to_name(ctx, pdf_dict_gets(ctx, a, "S")); if (!strcmp(type, "JavaScript")) { - pdf_obj *js = pdf_dict_gets(a, "JS"); + pdf_obj *js = pdf_dict_gets(ctx, a, "JS"); if (js) { - char *code = pdf_to_utf8(doc, js); + char *code = pdf_to_utf8(ctx, doc, js); fz_try(ctx) { pdf_js_execute(doc->js, code); @@ -362,21 +357,21 @@ static void execute_action(pdf_document *doc, pdf_obj *obj, pdf_obj *a) } else if (!strcmp(type, "ResetForm")) { - reset_form(doc, pdf_dict_gets(a, "Fields"), pdf_to_int(pdf_dict_gets(a, "Flags")) & 1); + reset_form(ctx, doc, pdf_dict_gets(ctx, a, "Fields"), pdf_to_int(ctx, pdf_dict_gets(ctx, a, "Flags")) & 1); } else if (!strcmp(type, "Named")) { - char *name = pdf_to_name(pdf_dict_gets(a, "N")); + char *name = pdf_to_name(ctx, pdf_dict_gets(ctx, a, "N")); if (!strcmp(name, "Print")) - pdf_event_issue_print(doc); + pdf_event_issue_print(ctx, doc); } } } -static void execute_action_chain(pdf_document *doc, pdf_obj *obj) +static void execute_action_chain(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - pdf_obj *a = pdf_dict_gets(obj, "A"); + pdf_obj *a = pdf_dict_gets(ctx, obj, "A"); pdf_js_event e; e.target = obj; @@ -385,14 +380,14 @@ static void execute_action_chain(pdf_document *doc, pdf_obj *obj) while (a) { - execute_action(doc, obj, a); - a = pdf_dict_gets(a, "Next"); + execute_action(ctx, doc, obj, a); + a = pdf_dict_gets(ctx, a, "Next"); } } -static void execute_additional_action(pdf_document *doc, pdf_obj *obj, char *act) +static void execute_additional_action(fz_context *ctx, pdf_document *doc, pdf_obj *obj, char *act) { - pdf_obj *a = pdf_dict_getp(obj, act); + pdf_obj *a = pdf_dict_getp(ctx, obj, act); if (a) { @@ -401,24 +396,23 @@ static void execute_additional_action(pdf_document *doc, pdf_obj *obj, char *act e.target = obj; e.value = ""; pdf_js_setup_event(doc->js, &e); - execute_action(doc, obj, a); + execute_action(ctx, doc, obj, a); } } -static void check_off(pdf_document *doc, pdf_obj *obj) +static void check_off(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; pdf_obj *off = NULL; fz_var(off); fz_try(ctx); { - off = pdf_new_name(doc, "Off"); - pdf_dict_puts(obj, "AS", off); + off = pdf_new_name(ctx, doc, "Off"); + pdf_dict_puts(ctx, obj, "AS", off); } fz_always(ctx) { - pdf_drop_obj(off); + pdf_drop_obj(ctx, off); } fz_catch(ctx) { @@ -426,27 +420,26 @@ static void check_off(pdf_document *doc, pdf_obj *obj) } } -static void set_check(pdf_document *doc, pdf_obj *chk, char *name) +static void set_check(fz_context *ctx, pdf_document *doc, pdf_obj *chk, char *name) { - pdf_obj *n = pdf_dict_getp(chk, "AP/N"); + pdf_obj *n = pdf_dict_getp(ctx, chk, "AP/N"); pdf_obj *val = NULL; - fz_context *ctx = doc->ctx; fz_var(val); fz_try(ctx) { /* If name is a possible value of this check * box then use it, otherwise use "Off" */ - if (pdf_dict_gets(n, name)) - val = pdf_new_name(doc, name); + if (pdf_dict_gets(ctx, n, name)) + val = pdf_new_name(ctx, doc, name); else - val = pdf_new_name(doc, "Off"); + val = pdf_new_name(ctx, doc, "Off"); - pdf_dict_puts(chk, "AS", val); + pdf_dict_puts(ctx, chk, "AS", val); } fz_always(ctx) { - pdf_drop_obj(val); + pdf_drop_obj(ctx, val); } fz_catch(ctx) { @@ -456,55 +449,53 @@ static void set_check(pdf_document *doc, pdf_obj *chk, char *name) /* Set the values of all fields in a group defined by a node * in the hierarchy */ -static void set_check_grp(pdf_document *doc, pdf_obj *grp, char *val) +static void set_check_grp(fz_context *ctx, pdf_document *doc, pdf_obj *grp, char *val) { - pdf_obj *kids = pdf_dict_gets(grp, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, grp, "Kids"); if (kids == NULL) { - set_check(doc, grp, val); + set_check(ctx, doc, grp, val); } else { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - set_check_grp(doc, pdf_array_get(kids, i), val); + set_check_grp(ctx, doc, pdf_array_get(ctx, kids, i), val); } } -static void recalculate(pdf_document *doc) +static void recalculate(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; - if (doc->recalculating) return; doc->recalculating = 1; fz_try(ctx) { - pdf_obj *co = pdf_dict_getp(pdf_trailer(doc), "Root/AcroForm/CO"); + pdf_obj *co = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/CO"); if (co && doc->js) { - int i, n = pdf_array_len(co); + int i, n = pdf_array_len(ctx, co); for (i = 0; i < n; i++) { - pdf_obj *field = pdf_array_get(co, i); - pdf_obj *calc = pdf_dict_getp(field, "AA/C"); + pdf_obj *field = pdf_array_get(ctx, co, i); + pdf_obj *calc = pdf_dict_getp(ctx, field, "AA/C"); if (calc) { pdf_js_event e; e.target = field; - e.value = pdf_field_value(doc, field); + e.value = pdf_field_value(ctx, doc, field); pdf_js_setup_event(doc->js, &e); - execute_action(doc, field, calc); + execute_action(ctx, doc, field, calc); /* A calculate action, updates event.value. We need * to place the value in the field */ - update_field_value(doc, field, pdf_js_get_event(doc->js)->value); + update_field_value(ctx, doc, field, pdf_js_get_event(doc->js)->value); } } } @@ -519,25 +510,24 @@ static void recalculate(pdf_document *doc) } } -static void toggle_check_box(pdf_document *doc, pdf_obj *obj) +static void toggle_check_box(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; - pdf_obj *as = pdf_dict_gets(obj, "AS"); - int ff = pdf_get_field_flags(doc, obj); + pdf_obj *as = pdf_dict_gets(ctx, obj, "AS"); + int ff = pdf_get_field_flags(ctx, doc, obj); int radio = ((ff & (Ff_Pushbutton|Ff_Radio)) == Ff_Radio); char *val = NULL; - pdf_obj *grp = radio ? pdf_dict_gets(obj, "Parent") : find_head_of_field_group(obj); + pdf_obj *grp = radio ? pdf_dict_gets(ctx, obj, "Parent") : find_head_of_field_group(ctx, obj); if (!grp) grp = obj; - if (as && strcmp(pdf_to_name(as), "Off")) + if (as && strcmp(pdf_to_name(ctx, as), "Off")) { /* "as" neither missing nor set to Off. Set it to Off, unless * this is a non-toggle-off radio button. */ if ((ff & (Ff_Pushbutton|Ff_NoToggleToOff|Ff_Radio)) != (Ff_NoToggleToOff|Ff_Radio)) { - check_off(doc, obj); + check_off(ctx, doc, obj); val = "Off"; } } @@ -546,14 +536,14 @@ static void toggle_check_box(pdf_document *doc, pdf_obj *obj) pdf_obj *n, *key = NULL; int len, i; - n = pdf_dict_getp(obj, "AP/N"); + n = pdf_dict_getp(ctx, obj, "AP/N"); /* Look for a key that isn't "Off" */ - len = pdf_dict_len(n); + len = pdf_dict_len(ctx, n); for (i = 0; i < len; i++) { - key = pdf_dict_get_key(n, i); - if (pdf_is_name(key) && strcmp(pdf_to_name(key), "Off")) + key = pdf_dict_get_key(ctx, n, i); + if (pdf_is_name(ctx, key) && strcmp(pdf_to_name(ctx, key), "Off")) break; } @@ -561,19 +551,19 @@ static void toggle_check_box(pdf_document *doc, pdf_obj *obj) if (!key) return; - val = pdf_to_name(key); + val = pdf_to_name(ctx, key); if (radio) { /* For radio buttons, first turn off all buttons in the group and * then set the one that was clicked */ - pdf_obj *kids = pdf_dict_gets(grp, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, grp, "Kids"); - len = pdf_array_len(kids); + len = pdf_array_len(ctx, kids); for (i = 0; i < len; i++) - check_off(doc, pdf_array_get(kids, i)); + check_off(ctx, doc, pdf_array_get(ctx, kids, i)); - pdf_dict_puts(obj, "AS", key); + pdf_dict_puts(ctx, obj, "AS", key); } else { @@ -582,9 +572,9 @@ static void toggle_check_box(pdf_document *doc, pdf_obj *obj) * all to the same value. This may cause the group to act like * radio buttons, if each have distinct "On" values */ if (grp) - set_check_grp(doc, grp, val); + set_check_grp(ctx, doc, grp, val); else - set_check(doc, obj, val); + set_check(ctx, doc, obj, val); } } @@ -595,28 +585,28 @@ static void toggle_check_box(pdf_document *doc, pdf_obj *obj) fz_var(v); fz_try(ctx) { - v = pdf_new_string(doc, val, strlen(val)); - pdf_dict_puts(grp, "V", v); + v = pdf_new_string(ctx, doc, val, strlen(val)); + pdf_dict_puts(ctx, grp, "V", v); } fz_always(ctx) { - pdf_drop_obj(v); + pdf_drop_obj(ctx, v); } fz_catch(ctx) { fz_rethrow(ctx); } - recalculate(doc); + recalculate(ctx, doc); } } -int pdf_has_unsaved_changes(pdf_document *doc) +int pdf_has_unsaved_changes(fz_context *ctx, pdf_document *doc) { return doc->dirty; } -int pdf_pass_event(pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) +int pdf_pass_event(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) { pdf_annot *annot; pdf_hotspot *hp = &doc->hotspot; @@ -635,7 +625,7 @@ int pdf_pass_event(pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) if (annot) { - int f = pdf_to_int(pdf_dict_gets(annot->obj, "F")); + int f = pdf_to_int(ctx, pdf_dict_gets(ctx, annot->obj, "F")); if (f & (F_Hidden|F_NoView)) annot = NULL; @@ -651,24 +641,24 @@ int pdf_pass_event(pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) if (doc->focus_obj) { /* Execute the blur action */ - execute_additional_action(doc, doc->focus_obj, "AA/Bl"); + execute_additional_action(ctx, doc, doc->focus_obj, "AA/Bl"); doc->focus = NULL; - pdf_drop_obj(doc->focus_obj); + pdf_drop_obj(ctx, doc->focus_obj); doc->focus_obj = NULL; } if (annot) { doc->focus = annot; - doc->focus_obj = pdf_keep_obj(annot->obj); + doc->focus_obj = pdf_keep_obj(ctx, annot->obj); - hp->num = pdf_to_num(annot->obj); - hp->gen = pdf_to_gen(annot->obj); + hp->num = pdf_to_num(ctx, annot->obj); + hp->gen = pdf_to_gen(ctx, annot->obj); hp->state = HOTSPOT_POINTER_DOWN; changed = 1; /* Exectute the down and focus actions */ - execute_additional_action(doc, annot->obj, "AA/Fo"); - execute_additional_action(doc, annot->obj, "AA/D"); + execute_additional_action(ctx, doc, annot->obj, "AA/Fo"); + execute_additional_action(ctx, doc, annot->obj, "AA/D"); } break; @@ -687,15 +677,15 @@ int pdf_pass_event(pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) case PDF_WIDGET_TYPE_RADIOBUTTON: case PDF_WIDGET_TYPE_CHECKBOX: /* FIXME: treating radio buttons like check boxes, for now */ - toggle_check_box(doc, annot->obj); + toggle_check_box(ctx, doc, annot->obj); changed = 1; break; } /* Execute the up action */ - execute_additional_action(doc, annot->obj, "AA/U"); + execute_additional_action(ctx, doc, annot->obj, "AA/U"); /* Execute the main action chain */ - execute_action_chain(doc, annot->obj); + execute_action_chain(ctx, doc, annot->obj); } break; } @@ -706,9 +696,8 @@ int pdf_pass_event(pdf_document *doc, pdf_page *page, pdf_ui_event *ui_event) return changed; } -void pdf_update_page(pdf_document *doc, pdf_page *page) +void pdf_update_page(fz_context *ctx, pdf_document *doc, pdf_page *page) { - fz_context *ctx = doc->ctx; pdf_annot *annot; /* Reset changed_annots to empty */ @@ -732,7 +721,7 @@ void pdf_update_page(pdf_document *doc, pdf_page *page) fz_try(ctx) { - pdf_update_annot(doc, annot); + pdf_update_annot(ctx, doc, annot); if ((ap != annot->ap || ap_iteration != annot->ap_iteration)) { @@ -769,7 +758,7 @@ void pdf_update_page(pdf_document *doc, pdf_page *page) page->deleted_annots = NULL; } -pdf_annot *pdf_poll_changed_annot(pdf_document *idoc, pdf_page *page) +pdf_annot *pdf_poll_changed_annot(fz_context *ctx, pdf_document *idoc, pdf_page *page) { pdf_annot *annot = page->changed_annots; @@ -779,12 +768,12 @@ pdf_annot *pdf_poll_changed_annot(pdf_document *idoc, pdf_page *page) return annot; } -pdf_widget *pdf_focused_widget(pdf_document *doc) +pdf_widget *pdf_focused_widget(fz_context *ctx, pdf_document *doc) { return (pdf_widget *)doc->focus; } -pdf_widget *pdf_first_widget(pdf_document *doc, pdf_page *page) +pdf_widget *pdf_first_widget(fz_context *ctx, pdf_document *doc, pdf_page *page) { pdf_annot *annot = page->annots; @@ -794,7 +783,7 @@ pdf_widget *pdf_first_widget(pdf_document *doc, pdf_page *page) return (pdf_widget *)annot; } -pdf_widget *pdf_next_widget(pdf_widget *previous) +pdf_widget *pdf_next_widget(fz_context *ctx, pdf_widget *previous) { pdf_annot *annot = (pdf_annot *)previous; @@ -807,46 +796,45 @@ pdf_widget *pdf_next_widget(pdf_widget *previous) return (pdf_widget *)annot; } -pdf_widget *pdf_create_widget(pdf_document *doc, pdf_page *page, int type, char *fieldname) +pdf_widget *pdf_create_widget(fz_context *ctx, pdf_document *doc, pdf_page *page, int type, char *fieldname) { - fz_context *ctx = doc->ctx; pdf_obj *form = NULL; - int old_sigflags = pdf_to_int(pdf_dict_getp(pdf_trailer(doc), "Root/AcroForm/SigFlags")); - pdf_annot *annot = pdf_create_annot(doc, page, FZ_ANNOT_WIDGET); + int old_sigflags = pdf_to_int(ctx, pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/SigFlags")); + pdf_annot *annot = pdf_create_annot(ctx, doc, page, FZ_ANNOT_WIDGET); fz_try(ctx) { - pdf_set_field_type(doc, annot->obj, type); - pdf_dict_puts_drop(annot->obj, "T", pdf_new_string(doc, fieldname, strlen(fieldname))); + pdf_set_field_type(ctx, doc, annot->obj, type); + pdf_dict_puts_drop(ctx, annot->obj, "T", pdf_new_string(ctx, doc, fieldname, strlen(fieldname))); annot->widget_type = type; if (type == PDF_WIDGET_TYPE_SIGNATURE) { int sigflags = (old_sigflags | (SigFlag_SignaturesExist|SigFlag_AppendOnly)); - pdf_dict_putp_drop(pdf_trailer(doc), "Root/AcroForm/SigFlags", pdf_new_int(doc, sigflags)); + pdf_dict_putp_drop(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/SigFlags", pdf_new_int(ctx, doc, sigflags)); } /* pdf_create_annot will have linked the new widget into the page's annot array. We also need it linked into the document's form */ - form = pdf_dict_getp(pdf_trailer(doc), "Root/AcroForm/Fields"); + form = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/Fields"); if (!form) { - form = pdf_new_array(doc, 1); - pdf_dict_putp_drop(pdf_trailer(doc), "Root/AcroForm/Fields", form); + form = pdf_new_array(ctx, doc, 1); + pdf_dict_putp_drop(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/Fields", form); } - pdf_array_push(form, annot->obj); /* Cleanup relies on this statement being last */ + pdf_array_push(ctx, form, annot->obj); /* Cleanup relies on this statement being last */ } fz_catch(ctx) { - pdf_delete_annot(doc, page, annot); + pdf_delete_annot(ctx, doc, page, annot); /* An empty Fields array may have been created, but that is harmless */ if (type == PDF_WIDGET_TYPE_SIGNATURE) - pdf_dict_putp_drop(pdf_trailer(doc), "Root/AcroForm/SigFlags", pdf_new_int(doc, old_sigflags)); + pdf_dict_putp_drop(ctx, pdf_trailer(ctx, doc), "Root/AcroForm/SigFlags", pdf_new_int(ctx, doc, old_sigflags)); fz_rethrow(ctx); } @@ -854,15 +842,15 @@ pdf_widget *pdf_create_widget(pdf_document *doc, pdf_page *page, int type, char return (pdf_widget *)annot; } -int pdf_widget_get_type(pdf_widget *widget) +int pdf_widget_get_type(fz_context *ctx, pdf_widget *widget) { pdf_annot *annot = (pdf_annot *)widget; return annot->widget_type; } -static int set_text_field_value(pdf_document *doc, pdf_obj *field, char *text) +static int set_text_field_value(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *text) { - pdf_obj *v = pdf_dict_getp(field, "AA/V"); + pdf_obj *v = pdf_dict_getp(ctx, field, "AA/V"); if (v && doc->js) { @@ -871,7 +859,7 @@ static int set_text_field_value(pdf_document *doc, pdf_obj *field, char *text) e.target = field; e.value = text; pdf_js_setup_event(doc->js, &e); - execute_action(doc, field, v); + execute_action(ctx, doc, field, v); if (!pdf_js_get_event(doc->js)->rc) return 0; @@ -879,43 +867,42 @@ static int set_text_field_value(pdf_document *doc, pdf_obj *field, char *text) text = pdf_js_get_event(doc->js)->value; } - if (pdf_field_dirties_document(doc, field)) + if (pdf_field_dirties_document(ctx, doc, field)) doc->dirty = 1; - update_field_value(doc, field, text); + update_field_value(ctx, doc, field, text); return 1; } -static void update_checkbox_selector(pdf_document *doc, pdf_obj *field, char *val) +static void update_checkbox_selector(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *val) { - fz_context *ctx = doc->ctx; - pdf_obj *kids = pdf_dict_gets(field, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); if (kids) { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - update_checkbox_selector(doc, pdf_array_get(kids, i), val); + update_checkbox_selector(ctx, doc, pdf_array_get(ctx, kids, i), val); } else { - pdf_obj *n = pdf_dict_getp(field, "AP/N"); + pdf_obj *n = pdf_dict_getp(ctx, field, "AP/N"); pdf_obj *oval = NULL; fz_var(oval); fz_try(ctx) { - if (pdf_dict_gets(n, val)) - oval = pdf_new_name(doc, val); + if (pdf_dict_gets(ctx, n, val)) + oval = pdf_new_name(ctx, doc, val); else - oval = pdf_new_name(doc, "Off"); + oval = pdf_new_name(ctx, doc, "Off"); - pdf_dict_puts(field, "AS", oval); + pdf_dict_puts(ctx, field, "AS", oval); } fz_always(ctx) { - pdf_drop_obj(oval); + pdf_drop_obj(ctx, oval); } fz_catch(ctx) { @@ -924,43 +911,43 @@ static void update_checkbox_selector(pdf_document *doc, pdf_obj *field, char *va } } -static int set_checkbox_value(pdf_document *doc, pdf_obj *field, char *val) +static int set_checkbox_value(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *val) { - update_checkbox_selector(doc, field, val); - update_field_value(doc, field, val); + update_checkbox_selector(ctx, doc, field, val); + update_field_value(ctx, doc, field, val); return 1; } -int pdf_field_set_value(pdf_document *doc, pdf_obj *field, char *text) +int pdf_field_set_value(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *text) { int res = 0; - switch (pdf_field_type(doc, field)) + switch (pdf_field_type(ctx, doc, field)) { case PDF_WIDGET_TYPE_TEXT: - res = set_text_field_value(doc, field, text); + res = set_text_field_value(ctx, doc, field, text); break; case PDF_WIDGET_TYPE_CHECKBOX: case PDF_WIDGET_TYPE_RADIOBUTTON: - res = set_checkbox_value(doc, field, text); + res = set_checkbox_value(ctx, doc, field, text); break; default: /* text updater will do in most cases */ - update_field_value(doc, field, text); + update_field_value(ctx, doc, field, text); res = 1; break; } - recalculate(doc); + recalculate(ctx, doc); return res; } -char *pdf_field_border_style(pdf_document *doc, pdf_obj *field) +char *pdf_field_border_style(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - char *bs = pdf_to_name(pdf_dict_getp(field, "BS/S")); + char *bs = pdf_to_name(ctx, pdf_dict_getp(ctx, field, "BS/S")); switch (*bs) { @@ -974,32 +961,31 @@ char *pdf_field_border_style(pdf_document *doc, pdf_obj *field) return "Solid"; } -void pdf_field_set_border_style(pdf_document *doc, pdf_obj *field, char *text) +void pdf_field_set_border_style(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *text) { - fz_context *ctx = doc->ctx; pdf_obj *val = NULL; if (!strcmp(text, "Solid")) - val = pdf_new_name(doc, "S"); + val = pdf_new_name(ctx, doc, "S"); else if (!strcmp(text, "Dashed")) - val = pdf_new_name(doc, "D"); + val = pdf_new_name(ctx, doc, "D"); else if (!strcmp(text, "Beveled")) - val = pdf_new_name(doc, "B"); + val = pdf_new_name(ctx, doc, "B"); else if (!strcmp(text, "Inset")) - val = pdf_new_name(doc, "I"); + val = pdf_new_name(ctx, doc, "I"); else if (!strcmp(text, "Underline")) - val = pdf_new_name(doc, "U"); + val = pdf_new_name(ctx, doc, "U"); else return; fz_try(ctx); { - pdf_dict_putp(field, "BS/S", val); - pdf_field_mark_dirty(doc, field); + pdf_dict_putp(ctx, field, "BS/S", val); + pdf_field_mark_dirty(ctx, doc, field); } fz_always(ctx) { - pdf_drop_obj(val); + pdf_drop_obj(ctx, val); } fz_catch(ctx) { @@ -1007,22 +993,21 @@ void pdf_field_set_border_style(pdf_document *doc, pdf_obj *field, char *text) } } -void pdf_field_set_button_caption(pdf_document *doc, pdf_obj *field, char *text) +void pdf_field_set_button_caption(fz_context *ctx, pdf_document *doc, pdf_obj *field, char *text) { - fz_context *ctx = doc->ctx; - pdf_obj *val = pdf_new_string(doc, text, strlen(text)); + pdf_obj *val = pdf_new_string(ctx, doc, text, strlen(text)); fz_try(ctx); { - if (pdf_field_type(doc, field) == PDF_WIDGET_TYPE_PUSHBUTTON) + if (pdf_field_type(ctx, doc, field) == PDF_WIDGET_TYPE_PUSHBUTTON) { - pdf_dict_putp(field, "MK/CA", val); - pdf_field_mark_dirty(doc, field); + pdf_dict_putp(ctx, field, "MK/CA", val); + pdf_field_mark_dirty(ctx, doc, field); } } fz_always(ctx) { - pdf_drop_obj(val); + pdf_drop_obj(ctx, val); } fz_catch(ctx) { @@ -1030,7 +1015,7 @@ void pdf_field_set_button_caption(pdf_document *doc, pdf_obj *field, char *text) } } -int pdf_field_display(pdf_document *doc, pdf_obj *field) +int pdf_field_display(fz_context *ctx, pdf_document *doc, pdf_obj *field) { pdf_obj *kids; int f, res = Display_Visible; @@ -1038,10 +1023,10 @@ int pdf_field_display(pdf_document *doc, pdf_obj *field) /* Base response on first of children. Not ideal, * but not clear how to handle children with * differing values */ - while ((kids = pdf_dict_gets(field, "Kids")) != NULL) - field = pdf_array_get(kids, 0); + while ((kids = pdf_dict_gets(ctx, field, "Kids")) != NULL) + field = pdf_array_get(ctx, kids, 0); - f = pdf_to_int(pdf_dict_gets(field, "F")); + f = pdf_to_int(ctx, pdf_dict_gets(ctx, field, "F")); if (f & F_Hidden) { @@ -1067,12 +1052,11 @@ int pdf_field_display(pdf_document *doc, pdf_obj *field) * get the field name in a char buffer that has spare room to * add more characters at the end. */ -static char *get_field_name(pdf_document *doc, pdf_obj *field, int spare) +static char *get_field_name(fz_context *ctx, pdf_document *doc, pdf_obj *field, int spare) { - fz_context *ctx = doc->ctx; char *res = NULL; - pdf_obj *parent = pdf_dict_gets(field, "Parent"); - char *lname = pdf_to_str_buf(pdf_dict_gets(field, "T")); + pdf_obj *parent = pdf_dict_gets(ctx, field, "Parent"); + char *lname = pdf_to_str_buf(ctx, pdf_dict_gets(ctx, field, "T")); int llen = strlen(lname); /* @@ -1084,7 +1068,7 @@ static char *get_field_name(pdf_document *doc, pdf_obj *field, int spare) if (parent) { - res = get_field_name(doc, parent, spare); + res = get_field_name(ctx, doc, parent, spare); } else { @@ -1103,20 +1087,19 @@ static char *get_field_name(pdf_document *doc, pdf_obj *field, int spare) return res; } -char *pdf_field_name(pdf_document *doc, pdf_obj *field) +char *pdf_field_name(fz_context *ctx, pdf_document *doc, pdf_obj *field) { - return get_field_name(doc, field, 0); + return get_field_name(ctx, doc, field, 0); } -void pdf_field_set_display(pdf_document *doc, pdf_obj *field, int d) +void pdf_field_set_display(fz_context *ctx, pdf_document *doc, pdf_obj *field, int d) { - fz_context *ctx = doc->ctx; - pdf_obj *kids = pdf_dict_gets(field, "Kids"); + pdf_obj *kids = pdf_dict_gets(ctx, field, "Kids"); if (!kids) { int mask = (F_Hidden|F_Print|F_NoView); - int f = pdf_to_int(pdf_dict_gets(field, "F")) & ~mask; + int f = pdf_to_int(ctx, pdf_dict_gets(ctx, field, "F")) & ~mask; pdf_obj *fo = NULL; switch (d) @@ -1137,12 +1120,12 @@ void pdf_field_set_display(pdf_document *doc, pdf_obj *field, int d) fz_var(fo); fz_try(ctx) { - fo = pdf_new_int(doc, f); - pdf_dict_puts(field, "F", fo); + fo = pdf_new_int(ctx, doc, f); + pdf_dict_puts(ctx, field, "F", fo); } fz_always(ctx) { - pdf_drop_obj(fo); + pdf_drop_obj(ctx, fo); } fz_catch(ctx) { @@ -1151,28 +1134,27 @@ void pdf_field_set_display(pdf_document *doc, pdf_obj *field, int d) } else { - int i, n = pdf_array_len(kids); + int i, n = pdf_array_len(ctx, kids); for (i = 0; i < n; i++) - pdf_field_set_display(doc, pdf_array_get(kids, i), d); + pdf_field_set_display(ctx, doc, pdf_array_get(ctx, kids, i), d); } } -void pdf_field_set_fill_color(pdf_document *doc, pdf_obj *field, pdf_obj *col) +void pdf_field_set_fill_color(fz_context *ctx, pdf_document *doc, pdf_obj *field, pdf_obj *col) { /* col == NULL mean transparent, but we can simply pass it on as with * non-NULL values because pdf_dict_putp interprets a NULL value as * delete */ - pdf_dict_putp(field, "MK/BG", col); - pdf_field_mark_dirty(doc, field); + pdf_dict_putp(ctx, field, "MK/BG", col); + pdf_field_mark_dirty(ctx, doc, field); } -void pdf_field_set_text_color(pdf_document *doc, pdf_obj *field, pdf_obj *col) +void pdf_field_set_text_color(fz_context *ctx, pdf_document *doc, pdf_obj *field, pdf_obj *col) { - fz_context *ctx = doc->ctx; pdf_da_info di; fz_buffer *fzbuf = NULL; - char *da = pdf_to_str_buf(pdf_get_inheritable(doc, field, "DA")); + char *da = pdf_to_str_buf(ctx, pdf_get_inheritable(ctx, doc, field, "DA")); unsigned char *buf; int len; pdf_obj *daobj = NULL; @@ -1187,24 +1169,24 @@ void pdf_field_set_text_color(pdf_document *doc, pdf_obj *field, pdf_obj *col) int i; pdf_parse_da(ctx, da, &di); - di.col_size = pdf_array_len(col); + di.col_size = pdf_array_len(ctx, col); len = fz_mini(di.col_size, nelem(di.col)); for (i = 0; i < len; i++) - di.col[i] = pdf_to_real(pdf_array_get(col, i)); + di.col[i] = pdf_to_real(ctx, pdf_array_get(ctx, col, i)); fzbuf = fz_new_buffer(ctx, 0); pdf_fzbuf_print_da(ctx, fzbuf, &di); len = fz_buffer_storage(ctx, fzbuf, &buf); - daobj = pdf_new_string(doc, (char *)buf, len); - pdf_dict_puts(field, "DA", daobj); - pdf_field_mark_dirty(doc, field); + daobj = pdf_new_string(ctx, doc, (char *)buf, len); + pdf_dict_puts(ctx, field, "DA", daobj); + pdf_field_mark_dirty(ctx, doc, field); } fz_always(ctx) { pdf_da_info_fin(ctx, &di); fz_drop_buffer(ctx, fzbuf); - pdf_drop_obj(daobj); + pdf_drop_obj(ctx, daobj); } fz_catch(ctx) { @@ -1212,7 +1194,7 @@ void pdf_field_set_text_color(pdf_document *doc, pdf_obj *field, pdf_obj *col) } } -fz_rect *pdf_bound_widget(pdf_widget *widget, fz_rect *rect) +fz_rect *pdf_bound_widget(fz_context *ctx, pdf_widget *widget, fz_rect *rect) { pdf_annot *annot = (pdf_annot *)widget; @@ -1223,16 +1205,15 @@ fz_rect *pdf_bound_widget(pdf_widget *widget, fz_rect *rect) return rect; } -char *pdf_text_widget_text(pdf_document *doc, pdf_widget *tw) +char *pdf_text_widget_text(fz_context *ctx, pdf_document *doc, pdf_widget *tw) { pdf_annot *annot = (pdf_annot *)tw; - fz_context *ctx = doc->ctx; char *text = NULL; fz_var(text); fz_try(ctx) { - text = pdf_field_value(doc, annot->obj); + text = pdf_field_value(ctx, doc, annot->obj); } fz_catch(ctx) { @@ -1242,24 +1223,23 @@ char *pdf_text_widget_text(pdf_document *doc, pdf_widget *tw) return text; } -int pdf_text_widget_max_len(pdf_document *doc, pdf_widget *tw) +int pdf_text_widget_max_len(fz_context *ctx, pdf_document *doc, pdf_widget *tw) { pdf_annot *annot = (pdf_annot *)tw; - return pdf_to_int(pdf_get_inheritable(doc, annot->obj, "MaxLen")); + return pdf_to_int(ctx, pdf_get_inheritable(ctx, doc, annot->obj, "MaxLen")); } -int pdf_text_widget_content_type(pdf_document *doc, pdf_widget *tw) +int pdf_text_widget_content_type(fz_context *ctx, pdf_document *doc, pdf_widget *tw) { pdf_annot *annot = (pdf_annot *)tw; - fz_context *ctx = doc->ctx; char *code = NULL; int type = PDF_WIDGET_CONTENT_UNRESTRAINED; fz_var(code); fz_try(ctx) { - code = pdf_get_string_or_stream(doc, pdf_dict_getp(annot->obj, "AA/F/JS")); + code = pdf_get_string_or_stream(ctx, doc, pdf_dict_getp(ctx, annot->obj, "AA/F/JS")); if (code) { if (strstr(code, "AFNumber_Format")) @@ -1284,9 +1264,9 @@ int pdf_text_widget_content_type(pdf_document *doc, pdf_widget *tw) return type; } -static int run_keystroke(pdf_document *doc, pdf_obj *field, char **text) +static int run_keystroke(fz_context *ctx, pdf_document *doc, pdf_obj *field, char **text) { - pdf_obj *k = pdf_dict_getp(field, "AA/K"); + pdf_obj *k = pdf_dict_getp(ctx, field, "AA/K"); if (k && doc->js) { @@ -1295,7 +1275,7 @@ static int run_keystroke(pdf_document *doc, pdf_obj *field, char **text) e.target = field; e.value = *text; pdf_js_setup_event(doc->js, &e); - execute_action(doc, field, k); + execute_action(ctx, doc, field, k); if (!pdf_js_get_event(doc->js)->rc) return 0; @@ -1306,17 +1286,16 @@ static int run_keystroke(pdf_document *doc, pdf_obj *field, char **text) return 1; } -int pdf_text_widget_set_text(pdf_document *doc, pdf_widget *tw, char *text) +int pdf_text_widget_set_text(fz_context *ctx, pdf_document *doc, pdf_widget *tw, char *text) { pdf_annot *annot = (pdf_annot *)tw; - fz_context *ctx = doc->ctx; int accepted = 0; fz_try(ctx) { - accepted = run_keystroke(doc, annot->obj, &text); + accepted = run_keystroke(ctx, doc, annot->obj, &text); if (accepted) - accepted = pdf_field_set_value(doc, annot->obj, text); + accepted = pdf_field_set_value(ctx, doc, annot->obj, text); } fz_catch(ctx) { @@ -1326,7 +1305,7 @@ int pdf_text_widget_set_text(pdf_document *doc, pdf_widget *tw, char *text) return accepted; } -int pdf_choice_widget_options(pdf_document *doc, pdf_widget *tw, char *opts[]) +int pdf_choice_widget_options(fz_context *ctx, pdf_document *doc, pdf_widget *tw, char *opts[]) { pdf_annot *annot = (pdf_annot *)tw; pdf_obj *optarr; @@ -1335,37 +1314,37 @@ int pdf_choice_widget_options(pdf_document *doc, pdf_widget *tw, char *opts[]) if (!annot) return 0; - optarr = pdf_dict_gets(annot->obj, "Opt"); - n = pdf_array_len(optarr); + optarr = pdf_dict_gets(ctx, annot->obj, "Opt"); + n = pdf_array_len(ctx, optarr); if (opts) { for (i = 0; i < n; i++) { - opts[i] = pdf_to_str_buf(pdf_array_get(optarr, i)); + opts[i] = pdf_to_str_buf(ctx, pdf_array_get(ctx, optarr, i)); } } return n; } -int pdf_choice_widget_is_multiselect(pdf_document *doc, pdf_widget *tw) +int pdf_choice_widget_is_multiselect(fz_context *ctx, pdf_document *doc, pdf_widget *tw) { pdf_annot *annot = (pdf_annot *)tw; if (!annot) return 0; - switch (pdf_field_type(doc, annot->obj)) + switch (pdf_field_type(ctx, doc, annot->obj)) { case PDF_WIDGET_TYPE_LISTBOX: case PDF_WIDGET_TYPE_COMBOBOX: - return (pdf_get_field_flags(doc, annot->obj) & Ff_MultiSelect) != 0; + return (pdf_get_field_flags(ctx, doc, annot->obj) & Ff_MultiSelect) != 0; default: return 0; } } -int pdf_choice_widget_value(pdf_document *doc, pdf_widget *tw, char *opts[]) +int pdf_choice_widget_value(fz_context *ctx, pdf_document *doc, pdf_widget *tw, char *opts[]) { pdf_annot *annot = (pdf_annot *)tw; pdf_obj *optarr; @@ -1374,29 +1353,29 @@ int pdf_choice_widget_value(pdf_document *doc, pdf_widget *tw, char *opts[]) if (!annot) return 0; - optarr = pdf_dict_gets(annot->obj, "V"); + optarr = pdf_dict_gets(ctx, annot->obj, "V"); - if (pdf_is_string(optarr)) + if (pdf_is_string(ctx, optarr)) { if (opts) - opts[0] = pdf_to_str_buf(optarr); + opts[0] = pdf_to_str_buf(ctx, optarr); return 1; } else { - n = pdf_array_len(optarr); + n = pdf_array_len(ctx, optarr); if (opts) { for (i = 0; i < n; i++) { - pdf_obj *elem = pdf_array_get(optarr, i); + pdf_obj *elem = pdf_array_get(ctx, optarr, i); - if (pdf_is_array(elem)) - elem = pdf_array_get(elem, 1); + if (pdf_is_array(ctx, elem)) + elem = pdf_array_get(ctx, elem, 1); - opts[i] = pdf_to_str_buf(elem); + opts[i] = pdf_to_str_buf(ctx, elem); } } @@ -1404,9 +1383,8 @@ int pdf_choice_widget_value(pdf_document *doc, pdf_widget *tw, char *opts[]) } } -void pdf_choice_widget_set_value(pdf_document *doc, pdf_widget *tw, int n, char *opts[]) +void pdf_choice_widget_set_value(fz_context *ctx, pdf_document *doc, pdf_widget *tw, int n, char *opts[]) { - fz_context *ctx = doc->ctx; pdf_annot *annot = (pdf_annot *)tw; pdf_obj *optarr = NULL, *opt = NULL; int i; @@ -1420,71 +1398,70 @@ void pdf_choice_widget_set_value(pdf_document *doc, pdf_widget *tw, int n, char { if (n != 1) { - optarr = pdf_new_array(doc, n); + optarr = pdf_new_array(ctx, doc, n); for (i = 0; i < n; i++) { - opt = pdf_new_string(doc, opts[i], strlen(opts[i])); - pdf_array_push(optarr, opt); - pdf_drop_obj(opt); + opt = pdf_new_string(ctx, doc, opts[i], strlen(opts[i])); + pdf_array_push(ctx, optarr, opt); + pdf_drop_obj(ctx, opt); opt = NULL; } - pdf_dict_puts(annot->obj, "V", optarr); - pdf_drop_obj(optarr); + pdf_dict_puts(ctx, annot->obj, "V", optarr); + pdf_drop_obj(ctx, optarr); } else { - opt = pdf_new_string(doc, opts[0], strlen(opts[0])); - pdf_dict_puts(annot->obj, "V", opt); - pdf_drop_obj(opt); + opt = pdf_new_string(ctx, doc, opts[0], strlen(opts[0])); + pdf_dict_puts(ctx, annot->obj, "V", opt); + pdf_drop_obj(ctx, opt); } /* FIXME: when n > 1, we should be regenerating the indexes */ - pdf_dict_dels(annot->obj, "I"); + pdf_dict_dels(ctx, annot->obj, "I"); - pdf_field_mark_dirty(doc, annot->obj); - if (pdf_field_dirties_document(doc, annot->obj)) + pdf_field_mark_dirty(ctx, doc, annot->obj); + if (pdf_field_dirties_document(ctx, doc, annot->obj)) doc->dirty = 1; } fz_catch(ctx) { - pdf_drop_obj(optarr); - pdf_drop_obj(opt); + pdf_drop_obj(ctx, optarr); + pdf_drop_obj(ctx, opt); fz_rethrow(ctx); } } -int pdf_signature_widget_byte_range(pdf_document *doc, pdf_widget *widget, int (*byte_range)[2]) +int pdf_signature_widget_byte_range(fz_context *ctx, pdf_document *doc, pdf_widget *widget, int (*byte_range)[2]) { pdf_annot *annot = (pdf_annot *)widget; - pdf_obj *br = pdf_dict_getp(annot->obj, "V/ByteRange"); - int i, n = pdf_array_len(br)/2; + pdf_obj *br = pdf_dict_getp(ctx, annot->obj, "V/ByteRange"); + int i, n = pdf_array_len(ctx, br)/2; if (byte_range) { for (i = 0; i < n; i++) { - byte_range[i][0] = pdf_to_int(pdf_array_get(br, 2*i)); - byte_range[i][1] = pdf_to_int(pdf_array_get(br, 2*i+1)); + byte_range[i][0] = pdf_to_int(ctx, pdf_array_get(ctx, br, 2*i)); + byte_range[i][1] = pdf_to_int(ctx, pdf_array_get(ctx, br, 2*i+1)); } } return n; } -int pdf_signature_widget_contents(pdf_document *doc, pdf_widget *widget, char **contents) +int pdf_signature_widget_contents(fz_context *ctx, pdf_document *doc, pdf_widget *widget, char **contents) { pdf_annot *annot = (pdf_annot *)widget; - pdf_obj *c = pdf_dict_getp(annot->obj, "V/Contents"); + pdf_obj *c = pdf_dict_getp(ctx, annot->obj, "V/Contents"); if (contents) - *contents = pdf_to_str_buf(c); - return pdf_to_str_len(c); + *contents = pdf_to_str_buf(ctx, c); + return pdf_to_str_len(ctx, c); } -void pdf_signature_set_value(pdf_document *doc, pdf_obj *field, pdf_signer *signer) +void pdf_signature_set_value(fz_context *ctx, pdf_document *doc, pdf_obj *field, pdf_signer *signer) { - fz_context *ctx = doc->ctx; pdf_obj *v; pdf_obj *indv; int vnum; @@ -1495,40 +1472,40 @@ void pdf_signature_set_value(pdf_document *doc, pdf_obj *field, pdf_signer *sign memset(buf, 0, sizeof(buf)); - vnum = pdf_create_object(doc); - indv = pdf_new_indirect(doc, vnum, 0); - pdf_dict_puts_drop(field, "V", indv); + vnum = pdf_create_object(ctx, doc); + indv = pdf_new_indirect(ctx, doc, vnum, 0); + pdf_dict_puts_drop(ctx, field, "V", indv); fz_var(v); fz_try(ctx) { - v = pdf_new_dict(doc, 4); - pdf_update_object(doc, vnum, v); + v = pdf_new_dict(ctx, doc, 4); + pdf_update_object(ctx, doc, vnum, v); } fz_always(ctx) { - pdf_drop_obj(v); + pdf_drop_obj(ctx, v); } fz_catch(ctx) { fz_rethrow(ctx); } - byte_range = pdf_new_array(doc, 4); - pdf_dict_puts_drop(v, "ByteRange", byte_range); + byte_range = pdf_new_array(ctx, doc, 4); + pdf_dict_puts_drop(ctx, v, "ByteRange", byte_range); - contents = pdf_new_string(doc, buf, sizeof(buf)); - pdf_dict_puts_drop(v, "Contents", contents); + contents = pdf_new_string(ctx, doc, buf, sizeof(buf)); + pdf_dict_puts_drop(ctx, v, "Contents", contents); - pdf_dict_puts_drop(v, "Filter", pdf_new_name(doc, "Adobe.PPKLite")); - pdf_dict_puts_drop(v, "SubFilter", pdf_new_name(doc, "adbe.pkcs7.detached")); + pdf_dict_puts_drop(ctx, v, "Filter", pdf_new_name(ctx, doc, "Adobe.PPKLite")); + pdf_dict_puts_drop(ctx, v, "SubFilter", pdf_new_name(ctx, doc, "adbe.pkcs7.detached")); /* Record details within the document structure so that contents * and byte_range can be updated with their correct values at * saving time */ - unsaved_sig = fz_malloc_struct(doc->ctx, pdf_unsaved_sig); - unsaved_sig->field = pdf_keep_obj(field); - unsaved_sig->signer = pdf_keep_signer(signer); + unsaved_sig = fz_malloc_struct(ctx, pdf_unsaved_sig); + unsaved_sig->field = pdf_keep_obj(ctx, field); + unsaved_sig->signer = pdf_keep_signer(ctx, signer); unsaved_sig->next = doc->unsaved_sigs; doc->unsaved_sigs = unsaved_sig; } diff --git a/source/pdf/pdf-function.c b/source/pdf/pdf-function.c index c8986e32..7ead09ca 100644 --- a/source/pdf/pdf-function.c +++ b/source/pdf/pdf-function.c @@ -111,7 +111,7 @@ struct ps_stack_s #ifndef NDEBUG void -pdf_debug_ps_stack(ps_stack *st) +pdf_debug_ps_stack(fz_context *ctx, ps_stack *st) { int i; @@ -693,16 +693,15 @@ resize_code(fz_context *ctx, pdf_function *func, int newsize) } static void -parse_code(pdf_function *func, fz_stream *stream, int *codeptr, pdf_lexbuf *buf) +parse_code(fz_context *ctx, pdf_function *func, fz_stream *stream, int *codeptr, pdf_lexbuf *buf) { pdf_token tok; int opptr, elseptr, ifptr; int a, b, mid, cmp; - fz_context *ctx = stream->ctx; while (1) { - tok = pdf_lex(stream, buf); + tok = pdf_lex(ctx, stream, buf); switch (tok) { @@ -744,16 +743,16 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr, pdf_lexbuf *buf) resize_code(ctx, func, *codeptr); ifptr = *codeptr; - parse_code(func, stream, codeptr, buf); + parse_code(ctx, func, stream, codeptr, buf); - tok = pdf_lex(stream, buf); + tok = pdf_lex(ctx, stream, buf); if (tok == PDF_TOK_OPEN_BRACE) { elseptr = *codeptr; - parse_code(func, stream, codeptr, buf); + parse_code(ctx, func, stream, codeptr, buf); - tok = pdf_lex(stream, buf); + tok = pdf_lex(ctx, stream, buf); } else { @@ -835,13 +834,12 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr, pdf_lexbuf *buf) } static void -load_postscript_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, int gen) +load_postscript_func(fz_context *ctx, pdf_document *doc, pdf_function *func, pdf_obj *dict, int num, int gen) { fz_stream *stream = NULL; int codeptr; pdf_lexbuf buf; pdf_token tok; - fz_context *ctx = doc->ctx; int locked = 0; pdf_lexbuf_init(ctx, &buf, PDF_LEXBUF_SMALL); @@ -851,9 +849,9 @@ load_postscript_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int n fz_try(ctx) { - stream = pdf_open_stream(doc, num, gen); + stream = pdf_open_stream(ctx, doc, num, gen); - tok = pdf_lex(stream, &buf); + tok = pdf_lex(ctx, stream, &buf); if (tok != PDF_TOK_OPEN_BRACE) { fz_throw(ctx, FZ_ERROR_GENERIC, "stream is not a calculator function"); @@ -863,12 +861,12 @@ load_postscript_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int n func->u.p.cap = 0; codeptr = 0; - parse_code(func, stream, &codeptr, &buf); + parse_code(ctx, func, stream, &codeptr, &buf); } fz_always(ctx) { - fz_drop_stream(stream); - pdf_lexbuf_fin(&buf); + fz_drop_stream(ctx, stream); + pdf_lexbuf_fin(ctx, &buf); } fz_catch(ctx) { @@ -909,9 +907,8 @@ eval_postscript_func(fz_context *ctx, pdf_function *func, const float *in, float #define MAX_SAMPLE_FUNCTION_SIZE (100 << 20) static void -load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, int gen) +load_sample_func(fz_context *ctx, pdf_document *doc, pdf_function *func, pdf_obj *dict, int num, int gen) { - fz_context *ctx = doc->ctx; fz_stream *stream; pdf_obj *obj; int samplecount; @@ -922,14 +919,14 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, func->u.sa.samples = NULL; - obj = pdf_dict_gets(dict, "Size"); - if (pdf_array_len(obj) < func->base.m) + obj = pdf_dict_gets(ctx, dict, "Size"); + if (pdf_array_len(ctx, obj) < func->base.m) fz_throw(ctx, FZ_ERROR_GENERIC, "too few sample function dimension sizes"); - if (pdf_array_len(obj) > func->base.m) + if (pdf_array_len(ctx, obj) > func->base.m) fz_warn(ctx, "too many sample function dimension sizes"); for (i = 0; i < func->base.m; i++) { - func->u.sa.size[i] = pdf_to_int(pdf_array_get(obj, i)); + func->u.sa.size[i] = pdf_to_int(ctx, pdf_array_get(ctx, obj, i)); if (func->u.sa.size[i] <= 0) { fz_warn(ctx, "non-positive sample function dimension size"); @@ -937,25 +934,25 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, } } - obj = pdf_dict_gets(dict, "BitsPerSample"); - func->u.sa.bps = bps = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "BitsPerSample"); + func->u.sa.bps = bps = pdf_to_int(ctx, obj); for (i = 0; i < func->base.m; i++) { func->u.sa.encode[i][0] = 0; func->u.sa.encode[i][1] = func->u.sa.size[i] - 1; } - obj = pdf_dict_gets(dict, "Encode"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Encode"); + if (pdf_is_array(ctx, obj)) { - int ranges = fz_mini(func->base.m, pdf_array_len(obj) / 2); + int ranges = fz_mini(func->base.m, pdf_array_len(ctx, obj) / 2); if (ranges != func->base.m) fz_warn(ctx, "wrong number of sample function input mappings"); for (i = 0; i < ranges; i++) { - func->u.sa.encode[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0)); - func->u.sa.encode[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1)); + func->u.sa.encode[i][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 0)); + func->u.sa.encode[i][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 1)); } } @@ -965,17 +962,17 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, func->u.sa.decode[i][1] = func->range[i][1]; } - obj = pdf_dict_gets(dict, "Decode"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Decode"); + if (pdf_is_array(ctx, obj)) { - int ranges = fz_mini(func->base.n, pdf_array_len(obj) / 2); + int ranges = fz_mini(func->base.n, pdf_array_len(ctx, obj) / 2); if (ranges != func->base.n) fz_warn(ctx, "wrong number of sample function output mappings"); for (i = 0; i < ranges; i++) { - func->u.sa.decode[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0)); - func->u.sa.decode[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1)); + func->u.sa.decode[i][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 0)); + func->u.sa.decode[i][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 1)); } } @@ -988,7 +985,7 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, func->u.sa.samples = fz_malloc_array(ctx, samplecount, sizeof(float)); func->base.size += samplecount * sizeof(float); - stream = pdf_open_stream(doc, num, gen); + stream = pdf_open_stream(ctx, doc, num, gen); fz_try(ctx) { @@ -998,32 +995,32 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, unsigned int x; float s; - if (fz_is_eof_bits(stream)) + if (fz_is_eof_bits(ctx, stream)) fz_throw(ctx, FZ_ERROR_GENERIC, "truncated sample function stream"); switch (bps) { - case 1: s = fz_read_bits(stream, 1); break; - case 2: s = fz_read_bits(stream, 2) / 3.0f; break; - case 4: s = fz_read_bits(stream, 4) / 15.0f; break; - case 8: s = fz_read_byte(stream) / 255.0f; break; - case 12: s = fz_read_bits(stream, 12) / 4095.0f; break; + case 1: s = fz_read_bits(ctx, stream, 1); break; + case 2: s = fz_read_bits(ctx, stream, 2) / 3.0f; break; + case 4: s = fz_read_bits(ctx, stream, 4) / 15.0f; break; + case 8: s = fz_read_byte(ctx, stream) / 255.0f; break; + case 12: s = fz_read_bits(ctx, stream, 12) / 4095.0f; break; case 16: - x = fz_read_byte(stream) << 8; - x |= fz_read_byte(stream); + x = fz_read_byte(ctx, stream) << 8; + x |= fz_read_byte(ctx, stream); s = x / 65535.0f; break; case 24: - x = fz_read_byte(stream) << 16; - x |= fz_read_byte(stream) << 8; - x |= fz_read_byte(stream); + x = fz_read_byte(ctx, stream) << 16; + x |= fz_read_byte(ctx, stream) << 8; + x |= fz_read_byte(ctx, stream); s = x / 16777215.0f; break; case 32: - x = fz_read_byte(stream) << 24; - x |= fz_read_byte(stream) << 16; - x |= fz_read_byte(stream) << 8; - x |= fz_read_byte(stream); + x = fz_read_byte(ctx, stream) << 24; + x |= fz_read_byte(ctx, stream) << 16; + x |= fz_read_byte(ctx, stream) << 8; + x |= fz_read_byte(ctx, stream); s = x / 4294967295.0f; break; default: @@ -1035,7 +1032,7 @@ load_sample_func(pdf_function *func, pdf_document *doc, pdf_obj *dict, int num, } fz_always(ctx) { - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -1135,7 +1132,7 @@ eval_sample_func(fz_context *ctx, pdf_function *func, const float *in, float *ou */ static void -load_exponential_func(fz_context *ctx, pdf_function *func, pdf_obj *dict) +load_exponential_func(fz_context *ctx, pdf_document *doc, pdf_function *func, pdf_obj *dict) { pdf_obj *obj; int i; @@ -1144,8 +1141,8 @@ load_exponential_func(fz_context *ctx, pdf_function *func, pdf_obj *dict) fz_warn(ctx, "exponential functions have at most one input"); func->base.m = 1; - obj = pdf_dict_gets(dict, "N"); - func->u.e.n = pdf_to_real(obj); + obj = pdf_dict_gets(ctx, dict, "N"); + func->u.e.n = pdf_to_real(ctx, obj); /* See exponential functions (PDF 1.7 section 3.9.2) */ if (func->u.e.n != (int) func->u.e.n) @@ -1170,26 +1167,26 @@ load_exponential_func(fz_context *ctx, pdf_function *func, pdf_obj *dict) func->u.e.c1[i] = 1; } - obj = pdf_dict_gets(dict, "C0"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "C0"); + if (pdf_is_array(ctx, obj)) { - int ranges = fz_mini(func->base.n, pdf_array_len(obj)); + int ranges = fz_mini(func->base.n, pdf_array_len(ctx, obj)); if (ranges != func->base.n) fz_warn(ctx, "wrong number of C0 constants for exponential function"); for (i = 0; i < ranges; i++) - func->u.e.c0[i] = pdf_to_real(pdf_array_get(obj, i)); + func->u.e.c0[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)); } - obj = pdf_dict_gets(dict, "C1"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "C1"); + if (pdf_is_array(ctx, obj)) { - int ranges = fz_mini(func->base.n, pdf_array_len(obj)); + int ranges = fz_mini(func->base.n, pdf_array_len(ctx, obj)); if (ranges != func->base.n) fz_warn(ctx, "wrong number of C1 constants for exponential function"); for (i = 0; i < ranges; i++) - func->u.e.c1[i] = pdf_to_real(pdf_array_get(obj, i)); + func->u.e.c1[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)); } } @@ -1220,9 +1217,8 @@ eval_exponential_func(fz_context *ctx, pdf_function *func, float in, float *out) */ static void -load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict) +load_stitching_func(fz_context *ctx, pdf_document *doc, pdf_function *func, pdf_obj *dict) { - fz_context *ctx = doc->ctx; fz_function **funcs; pdf_obj *obj; pdf_obj *sub; @@ -1236,14 +1232,14 @@ load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict) fz_warn(ctx, "stitching functions have at most one input"); func->base.m = 1; - obj = pdf_dict_gets(dict, "Functions"); - if (!pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Functions"); + if (!pdf_is_array(ctx, obj)) fz_throw(ctx, FZ_ERROR_GENERIC, "stitching function has no input functions"); fz_try(ctx) { - pdf_mark_obj(obj); - k = pdf_array_len(obj); + pdf_mark_obj(ctx, obj); + k = pdf_array_len(ctx, obj); func->u.st.funcs = fz_malloc_array(ctx, k, sizeof(fz_function*)); func->u.st.bounds = fz_malloc_array(ctx, k - 1, sizeof(float)); @@ -1252,10 +1248,10 @@ load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict) for (i = 0; i < k; i++) { - sub = pdf_array_get(obj, i); - funcs[i] = pdf_load_function(doc, sub, 1, func->base.n); + sub = pdf_array_get(ctx, obj, i); + funcs[i] = pdf_load_function(ctx, doc, sub, 1, func->base.n); - func->base.size += fz_function_size(funcs[i]); + func->base.size += fz_function_size(ctx, funcs[i]); func->u.st.k ++; if (funcs[i]->m != func->base.m) @@ -1266,26 +1262,26 @@ load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict) } fz_always(ctx) { - pdf_unmark_obj(obj); + pdf_unmark_obj(ctx, obj); } fz_catch(ctx) { fz_rethrow(ctx); } - obj = pdf_dict_gets(dict, "Bounds"); - if (!pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Bounds"); + if (!pdf_is_array(ctx, obj)) fz_throw(ctx, FZ_ERROR_GENERIC, "stitching function has no bounds"); { - if (pdf_array_len(obj) < k - 1) + if (pdf_array_len(ctx, obj) < k - 1) fz_throw(ctx, FZ_ERROR_GENERIC, "too few subfunction boundaries"); - if (pdf_array_len(obj) > k) + if (pdf_array_len(ctx, obj) > k) fz_warn(ctx, "too many subfunction boundaries"); for (i = 0; i < k - 1; i++) { - num = pdf_array_get(obj, i); - func->u.st.bounds[i] = pdf_to_real(num); + num = pdf_array_get(ctx, obj, i); + func->u.st.bounds[i] = pdf_to_real(ctx, num); if (i && func->u.st.bounds[i - 1] > func->u.st.bounds[i]) fz_throw(ctx, FZ_ERROR_GENERIC, "subfunction %d boundary out of range", i); } @@ -1301,17 +1297,17 @@ load_stitching_func(pdf_function *func, pdf_document *doc, pdf_obj *dict) func->u.st.encode[i * 2 + 1] = 0; } - obj = pdf_dict_gets(dict, "Encode"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Encode"); + if (pdf_is_array(ctx, obj)) { - int ranges = fz_mini(k, pdf_array_len(obj) / 2); + int ranges = fz_mini(k, pdf_array_len(ctx, obj) / 2); if (ranges != k) fz_warn(ctx, "wrong number of stitching function input mappings"); for (i = 0; i < ranges; i++) { - func->u.st.encode[i * 2 + 0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0)); - func->u.st.encode[i * 2 + 1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1)); + func->u.st.encode[i * 2 + 0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 0)); + func->u.st.encode[i * 2 + 1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 1)); } } } @@ -1620,21 +1616,20 @@ pdf_debug_function_imp(fz_function *func_, int level) } void -pdf_debug_function(fz_function *func) +pdf_debug_function(fz_context *ctx, fz_function *func) { pdf_debug_function_imp(func, 0); } #endif fz_function * -pdf_load_function(pdf_document *doc, pdf_obj *dict, int in, int out) +pdf_load_function(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int in, int out) { - fz_context *ctx = doc->ctx; pdf_function *func; pdf_obj *obj; int i; - if (pdf_obj_marked(dict)) + if (pdf_obj_marked(ctx, dict)) fz_throw(ctx, FZ_ERROR_GENERIC, "Recursion in function definition"); if ((func = pdf_find_item(ctx, pdf_drop_function_imp, dict)) != NULL) @@ -1650,28 +1645,28 @@ pdf_load_function(pdf_document *doc, pdf_obj *dict, int in, int out) func->base.debug = pdf_debug_function; #endif - obj = pdf_dict_gets(dict, "FunctionType"); - func->type = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "FunctionType"); + func->type = pdf_to_int(ctx, obj); /* required for all */ - obj = pdf_dict_gets(dict, "Domain"); - func->base.m = fz_clampi(pdf_array_len(obj) / 2, 1, FZ_FN_MAXM); + obj = pdf_dict_gets(ctx, dict, "Domain"); + func->base.m = fz_clampi(pdf_array_len(ctx, obj) / 2, 1, FZ_FN_MAXM); for (i = 0; i < func->base.m; i++) { - func->domain[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0)); - func->domain[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1)); + func->domain[i][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 0)); + func->domain[i][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 1)); } /* required for type0 and type4, optional otherwise */ - obj = pdf_dict_gets(dict, "Range"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "Range"); + if (pdf_is_array(ctx, obj)) { func->has_range = 1; - func->base.n = fz_clampi(pdf_array_len(obj) / 2, 1, FZ_FN_MAXN); + func->base.n = fz_clampi(pdf_array_len(ctx, obj) / 2, 1, FZ_FN_MAXN); for (i = 0; i < func->base.n; i++) { - func->range[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0)); - func->range[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1)); + func->range[i][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 0)); + func->range[i][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i * 2 + 1)); } } else @@ -1690,23 +1685,23 @@ pdf_load_function(pdf_document *doc, pdf_obj *dict, int in, int out) switch (func->type) { case SAMPLE: - load_sample_func(func, doc, dict, pdf_to_num(dict), pdf_to_gen(dict)); + load_sample_func(ctx, doc, func, dict, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); break; case EXPONENTIAL: - load_exponential_func(ctx, func, dict); + load_exponential_func(ctx, doc, func, dict); break; case STITCHING: - load_stitching_func(func, doc, dict); + load_stitching_func(ctx, doc, func, dict); break; case POSTSCRIPT: - load_postscript_func(func, doc, dict, pdf_to_num(dict), pdf_to_gen(dict)); + load_postscript_func(ctx, doc, func, dict, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); break; default: - fz_throw(ctx, FZ_ERROR_GENERIC, "unknown function type (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown function type (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } pdf_store_item(ctx, dict, func, func->base.size); @@ -1721,7 +1716,7 @@ pdf_load_function(pdf_document *doc, pdf_obj *dict, int in, int out) type == STITCHING ? "stitching" : type == POSTSCRIPT ? "calculator" : "unknown", - pdf_to_num(dict), pdf_to_gen(dict)); + pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } return (fz_function *)func; diff --git a/source/pdf/pdf-image.c b/source/pdf/pdf-image.c index dd96f4fb..30f96dc8 100644 --- a/source/pdf/pdf-image.c +++ b/source/pdf/pdf-image.c @@ -1,9 +1,9 @@ #include "mupdf/pdf.h" -static fz_image *pdf_load_jpx(pdf_document *doc, pdf_obj *dict, int forcemask); +static fz_image *pdf_load_jpx(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int forcemask); static fz_image * -pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask) +pdf_load_image_imp(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask) { fz_stream *stm = NULL; fz_image *image = NULL; @@ -21,7 +21,6 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs int stride; int i; - fz_context *ctx = doc->ctx; fz_compressed_buffer *buffer; fz_var(stm); @@ -34,7 +33,7 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs /* special case for JPEG2000 images */ if (pdf_is_jpx_image(ctx, dict)) { - image = pdf_load_jpx(doc, dict, forcemask); + image = pdf_load_jpx(ctx, doc, dict, forcemask); if (forcemask) { @@ -56,13 +55,13 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs break; /* Out of fz_try */ } - w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W")); - h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H")); - bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC")); + w = pdf_to_int(ctx, pdf_dict_getsa(ctx, dict, "Width", "W")); + h = pdf_to_int(ctx, pdf_dict_getsa(ctx, dict, "Height", "H")); + bpc = pdf_to_int(ctx, pdf_dict_getsa(ctx, dict, "BitsPerComponent", "BPC")); if (bpc == 0) bpc = 8; - imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM")); - interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I")); + imagemask = pdf_to_bool(ctx, pdf_dict_getsa(ctx, dict, "ImageMask", "IM")); + interpolate = pdf_to_bool(ctx, pdf_dict_getsa(ctx, dict, "Interpolate", "I")); indexed = 0; usecolorkey = 0; @@ -83,19 +82,19 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs if (h > (1 << 16)) fz_throw(ctx, FZ_ERROR_GENERIC, "image is too high"); - obj = pdf_dict_getsa(dict, "ColorSpace", "CS"); + obj = pdf_dict_getsa(ctx, dict, "ColorSpace", "CS"); if (obj && !imagemask && !forcemask) { /* colorspace resource lookup is only done for inline images */ - if (pdf_is_name(obj)) + if (pdf_is_name(ctx, obj)) { - res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj); + res = pdf_dict_get(ctx, pdf_dict_gets(ctx, rdb, "ColorSpace"), obj); if (res) obj = res; } - colorspace = pdf_load_colorspace(doc, obj); - indexed = fz_colorspace_is_indexed(colorspace); + colorspace = pdf_load_colorspace(ctx, doc, obj); + indexed = fz_colorspace_is_indexed(ctx, colorspace); n = colorspace->n; } @@ -104,11 +103,11 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs n = 1; } - obj = pdf_dict_getsa(dict, "Decode", "D"); + obj = pdf_dict_getsa(ctx, dict, "Decode", "D"); if (obj) { for (i = 0; i < n * 2; i++) - decode[i] = pdf_to_real(pdf_array_get(obj, i)); + decode[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)); } else { @@ -117,8 +116,8 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs decode[i] = i & 1 ? maxval : 0; } - obj = pdf_dict_getsa(dict, "SMask", "Mask"); - if (pdf_is_dict(obj)) + obj = pdf_dict_getsa(ctx, dict, "SMask", "Mask"); + if (pdf_is_dict(ctx, obj)) { /* Not allowed for inline images or soft masks */ if (cstm) @@ -127,27 +126,27 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs fz_warn(ctx, "Ignoring recursive image soft mask"); else { - mask = pdf_load_image_imp(doc, rdb, obj, NULL, 1); - obj = pdf_dict_gets(obj, "Matte"); - if (pdf_is_array(obj)) + mask = pdf_load_image_imp(ctx, doc, rdb, obj, NULL, 1); + obj = pdf_dict_gets(ctx, obj, "Matte"); + if (pdf_is_array(ctx, obj)) { usecolorkey = 1; for (i = 0; i < n; i++) - colorkey[i] = pdf_to_real(pdf_array_get(obj, i)) * 255; + colorkey[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)) * 255; } } } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { usecolorkey = 1; for (i = 0; i < n * 2; i++) { - if (!pdf_is_int(pdf_array_get(obj, i))) + if (!pdf_is_int(ctx, pdf_array_get(ctx, obj, i))) { fz_warn(ctx, "invalid value in color key mask"); usecolorkey = 0; } - colorkey[i] = pdf_to_int(pdf_array_get(obj, i)); + colorkey[i] = pdf_to_int(ctx, pdf_array_get(ctx, obj, i)); } } @@ -156,9 +155,9 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs { /* Just load the compressed image data now and we can * decode it on demand. */ - int num = pdf_to_num(dict); - int gen = pdf_to_gen(dict); - buffer = pdf_load_compressed_stream(doc, num, gen); + int num = pdf_to_num(ctx, dict); + int gen = pdf_to_gen(ctx, dict); + buffer = pdf_load_compressed_stream(ctx, doc, num, gen); image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, buffer, mask); } else @@ -166,7 +165,7 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs /* Inline stream */ stride = (w * n * bpc + 7) / 8; image = fz_new_image(ctx, w, h, bpc, colorspace, 96, 96, interpolate, imagemask, decode, usecolorkey ? colorkey : NULL, NULL, mask); - pdf_load_compressed_inline_image(doc, dict, stride * h, cstm, indexed, image); + pdf_load_compressed_inline_image(ctx, doc, dict, stride * h, cstm, indexed, image); } } @@ -181,9 +180,9 @@ pdf_load_image_imp(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *cs } fz_image * -pdf_load_inline_image(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *file) +pdf_load_inline_image(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *file) { - return pdf_load_image_imp(doc, rdb, dict, file, 0); + return pdf_load_image_imp(ctx, doc, rdb, dict, file, 0); } int @@ -192,79 +191,81 @@ pdf_is_jpx_image(fz_context *ctx, pdf_obj *dict) pdf_obj *filter; int i, n; - filter = pdf_dict_gets(dict, "Filter"); - if (!strcmp(pdf_to_name(filter), "JPXDecode")) + filter = pdf_dict_gets(ctx, dict, "Filter"); + if (!strcmp(pdf_to_name(ctx, filter), "JPXDecode")) return 1; - n = pdf_array_len(filter); + n = pdf_array_len(ctx, filter); for (i = 0; i < n; i++) - if (!strcmp(pdf_to_name(pdf_array_get(filter, i)), "JPXDecode")) + if (!strcmp(pdf_to_name(ctx, pdf_array_get(ctx, filter, i)), "JPXDecode")) return 1; return 0; } static fz_image * -pdf_load_jpx(pdf_document *doc, pdf_obj *dict, int forcemask) +pdf_load_jpx(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int forcemask) { fz_buffer *buf = NULL; fz_colorspace *colorspace = NULL; - fz_pixmap *img = NULL; + fz_pixmap *pix = NULL; pdf_obj *obj; - fz_context *ctx = doc->ctx; int indexed = 0; fz_image *mask = NULL; + fz_image *img = NULL; - fz_var(img); + fz_var(pix); fz_var(buf); fz_var(colorspace); fz_var(mask); - buf = pdf_load_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); /* FIXME: We can't handle decode arrays for indexed images currently */ fz_try(ctx) { - obj = pdf_dict_gets(dict, "ColorSpace"); + obj = pdf_dict_gets(ctx, dict, "ColorSpace"); if (obj) { - colorspace = pdf_load_colorspace(doc, obj); - indexed = fz_colorspace_is_indexed(colorspace); + colorspace = pdf_load_colorspace(ctx, doc, obj); + indexed = fz_colorspace_is_indexed(ctx, colorspace); } - img = fz_load_jpx(ctx, buf->data, buf->len, colorspace, indexed); + pix = fz_load_jpx(ctx, buf->data, buf->len, colorspace, indexed); - obj = pdf_dict_getsa(dict, "SMask", "Mask"); - if (pdf_is_dict(obj)) + obj = pdf_dict_getsa(ctx, dict, "SMask", "Mask"); + if (pdf_is_dict(ctx, obj)) { if (forcemask) fz_warn(ctx, "Ignoring recursive JPX soft mask"); else - mask = pdf_load_image_imp(doc, NULL, obj, NULL, 1); + mask = pdf_load_image_imp(ctx, doc, NULL, obj, NULL, 1); } - obj = pdf_dict_getsa(dict, "Decode", "D"); + obj = pdf_dict_getsa(ctx, dict, "Decode", "D"); if (obj && !indexed) { float decode[FZ_MAX_COLORS * 2]; int i; - for (i = 0; i < img->n * 2; i++) - decode[i] = pdf_to_real(pdf_array_get(obj, i)); + for (i = 0; i < pix->n * 2; i++) + decode[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)); - fz_decode_tile(img, decode); + fz_decode_tile(ctx, pix, decode); } + + img = fz_new_image_from_pixmap(ctx, pix, mask); } fz_always(ctx) { fz_drop_colorspace(ctx, colorspace); fz_drop_buffer(ctx, buf); + fz_drop_pixmap(ctx, pix); } fz_catch(ctx) { - fz_drop_pixmap(ctx, img); fz_rethrow(ctx); } - return fz_new_image_from_pixmap(ctx, img, mask); + return img; } static int @@ -276,9 +277,8 @@ fz_image_size(fz_context *ctx, fz_image *im) } fz_image * -pdf_load_image(pdf_document *doc, pdf_obj *dict) +pdf_load_image(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { - fz_context *ctx = doc->ctx; fz_image *image; if ((image = pdf_find_item(ctx, fz_drop_image_imp, dict)) != NULL) @@ -286,7 +286,7 @@ pdf_load_image(pdf_document *doc, pdf_obj *dict) return (fz_image *)image; } - image = pdf_load_image_imp(doc, NULL, dict, NULL, 0); + image = pdf_load_image_imp(ctx, doc, NULL, dict, NULL, 0); pdf_store_item(ctx, dict, image, fz_image_size(ctx, image)); diff --git a/source/pdf/pdf-interpret-imp.h b/source/pdf/pdf-interpret-imp.h index 314e6d2b..817a7d2c 100644 --- a/source/pdf/pdf-interpret-imp.h +++ b/source/pdf/pdf-interpret-imp.h @@ -106,6 +106,7 @@ typedef struct pdf_process_s struct pdf_csi_s { + fz_context *ctx; pdf_document *doc; /* Current resource dict and file. These are in here to reduce param @@ -142,14 +143,14 @@ void pdf_process_contents_object(pdf_csi *csi, pdf_obj *rdb, pdf_obj *contents); void pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf); /* Functions to set up pdf_process structures */ -pdf_process *pdf_process_run(pdf_process *process, fz_device *dev, const fz_matrix *ctm, const char *event, pdf_gstate *gstate, int nested); -pdf_process *pdf_process_buffer(pdf_process *process, fz_context *ctx, fz_buffer *buffer); -pdf_process *pdf_process_filter(pdf_process *process, fz_context *ctx, pdf_process *underlying, pdf_obj *resources); +pdf_process *pdf_init_process_run(fz_context *ctx, pdf_process *process, fz_device *dev, const fz_matrix *ctm, const char *event, pdf_gstate *gstate, int nested); +pdf_process *pdf_init_process_buffer(fz_context *ctx, pdf_process *process, fz_buffer *buffer); +pdf_process *pdf_init_process_filter(fz_context *ctx, pdf_process *process, pdf_process *underlying, pdf_obj *resources); /* Functions to actually use the pdf_process structures to process * annotations, glyphs and general stream objects */ -void pdf_process_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot, const pdf_process *process, fz_cookie *cookie); -void pdf_process_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, pdf_process *process); -void pdf_process_stream_object(pdf_document *doc, pdf_obj *obj, const pdf_process *process, pdf_obj *res, fz_cookie *cookie); +void pdf_process_annot(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_annot *annot, const pdf_process *process, fz_cookie *cookie); +void pdf_process_glyph(fz_context *ctx, pdf_document *doc, pdf_obj *resources, fz_buffer *contents, pdf_process *process); +void pdf_process_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, const pdf_process *process, pdf_obj *res, fz_cookie *cookie); #endif diff --git a/source/pdf/pdf-interpret.c b/source/pdf/pdf-interpret.c index b67de46e..a3df4c77 100644 --- a/source/pdf/pdf-interpret.c +++ b/source/pdf/pdf-interpret.c @@ -1,17 +1,18 @@ #include "pdf-interpret-imp.h" static pdf_csi * -pdf_new_csi(pdf_document *doc, fz_cookie *cookie, const pdf_process *process) +pdf_new_csi(fz_context *ctx, pdf_document *doc, fz_cookie *cookie, const pdf_process *process) { pdf_csi *csi = NULL; - fz_context *ctx = doc->ctx; fz_var(csi); fz_try(ctx) { csi = fz_malloc_struct(ctx, pdf_csi); - csi->doc = doc; + csi->ctx = ctx; /* FIXME */ + csi->doc = doc; /* FIXME */ + csi->in_text = 0; csi->top = 0; @@ -38,12 +39,14 @@ pdf_new_csi(pdf_document *doc, fz_cookie *cookie, const pdf_process *process) static void pdf_clear_stack(pdf_csi *csi) { + fz_context *ctx = csi->ctx; + int i; - fz_drop_image(csi->doc->ctx, csi->img); + fz_drop_image(ctx, csi->img); csi->img = NULL; - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; csi->name[0] = 0; @@ -57,7 +60,7 @@ pdf_clear_stack(pdf_csi *csi) static void pdf_drop_csi(pdf_csi *csi) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_process_op(csi, PDF_OP_END, &csi->process); fz_free(ctx, csi); @@ -70,27 +73,29 @@ pdf_drop_csi(pdf_csi *csi) static void parse_inline_image(pdf_csi *csi) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + pdf_document *doc = csi->doc; + pdf_obj *rdb = csi->rdb; fz_stream *file = csi->file; int ch, found; fz_drop_image(ctx, csi->img); csi->img = NULL; - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; - csi->obj = pdf_parse_dict(csi->doc, file, &csi->doc->lexbuf.base); + csi->obj = pdf_parse_dict(ctx, doc, file, &doc->lexbuf.base); /* read whitespace after ID keyword */ - ch = fz_read_byte(file); + ch = fz_read_byte(ctx, file); if (ch == '\r') - if (fz_peek_byte(file) == '\n') - fz_read_byte(file); + if (fz_peek_byte(ctx, file) == '\n') + fz_read_byte(ctx, file); fz_try(ctx) { - csi->img = pdf_load_inline_image(csi->doc, rdb, csi->obj, file); + csi->img = pdf_load_inline_image(ctx, doc, rdb, csi->obj, file); } fz_catch(ctx) { @@ -99,17 +104,17 @@ parse_inline_image(pdf_csi *csi) /* find EI */ found = 0; - ch = fz_read_byte(file); + ch = fz_read_byte(ctx, file); do { while (ch != 'E' && ch != EOF) - ch = fz_read_byte(file); + ch = fz_read_byte(ctx, file); if (ch == 'E') { - ch = fz_read_byte(file); + ch = fz_read_byte(ctx, file); if (ch == 'I') { - ch = fz_peek_byte(file); + ch = fz_peek_byte(ctx, file); if (ch == ' ' || ch <= 32 || ch == EOF || ch == '<' || ch == '/') { found = 1; @@ -125,7 +130,8 @@ parse_inline_image(pdf_csi *csi) static int pdf_run_keyword(pdf_csi *csi, char *buf) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + int key; PDF_OP op; @@ -278,7 +284,9 @@ pdf_run_keyword(pdf_csi *csi, char *buf) void pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + pdf_document *doc = csi->doc; + fz_stream *file = csi->file; pdf_token tok = PDF_TOK_ERROR; int in_text_array = 0; @@ -313,7 +321,7 @@ pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) csi->cookie->progress++; } - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (in_text_array) { @@ -323,27 +331,27 @@ pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) in_text_array = 0; break; case PDF_TOK_REAL: - pdf_array_push_drop(csi->obj, pdf_new_real(csi->doc, buf->f)); + pdf_array_push_drop(ctx, csi->obj, pdf_new_real(ctx, doc, buf->f)); break; case PDF_TOK_INT: - pdf_array_push_drop(csi->obj, pdf_new_int(csi->doc, buf->i)); + pdf_array_push_drop(ctx, csi->obj, pdf_new_int(ctx, doc, buf->i)); break; case PDF_TOK_STRING: - pdf_array_push_drop(csi->obj, pdf_new_string(csi->doc, buf->scratch, buf->len)); + pdf_array_push_drop(ctx, csi->obj, pdf_new_string(ctx, doc, buf->scratch, buf->len)); break; case PDF_TOK_EOF: break; case PDF_TOK_KEYWORD: if (!strcmp(buf->scratch, "Tw") || !strcmp(buf->scratch, "Tc")) { - int l = pdf_array_len(csi->obj); + int l = pdf_array_len(ctx, csi->obj); if (l > 0) { - pdf_obj *o = pdf_array_get(csi->obj, l-1); - if (pdf_is_number(o)) + pdf_obj *o = pdf_array_get(ctx, csi->obj, l-1); + if (pdf_is_number(ctx, o)) { - csi->stack[0] = pdf_to_real(o); - pdf_array_delete(csi->obj, l-1); + csi->stack[0] = pdf_to_real(ctx, o); + pdf_array_delete(ctx, csi->obj, l-1); if (pdf_run_keyword(csi, buf->scratch) == 0) break; } @@ -364,35 +372,35 @@ pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) case PDF_TOK_OPEN_ARRAY: if (csi->obj) { - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; } if (csi->in_text) { in_text_array = 1; - csi->obj = pdf_new_array(csi->doc, 4); + csi->obj = pdf_new_array(ctx, doc, 4); } else { - csi->obj = pdf_parse_array(csi->doc, file, buf); + csi->obj = pdf_parse_array(ctx, doc, file, buf); } break; case PDF_TOK_OPEN_DICT: if (csi->obj) { - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; } - csi->obj = pdf_parse_dict(csi->doc, file, buf); + csi->obj = pdf_parse_dict(ctx, doc, file, buf); break; case PDF_TOK_NAME: if (csi->name[0]) { - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; - csi->obj = pdf_new_name(csi->doc, buf->scratch); + csi->obj = pdf_new_name(ctx, doc, buf->scratch); } else fz_strlcpy(csi->name, buf->scratch, sizeof(csi->name)); @@ -426,10 +434,10 @@ pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) { if (csi->obj) { - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = NULL; } - csi->obj = pdf_new_string(csi->doc, buf->scratch, buf->len); + csi->obj = pdf_new_string(ctx, doc, buf->scratch, buf->len); } break; @@ -494,7 +502,8 @@ pdf_process_stream(pdf_csi *csi, pdf_lexbuf *buf) static void pdf_process_contents_stream(pdf_csi *csi, pdf_obj *rdb, fz_stream *file) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + pdf_lexbuf *buf; int save_in_text; pdf_obj *save_obj; @@ -521,11 +530,11 @@ pdf_process_contents_stream(pdf_csi *csi, pdf_obj *rdb, fz_stream *file) fz_always(ctx) { csi->in_text = save_in_text; - pdf_drop_obj(csi->obj); + pdf_drop_obj(ctx, csi->obj); csi->obj = save_obj; csi->rdb = save_rdb; csi->file = save_file; - pdf_lexbuf_fin(buf); + pdf_lexbuf_fin(ctx, buf); fz_free(ctx, buf); } fz_catch(ctx) @@ -537,16 +546,15 @@ pdf_process_contents_stream(pdf_csi *csi, pdf_obj *rdb, fz_stream *file) } void -pdf_process_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot, const pdf_process *process, fz_cookie *cookie) +pdf_process_annot(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_annot *annot, const pdf_process *process, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; pdf_csi *csi; int flags; - csi = pdf_new_csi(doc, cookie, process); + csi = pdf_new_csi(ctx, doc, cookie, process); fz_try(ctx) { - flags = pdf_to_int(pdf_dict_gets(annot->obj, "F")); + flags = pdf_to_int(ctx, pdf_dict_gets(ctx, annot->obj, "F")); /* Check not invisible (bit 0) and hidden (bit 1) */ /* TODO: NoZoom and NoRotate */ @@ -568,20 +576,22 @@ pdf_process_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot, const pdf void pdf_process_contents_object(pdf_csi *csi, pdf_obj *rdb, pdf_obj *contents) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + pdf_document *doc = csi->doc; + fz_stream *file = NULL; if (contents == NULL) return; - file = pdf_open_contents_stream(csi->doc, contents); + file = pdf_open_contents_stream(ctx, doc, contents); fz_try(ctx) { pdf_process_contents_stream(csi, rdb, file); } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { @@ -592,7 +602,8 @@ pdf_process_contents_object(pdf_csi *csi, pdf_obj *rdb, pdf_obj *contents) static void pdf_process_contents_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; + fz_stream *file = NULL; if (contents == NULL) @@ -605,7 +616,7 @@ pdf_process_contents_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents) } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { @@ -614,12 +625,11 @@ pdf_process_contents_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents) } void -pdf_process_stream_object(pdf_document *doc, pdf_obj *obj, const pdf_process *process, pdf_obj *res, fz_cookie *cookie) +pdf_process_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, const pdf_process *process, pdf_obj *res, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; pdf_csi *csi; - csi = pdf_new_csi(doc, cookie, process); + csi = pdf_new_csi(ctx, doc, cookie, process); fz_try(ctx) { csi->process.processor->process_contents(csi, csi->process.state, res, obj); @@ -636,12 +646,11 @@ pdf_process_stream_object(pdf_document *doc, pdf_obj *obj, const pdf_process *pr } void -pdf_process_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, pdf_process *process) +pdf_process_glyph(fz_context *ctx, pdf_document *doc, pdf_obj *resources, fz_buffer *contents, pdf_process *process) { pdf_csi *csi; - fz_context *ctx = doc->ctx; - csi = pdf_new_csi(doc, NULL, process); + csi = pdf_new_csi(ctx, doc, NULL, process); fz_try(ctx) { pdf_process_contents_buffer(csi, resources, contents); diff --git a/source/pdf/pdf-lex.c b/source/pdf/pdf-lex.c index 096cb540..a8dfd916 100644 --- a/source/pdf/pdf-lex.c +++ b/source/pdf/pdf-lex.c @@ -44,27 +44,27 @@ static inline int unhex(int ch) } static void -lex_white(fz_stream *f) +lex_white(fz_context *ctx, fz_stream *f) { int c; do { - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); } while ((c <= 32) && (iswhite(c))); if (c != EOF) - fz_unread_byte(f); + fz_unread_byte(ctx, f); } static void -lex_comment(fz_stream *f) +lex_comment(fz_context *ctx, fz_stream *f) { int c; do { - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); } while ((c != '\012') && (c != '\015') && (c != EOF)); } static int -lex_number(fz_stream *f, pdf_lexbuf *buf, int c) +lex_number(fz_context *ctx, fz_stream *f, pdf_lexbuf *buf, int c) { int neg = 0; int i = 0; @@ -89,7 +89,7 @@ lex_number(fz_stream *f, pdf_lexbuf *buf, int c) while (1) { - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case '.': @@ -99,7 +99,7 @@ lex_number(fz_stream *f, pdf_lexbuf *buf, int c) /* FIXME: Need overflow check here; do we care? */ break; default: - fz_unread_byte(f); + fz_unread_byte(ctx, f); /* Fallthrough */ case EOF: if (neg) @@ -115,7 +115,7 @@ loop_after_dot: d = 1; while (1) { - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case RANGE_0_9: @@ -125,7 +125,7 @@ loop_after_dot: d *= 10; break; default: - fz_unread_byte(f); + fz_unread_byte(ctx, f); /* Fallthrough */ case EOF: v = (float)i + ((float)n / (float)d); @@ -140,13 +140,13 @@ underflow: /* Ignore any digits after here, because they are too small */ while (1) { - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case RANGE_0_9: break; default: - fz_unread_byte(f); + fz_unread_byte(ctx, f); /* Fallthrough */ case EOF: v = (float)i + ((float)n / (float)d); @@ -159,26 +159,26 @@ underflow: } static void -lex_name(fz_stream *f, pdf_lexbuf *buf) +lex_name(fz_context *ctx, fz_stream *f, pdf_lexbuf *buf) { char *s = buf->scratch; int n = buf->size; while (n > 1) { - int c = fz_read_byte(f); + int c = fz_read_byte(ctx, f); switch (c) { case IS_WHITE: case IS_DELIM: - fz_unread_byte(f); + fz_unread_byte(ctx, f); goto end; case EOF: goto end; case '#': { int d; - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case RANGE_0_9: @@ -191,12 +191,12 @@ lex_name(fz_stream *f, pdf_lexbuf *buf) d = (c - 'A' + 10) << 4; break; default: - fz_unread_byte(f); + fz_unread_byte(ctx, f); /* fallthrough */ case EOF: goto end; } - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case RANGE_0_9: @@ -209,7 +209,7 @@ lex_name(fz_stream *f, pdf_lexbuf *buf) c -= 'A' - 10; break; default: - fz_unread_byte(f); + fz_unread_byte(ctx, f); /* fallthrough */ case EOF: *s++ = d; @@ -232,7 +232,7 @@ end: } static int -lex_string(fz_stream *f, pdf_lexbuf *lb) +lex_string(fz_context *ctx, fz_stream *f, pdf_lexbuf *lb) { char *s = lb->scratch; char *e = s + lb->size; @@ -244,10 +244,10 @@ lex_string(fz_stream *f, pdf_lexbuf *lb) { if (s == e) { - s += pdf_lexbuf_grow(lb); + s += pdf_lexbuf_grow(ctx, lb); e = lb->scratch + lb->size; } - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case EOF: @@ -263,7 +263,7 @@ lex_string(fz_stream *f, pdf_lexbuf *lb) *s++ = c; break; case '\\': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case EOF: @@ -294,26 +294,26 @@ lex_string(fz_stream *f, pdf_lexbuf *lb) break; case RANGE_0_7: oct = c - '0'; - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c >= '0' && c <= '7') { oct = oct * 8 + (c - '0'); - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c >= '0' && c <= '7') oct = oct * 8 + (c - '0'); else if (c != EOF) - fz_unread_byte(f); + fz_unread_byte(ctx, f); } else if (c != EOF) - fz_unread_byte(f); + fz_unread_byte(ctx, f); *s++ = oct; break; case '\n': break; case '\r': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if ((c != '\n') && (c != EOF)) - fz_unread_byte(f); + fz_unread_byte(ctx, f); break; default: *s++ = c; @@ -330,7 +330,7 @@ end: } static int -lex_hex_string(fz_stream *f, pdf_lexbuf *lb) +lex_hex_string(fz_context *ctx, fz_stream *f, pdf_lexbuf *lb) { char *s = lb->scratch; char *e = s + lb->size; @@ -341,10 +341,10 @@ lex_hex_string(fz_stream *f, pdf_lexbuf *lb) { if (s == e) { - s += pdf_lexbuf_grow(lb); + s += pdf_lexbuf_grow(ctx, lb); e = lb->scratch + lb->size; } - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); switch (c) { case IS_WHITE: @@ -365,7 +365,7 @@ lex_hex_string(fz_stream *f, pdf_lexbuf *lb) case EOF: goto end; default: - fz_warn(f->ctx, "ignoring invalid character in hex string"); + fz_warn(ctx, "ignoring invalid character in hex string"); } } end: @@ -416,80 +416,79 @@ void pdf_lexbuf_init(fz_context *ctx, pdf_lexbuf *lb, int size) { lb->size = lb->base_size = size; lb->len = 0; - lb->ctx = ctx; lb->scratch = &lb->buffer[0]; } -void pdf_lexbuf_fin(pdf_lexbuf *lb) +void pdf_lexbuf_fin(fz_context *ctx, pdf_lexbuf *lb) { if (lb && lb->size != lb->base_size) - fz_free(lb->ctx, lb->scratch); + fz_free(ctx, lb->scratch); } -ptrdiff_t pdf_lexbuf_grow(pdf_lexbuf *lb) +ptrdiff_t pdf_lexbuf_grow(fz_context *ctx, pdf_lexbuf *lb) { char *old = lb->scratch; int newsize = lb->size * 2; if (lb->size == lb->base_size) { - lb->scratch = fz_malloc(lb->ctx, newsize); + lb->scratch = fz_malloc(ctx, newsize); memcpy(lb->scratch, lb->buffer, lb->size); } else { - lb->scratch = fz_resize_array(lb->ctx, lb->scratch, newsize, 1); + lb->scratch = fz_resize_array(ctx, lb->scratch, newsize, 1); } lb->size = newsize; return lb->scratch - old; } pdf_token -pdf_lex(fz_stream *f, pdf_lexbuf *buf) +pdf_lex(fz_context *ctx, fz_stream *f, pdf_lexbuf *buf) { while (1) { - int c = fz_read_byte(f); + int c = fz_read_byte(ctx, f); switch (c) { case EOF: return PDF_TOK_EOF; case IS_WHITE: - lex_white(f); + lex_white(ctx, f); break; case '%': - lex_comment(f); + lex_comment(ctx, f); break; case '/': - lex_name(f, buf); + lex_name(ctx, f, buf); return PDF_TOK_NAME; case '(': - return lex_string(f, buf); + return lex_string(ctx, f, buf); case ')': - fz_warn(f->ctx, "lexical error (unexpected ')')"); + fz_warn(ctx, "lexical error (unexpected ')')"); continue; case '<': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c == '<') { return PDF_TOK_OPEN_DICT; } else { - fz_unread_byte(f); - return lex_hex_string(f, buf); + fz_unread_byte(ctx, f); + return lex_hex_string(ctx, f, buf); } case '>': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c == '>') { return PDF_TOK_CLOSE_DICT; } - fz_warn(f->ctx, "lexical error (unexpected '>')"); + fz_warn(ctx, "lexical error (unexpected '>')"); if (c == EOF) { return PDF_TOK_EOF; } - fz_unread_byte(f); + fz_unread_byte(ctx, f); continue; case '[': return PDF_TOK_OPEN_ARRAY; @@ -500,40 +499,40 @@ pdf_lex(fz_stream *f, pdf_lexbuf *buf) case '}': return PDF_TOK_CLOSE_BRACE; case IS_NUMBER: - return lex_number(f, buf, c); + return lex_number(ctx, f, buf, c); default: /* isregular: !isdelim && !iswhite && c != EOF */ - fz_unread_byte(f); - lex_name(f, buf); + fz_unread_byte(ctx, f); + lex_name(ctx, f, buf); return pdf_token_from_keyword(buf->scratch); } } } pdf_token -pdf_lex_no_string(fz_stream *f, pdf_lexbuf *buf) +pdf_lex_no_string(fz_context *ctx, fz_stream *f, pdf_lexbuf *buf) { while (1) { - int c = fz_read_byte(f); + int c = fz_read_byte(ctx, f); switch (c) { case EOF: return PDF_TOK_EOF; case IS_WHITE: - lex_white(f); + lex_white(ctx, f); break; case '%': - lex_comment(f); + lex_comment(ctx, f); break; case '/': - lex_name(f, buf); + lex_name(ctx, f, buf); return PDF_TOK_NAME; case '(': continue; case ')': continue; case '<': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c == '<') { return PDF_TOK_OPEN_DICT; @@ -543,7 +542,7 @@ pdf_lex_no_string(fz_stream *f, pdf_lexbuf *buf) continue; } case '>': - c = fz_read_byte(f); + c = fz_read_byte(ctx, f); if (c == '>') { return PDF_TOK_CLOSE_DICT; @@ -552,7 +551,7 @@ pdf_lex_no_string(fz_stream *f, pdf_lexbuf *buf) { return PDF_TOK_EOF; } - fz_unread_byte(f); + fz_unread_byte(ctx, f); continue; case '[': return PDF_TOK_OPEN_ARRAY; @@ -563,10 +562,10 @@ pdf_lex_no_string(fz_stream *f, pdf_lexbuf *buf) case '}': return PDF_TOK_CLOSE_BRACE; case IS_NUMBER: - return lex_number(f, buf, c); + return lex_number(ctx, f, buf, c); default: /* isregular: !isdelim && !iswhite && c != EOF */ - fz_unread_byte(f); - lex_name(f, buf); + fz_unread_byte(ctx, f); + lex_name(ctx, f, buf); return pdf_token_from_keyword(buf->scratch); } } @@ -581,7 +580,7 @@ void pdf_print_token(fz_context *ctx, fz_buffer *fzbuf, int tok, pdf_lexbuf *buf break; case PDF_TOK_STRING: if (buf->len >= buf->size) - pdf_lexbuf_grow(buf); + pdf_lexbuf_grow(ctx, buf); buf->scratch[buf->len] = 0; fz_buffer_cat_pdf_string(ctx, fzbuf, buf->scratch); break; diff --git a/source/pdf/pdf-nametree.c b/source/pdf/pdf-nametree.c index bcbe8002..eecbb320 100644 --- a/source/pdf/pdf-nametree.c +++ b/source/pdf/pdf-nametree.c @@ -3,52 +3,52 @@ static pdf_obj * pdf_lookup_name_imp(fz_context *ctx, pdf_obj *node, pdf_obj *needle) { - pdf_obj *kids = pdf_dict_gets(node, "Kids"); - pdf_obj *names = pdf_dict_gets(node, "Names"); + pdf_obj *kids = pdf_dict_gets(ctx, node, "Kids"); + pdf_obj *names = pdf_dict_gets(ctx, node, "Names"); - if (pdf_is_array(kids)) + if (pdf_is_array(ctx, kids)) { int l = 0; - int r = pdf_array_len(kids) - 1; + int r = pdf_array_len(ctx, kids) - 1; while (l <= r) { int m = (l + r) >> 1; - pdf_obj *kid = pdf_array_get(kids, m); - pdf_obj *limits = pdf_dict_gets(kid, "Limits"); - pdf_obj *first = pdf_array_get(limits, 0); - pdf_obj *last = pdf_array_get(limits, 1); + pdf_obj *kid = pdf_array_get(ctx, kids, m); + pdf_obj *limits = pdf_dict_gets(ctx, kid, "Limits"); + pdf_obj *first = pdf_array_get(ctx, limits, 0); + pdf_obj *last = pdf_array_get(ctx, limits, 1); - if (pdf_objcmp(needle, first) < 0) + if (pdf_objcmp(ctx, needle, first) < 0) r = m - 1; - else if (pdf_objcmp(needle, last) > 0) + else if (pdf_objcmp(ctx, needle, last) > 0) l = m + 1; else { pdf_obj *obj; - if (pdf_mark_obj(node)) + if (pdf_mark_obj(ctx, node)) break; obj = pdf_lookup_name_imp(ctx, kid, needle); - pdf_unmark_obj(node); + pdf_unmark_obj(ctx, node); return obj; } } } - if (pdf_is_array(names)) + if (pdf_is_array(ctx, names)) { int l = 0; - int r = (pdf_array_len(names) / 2) - 1; + int r = (pdf_array_len(ctx, names) / 2) - 1; while (l <= r) { int m = (l + r) >> 1; int c; - pdf_obj *key = pdf_array_get(names, m * 2); - pdf_obj *val = pdf_array_get(names, m * 2 + 1); + pdf_obj *key = pdf_array_get(ctx, names, m * 2); + pdf_obj *val = pdf_array_get(ctx, names, m * 2 + 1); - c = pdf_objcmp(needle, key); + c = pdf_objcmp(ctx, needle, key); if (c < 0) r = m - 1; else if (c > 0) @@ -60,49 +60,45 @@ pdf_lookup_name_imp(fz_context *ctx, pdf_obj *node, pdf_obj *needle) /* Spec says names should be sorted (hence the binary search, * above), but Acrobat copes with non-sorted. Drop back to a * simple search if the binary search fails. */ - r = pdf_array_len(names)/2; + r = pdf_array_len(ctx, names)/2; for (l = 0; l < r; l++) - if (!pdf_objcmp(needle, pdf_array_get(names, l * 2))) - return pdf_array_get(names, l * 2 + 1); + if (!pdf_objcmp(ctx, needle, pdf_array_get(ctx, names, l * 2))) + return pdf_array_get(ctx, names, l * 2 + 1); } return NULL; } pdf_obj * -pdf_lookup_name(pdf_document *doc, char *which, pdf_obj *needle) +pdf_lookup_name(fz_context *ctx, pdf_document *doc, char *which, pdf_obj *needle) { - fz_context *ctx = doc->ctx; - - pdf_obj *root = pdf_dict_gets(pdf_trailer(doc), "Root"); - pdf_obj *names = pdf_dict_gets(root, "Names"); - pdf_obj *tree = pdf_dict_gets(names, which); + pdf_obj *root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pdf_obj *names = pdf_dict_gets(ctx, root, "Names"); + pdf_obj *tree = pdf_dict_gets(ctx, names, which); return pdf_lookup_name_imp(ctx, tree, needle); } pdf_obj * -pdf_lookup_dest(pdf_document *doc, pdf_obj *needle) +pdf_lookup_dest(fz_context *ctx, pdf_document *doc, pdf_obj *needle) { - fz_context *ctx = doc->ctx; - - pdf_obj *root = pdf_dict_gets(pdf_trailer(doc), "Root"); - pdf_obj *dests = pdf_dict_gets(root, "Dests"); - pdf_obj *names = pdf_dict_gets(root, "Names"); + pdf_obj *root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pdf_obj *dests = pdf_dict_gets(ctx, root, "Dests"); + pdf_obj *names = pdf_dict_gets(ctx, root, "Names"); pdf_obj *dest = NULL; /* PDF 1.1 has destinations in a dictionary */ if (dests) { - if (pdf_is_name(needle)) - return pdf_dict_get(dests, needle); + if (pdf_is_name(ctx, needle)) + return pdf_dict_get(ctx, dests, needle); else - return pdf_dict_gets(dests, pdf_to_str_buf(needle)); + return pdf_dict_gets(ctx, dests, pdf_to_str_buf(ctx, needle)); } /* PDF 1.2 has destinations in a name tree */ if (names && !dest) { - pdf_obj *tree = pdf_dict_gets(names, "Dests"); + pdf_obj *tree = pdf_dict_gets(ctx, names, "Dests"); return pdf_lookup_name_imp(ctx, tree, needle); } @@ -110,54 +106,53 @@ pdf_lookup_dest(pdf_document *doc, pdf_obj *needle) } static void -pdf_load_name_tree_imp(pdf_obj *dict, pdf_document *doc, pdf_obj *node) +pdf_load_name_tree_imp(fz_context *ctx, pdf_obj *dict, pdf_document *doc, pdf_obj *node) { - fz_context *ctx = doc->ctx; - pdf_obj *kids = pdf_dict_gets(node, "Kids"); - pdf_obj *names = pdf_dict_gets(node, "Names"); + pdf_obj *kids = pdf_dict_gets(ctx, node, "Kids"); + pdf_obj *names = pdf_dict_gets(ctx, node, "Names"); int i; UNUSED(ctx); - if (kids && !pdf_mark_obj(node)) + if (kids && !pdf_mark_obj(ctx, node)) { - int len = pdf_array_len(kids); + int len = pdf_array_len(ctx, kids); for (i = 0; i < len; i++) - pdf_load_name_tree_imp(dict, doc, pdf_array_get(kids, i)); - pdf_unmark_obj(node); + pdf_load_name_tree_imp(ctx, dict, doc, pdf_array_get(ctx, kids, i)); + pdf_unmark_obj(ctx, node); } if (names) { - int len = pdf_array_len(names); + int len = pdf_array_len(ctx, names); for (i = 0; i + 1 < len; i += 2) { - pdf_obj *key = pdf_array_get(names, i); - pdf_obj *val = pdf_array_get(names, i + 1); - if (pdf_is_string(key)) + pdf_obj *key = pdf_array_get(ctx, names, i); + pdf_obj *val = pdf_array_get(ctx, names, i + 1); + if (pdf_is_string(ctx, key)) { - key = pdf_to_utf8_name(doc, key); - pdf_dict_put(dict, key, val); - pdf_drop_obj(key); + key = pdf_to_utf8_name(ctx, doc, key); + pdf_dict_put(ctx, dict, key, val); + pdf_drop_obj(ctx, key); } - else if (pdf_is_name(key)) + else if (pdf_is_name(ctx, key)) { - pdf_dict_put(dict, key, val); + pdf_dict_put(ctx, dict, key, val); } } } } pdf_obj * -pdf_load_name_tree(pdf_document *doc, char *which) +pdf_load_name_tree(fz_context *ctx, pdf_document *doc, char *which) { - pdf_obj *root = pdf_dict_gets(pdf_trailer(doc), "Root"); - pdf_obj *names = pdf_dict_gets(root, "Names"); - pdf_obj *tree = pdf_dict_gets(names, which); - if (pdf_is_dict(tree)) + pdf_obj *root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pdf_obj *names = pdf_dict_gets(ctx, root, "Names"); + pdf_obj *tree = pdf_dict_gets(ctx, names, which); + if (pdf_is_dict(ctx, tree)) { - pdf_obj *dict = pdf_new_dict(doc, 100); - pdf_load_name_tree_imp(dict, doc, tree); + pdf_obj *dict = pdf_new_dict(ctx, doc, 100); + pdf_load_name_tree_imp(ctx, dict, doc, tree); return dict; } return NULL; diff --git a/source/pdf/pdf-object.c b/source/pdf/pdf-object.c index c3ac178a..d4b008fb 100644 --- a/source/pdf/pdf-object.c +++ b/source/pdf/pdf-object.c @@ -33,7 +33,7 @@ struct pdf_obj_s int refs; unsigned char kind; unsigned char flags; - pdf_document *doc; + pdf_document *doc; /* KEEP */ int parent_num; union { @@ -63,10 +63,9 @@ struct pdf_obj_s }; pdf_obj * -pdf_new_null(pdf_document *doc) +pdf_new_null(fz_context *ctx, pdf_document *doc) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(null)"); obj->doc = doc; obj->refs = 1; @@ -77,10 +76,9 @@ pdf_new_null(pdf_document *doc) } pdf_obj * -pdf_new_bool(pdf_document *doc, int b) +pdf_new_bool(fz_context *ctx, pdf_document *doc, int b) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(bool)"); obj->doc = doc; obj->refs = 1; @@ -92,10 +90,9 @@ pdf_new_bool(pdf_document *doc, int b) } pdf_obj * -pdf_new_int(pdf_document *doc, int i) +pdf_new_int(fz_context *ctx, pdf_document *doc, int i) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(int)"); obj->doc = doc; obj->refs = 1; @@ -107,10 +104,9 @@ pdf_new_int(pdf_document *doc, int i) } pdf_obj * -pdf_new_real(pdf_document *doc, float f) +pdf_new_real(fz_context *ctx, pdf_document *doc, float f) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(real)"); obj->doc = doc; obj->refs = 1; @@ -122,10 +118,9 @@ pdf_new_real(pdf_document *doc, float f) } pdf_obj * -pdf_new_string(pdf_document *doc, const char *str, int len) +pdf_new_string(fz_context *ctx, pdf_document *doc, const char *str, int len) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj, u.s.buf) + len + 1), "pdf_obj(string)"); obj->doc = doc; obj->refs = 1; @@ -139,10 +134,9 @@ pdf_new_string(pdf_document *doc, const char *str, int len) } pdf_obj * -pdf_new_name(pdf_document *doc, const char *str) +pdf_new_name(fz_context *ctx, pdf_document *doc, const char *str) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj, u.n) + strlen(str) + 1), "pdf_obj(name)"); obj->doc = doc; obj->refs = 1; @@ -154,10 +148,9 @@ pdf_new_name(pdf_document *doc, const char *str) } pdf_obj * -pdf_new_indirect(pdf_document *doc, int num, int gen) +pdf_new_indirect(fz_context *ctx, pdf_document *doc, int num, int gen) { pdf_obj *obj; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(indirect)"); obj->doc = doc; obj->refs = 1; @@ -170,81 +163,77 @@ pdf_new_indirect(pdf_document *doc, int num, int gen) } pdf_obj * -pdf_keep_obj(pdf_obj *obj) +pdf_keep_obj(fz_context *ctx, pdf_obj *obj) { if (obj) obj->refs ++; return obj; } -int pdf_is_indirect(pdf_obj *obj) +int pdf_is_indirect(fz_context *ctx, pdf_obj *obj) { return obj ? obj->kind == PDF_INDIRECT : 0; } #define RESOLVE(obj) \ - do { \ - if (obj && obj->kind == PDF_INDIRECT) \ - {\ - obj = pdf_resolve_indirect(obj); \ - } \ - } while (0) + if (obj && obj->kind == PDF_INDIRECT) \ + obj = pdf_resolve_indirect(ctx, obj); \ -int pdf_is_null(pdf_obj *obj) +int pdf_is_null(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_NULL : 0; } -int pdf_is_bool(pdf_obj *obj) +int pdf_is_bool(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_BOOL : 0; } -int pdf_is_int(pdf_obj *obj) +int pdf_is_int(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_INT : 0; } -int pdf_is_real(pdf_obj *obj) +int pdf_is_real(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_REAL : 0; } -int pdf_is_number(pdf_obj *obj) +int pdf_is_number(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? (obj->kind == PDF_REAL || obj->kind == PDF_INT) : 0; } -int pdf_is_string(pdf_obj *obj) +int pdf_is_string(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_STRING : 0; } -int pdf_is_name(pdf_obj *obj) +int pdf_is_name(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_NAME : 0; } -int pdf_is_array(pdf_obj *obj) +int pdf_is_array(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_ARRAY : 0; } -int pdf_is_dict(pdf_obj *obj) +int pdf_is_dict(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return obj ? obj->kind == PDF_DICT : 0; } -int pdf_to_bool(pdf_obj *obj) +int pdf_to_bool(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -252,7 +241,7 @@ int pdf_to_bool(pdf_obj *obj) return obj->kind == PDF_BOOL ? obj->u.b : 0; } -int pdf_to_int(pdf_obj *obj) +int pdf_to_int(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -264,7 +253,7 @@ int pdf_to_int(pdf_obj *obj) return 0; } -float pdf_to_real(pdf_obj *obj) +float pdf_to_real(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -276,7 +265,7 @@ float pdf_to_real(pdf_obj *obj) return 0; } -char *pdf_to_name(pdf_obj *obj) +char *pdf_to_name(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_NAME) @@ -284,7 +273,7 @@ char *pdf_to_name(pdf_obj *obj) return obj->u.n; } -char *pdf_to_str_buf(pdf_obj *obj) +char *pdf_to_str_buf(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_STRING) @@ -292,7 +281,7 @@ char *pdf_to_str_buf(pdf_obj *obj) return obj->u.s.buf; } -int pdf_to_str_len(pdf_obj *obj) +int pdf_to_str_len(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_STRING) @@ -300,7 +289,7 @@ int pdf_to_str_len(pdf_obj *obj) return obj->u.s.len; } -void pdf_set_int(pdf_obj *obj, int i) +void pdf_set_int(fz_context *ctx, pdf_obj *obj, int i) { if (!obj || obj->kind != PDF_INT) return; @@ -308,7 +297,7 @@ void pdf_set_int(pdf_obj *obj, int i) } /* for use by pdf_crypt_obj_imp to decrypt AES string in place */ -void pdf_set_str_len(pdf_obj *obj, int newlen) +void pdf_set_str_len(fz_context *ctx, pdf_obj *obj, int newlen) { RESOLVE(obj); if (!obj || obj->kind != PDF_STRING) @@ -318,27 +307,27 @@ void pdf_set_str_len(pdf_obj *obj, int newlen) obj->u.s.len = newlen; } -pdf_obj *pdf_to_dict(pdf_obj *obj) +pdf_obj *pdf_to_dict(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); return (obj && obj->kind == PDF_DICT ? obj : NULL); } -int pdf_to_num(pdf_obj *obj) +int pdf_to_num(fz_context *ctx, pdf_obj *obj) { if (!obj || obj->kind != PDF_INDIRECT) return 0; return obj->u.r.num; } -int pdf_to_gen(pdf_obj *obj) +int pdf_to_gen(fz_context *ctx, pdf_obj *obj) { if (!obj || obj->kind != PDF_INDIRECT) return 0; return obj->u.r.gen; } -pdf_document *pdf_get_indirect_document(pdf_obj *obj) +pdf_document *pdf_get_indirect_document(fz_context *ctx, pdf_obj *obj) { if (!obj || obj->kind != PDF_INDIRECT) return NULL; @@ -346,7 +335,7 @@ pdf_document *pdf_get_indirect_document(pdf_obj *obj) } int -pdf_objcmp(pdf_obj *a, pdf_obj *b) +pdf_objcmp(fz_context *ctx, pdf_obj *a, pdf_obj *b) { int i; @@ -404,7 +393,7 @@ pdf_objcmp(pdf_obj *a, pdf_obj *b) if (a->u.a.len != b->u.a.len) return a->u.a.len - b->u.a.len; for (i = 0; i < a->u.a.len; i++) - if (pdf_objcmp(a->u.a.items[i], b->u.a.items[i])) + if (pdf_objcmp(ctx, a->u.a.items[i], b->u.a.items[i])) return 1; return 0; @@ -413,9 +402,9 @@ pdf_objcmp(pdf_obj *a, pdf_obj *b) return a->u.d.len - b->u.d.len; for (i = 0; i < a->u.d.len; i++) { - if (pdf_objcmp(a->u.d.items[i].k, b->u.d.items[i].k)) + if (pdf_objcmp(ctx, a->u.d.items[i].k, b->u.d.items[i].k)) return 1; - if (pdf_objcmp(a->u.d.items[i].v, b->u.d.items[i].v)) + if (pdf_objcmp(ctx, a->u.d.items[i].v, b->u.d.items[i].v)) return 1; } return 0; @@ -445,11 +434,10 @@ pdf_objkindstr(pdf_obj *obj) } pdf_obj * -pdf_new_array(pdf_document *doc, int initialcap) +pdf_new_array(fz_context *ctx, pdf_document *doc, int initialcap) { pdf_obj *obj; int i; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(array)"); obj->doc = doc; @@ -477,12 +465,12 @@ pdf_new_array(pdf_document *doc, int initialcap) } static void -pdf_array_grow(pdf_obj *obj) +pdf_array_grow(fz_context *ctx, pdf_obj *obj) { int i; int new_cap = (obj->u.a.cap * 3) / 2; - obj->u.a.items = fz_resize_array(obj->doc->ctx, obj->u.a.items, new_cap, sizeof(pdf_obj*)); + obj->u.a.items = fz_resize_array(ctx, obj->u.a.items, new_cap, sizeof(pdf_obj*)); obj->u.a.cap = new_cap; for (i = obj->u.a.len ; i < obj->u.a.cap; i++) @@ -490,29 +478,32 @@ pdf_array_grow(pdf_obj *obj) } pdf_obj * -pdf_copy_array(pdf_obj *obj) +pdf_copy_array(fz_context *ctx, pdf_obj *obj) { - pdf_obj *arr; - int i; - int n; - fz_context *ctx = obj->doc->ctx; - RESOLVE(obj); - if (!obj) - return NULL; /* Can't warn :( */ - if (obj->kind != PDF_ARRAY) - fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + if (obj) + { + pdf_document *doc = obj->doc; - arr = pdf_new_array(obj->doc, pdf_array_len(obj)); - n = pdf_array_len(obj); - for (i = 0; i < n; i++) - pdf_array_push(arr, pdf_array_get(obj, i)); + pdf_obj *arr; + int i; + int n; - return arr; + if (obj->kind != PDF_ARRAY) + fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + + arr = pdf_new_array(ctx, doc, pdf_array_len(ctx, obj)); + n = pdf_array_len(ctx, obj); + for (i = 0; i < n; i++) + pdf_array_push(ctx, arr, pdf_array_get(ctx, obj, i)); + + return arr; + } + return NULL; /* Can't warn :( */ } int -pdf_array_len(pdf_obj *obj) +pdf_array_len(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_ARRAY) @@ -521,258 +512,252 @@ pdf_array_len(pdf_obj *obj) } pdf_obj * -pdf_array_get(pdf_obj *obj, int i) +pdf_array_get(fz_context *ctx, pdf_obj *obj, int i) { RESOLVE(obj); - if (!obj || obj->kind != PDF_ARRAY) return NULL; - if (i < 0 || i >= obj->u.a.len) return NULL; - return obj->u.a.items[i]; } -static void object_altered(pdf_obj *obj, pdf_obj *val) +static void object_altered(fz_context *ctx, pdf_obj *obj, pdf_obj *val) { + pdf_document *doc = obj->doc; + /* - parent_num = 0 while an object is being parsed from the file. - No further action is necessary. + parent_num = 0 while an object is being parsed from the file. + No further action is necessary. */ - if (obj->parent_num == 0 || obj->doc->freeze_updates) + if (obj->parent_num == 0 || doc->freeze_updates) return; /* - Otherwise we need to ensure that the containing hierarchy of objects - has been moved to the incremental xref section and the newly linked - object needs to record the parent_num + Otherwise we need to ensure that the containing hierarchy of objects + has been moved to the incremental xref section and the newly linked + object needs to record the parent_num */ - pdf_xref_ensure_incremental_object(obj->doc, obj->parent_num); - pdf_set_obj_parent(val, obj->parent_num); + pdf_xref_ensure_incremental_object(ctx, doc, obj->parent_num); + pdf_set_obj_parent(ctx, val, obj->parent_num); } void -pdf_array_put(pdf_obj *obj, int i, pdf_obj *item) +pdf_array_put(fz_context *ctx, pdf_obj *obj, int i, pdf_obj *item) { RESOLVE(obj); - - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_ARRAY) - fz_warn(obj->doc->ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); - else if (i < 0) - fz_warn(obj->doc->ctx, "assert: index %d < 0", i); - else if (i >= obj->u.a.len) - fz_warn(obj->doc->ctx, "assert: index %d > length %d", i, obj->u.a.len); - else + if (obj) { - pdf_drop_obj(obj->u.a.items[i]); - obj->u.a.items[i] = pdf_keep_obj(item); - } + if (obj->kind != PDF_ARRAY) + fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + else if (i < 0) + fz_warn(ctx, "assert: index %d < 0", i); + else if (i >= obj->u.a.len) + fz_warn(ctx, "assert: index %d > length %d", i, obj->u.a.len); + else + { + pdf_drop_obj(ctx, obj->u.a.items[i]); + obj->u.a.items[i] = pdf_keep_obj(ctx, item); + } - object_altered(obj, item); + object_altered(ctx, obj, item); + } + return; /* Can't warn :( */ } void -pdf_array_push(pdf_obj *obj, pdf_obj *item) +pdf_array_push(fz_context *ctx, pdf_obj *obj, pdf_obj *item) { RESOLVE(obj); - - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_ARRAY) - fz_warn(obj->doc->ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); - else + if (obj) { - if (obj->u.a.len + 1 > obj->u.a.cap) - pdf_array_grow(obj); - obj->u.a.items[obj->u.a.len] = pdf_keep_obj(item); - obj->u.a.len++; - } + if (obj->kind != PDF_ARRAY) + fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + else + { + if (obj->u.a.len + 1 > obj->u.a.cap) + pdf_array_grow(ctx, obj); + obj->u.a.items[obj->u.a.len] = pdf_keep_obj(ctx, item); + obj->u.a.len++; + } - object_altered(obj, item); + object_altered(ctx, obj, item); + } + return; /* Can't warn :( */ } void -pdf_array_push_drop(pdf_obj *obj, pdf_obj *item) +pdf_array_push_drop(fz_context *ctx, pdf_obj *obj, pdf_obj *item) { - fz_context *ctx = obj->doc->ctx; - - fz_try(ctx) - { - pdf_array_push(obj, item); - } - fz_always(ctx) - { - pdf_drop_obj(item); - } - fz_catch(ctx) + RESOLVE(obj); + if (obj) { - fz_rethrow(ctx); + fz_try(ctx) + pdf_array_push(ctx, obj, item); + fz_always(ctx) + pdf_drop_obj(ctx, item); + fz_catch(ctx) + fz_rethrow(ctx); } } void -pdf_array_insert(pdf_obj *obj, pdf_obj *item, int i) +pdf_array_insert(fz_context *ctx, pdf_obj *obj, pdf_obj *item, int i) { RESOLVE(obj); - - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_ARRAY) - fz_warn(obj->doc->ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); - else + if (obj) { - if (i < 0 || i > obj->u.a.len) - fz_throw(obj->doc->ctx, FZ_ERROR_GENERIC, "attempt to insert object %d in array of length %d", i, obj->u.a.len); - if (obj->u.a.len + 1 > obj->u.a.cap) - pdf_array_grow(obj); - memmove(obj->u.a.items + i + 1, obj->u.a.items + i, (obj->u.a.len - i) * sizeof(pdf_obj*)); - obj->u.a.items[i] = pdf_keep_obj(item); - obj->u.a.len++; - } + if (obj->kind != PDF_ARRAY) + fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + else + { + if (i < 0 || i > obj->u.a.len) + fz_throw(ctx, FZ_ERROR_GENERIC, "attempt to insert object %d in array of length %d", i, obj->u.a.len); + if (obj->u.a.len + 1 > obj->u.a.cap) + pdf_array_grow(ctx, obj); + memmove(obj->u.a.items + i + 1, obj->u.a.items + i, (obj->u.a.len - i) * sizeof(pdf_obj*)); + obj->u.a.items[i] = pdf_keep_obj(ctx, item); + obj->u.a.len++; + } - object_altered(obj, item); + object_altered(ctx, obj, item); + } + return; /* Can't warn :( */ } void -pdf_array_insert_drop(pdf_obj *obj, pdf_obj *item, int i) +pdf_array_insert_drop(fz_context *ctx, pdf_obj *obj, pdf_obj *item, int i) { - fz_context *ctx = obj->doc->ctx; - fz_try(ctx) - { - pdf_array_insert(obj, item, i); - } - fz_always(ctx) + RESOLVE(obj); + if (obj) { - pdf_drop_obj(item); - } - fz_catch(ctx) - { - fz_rethrow(ctx); + fz_try(ctx) + pdf_array_insert(ctx, obj, item, i); + fz_always(ctx) + pdf_drop_obj(ctx, item); + fz_catch(ctx) + fz_rethrow(ctx); } } void -pdf_array_delete(pdf_obj *obj, int i) +pdf_array_delete(fz_context *ctx, pdf_obj *obj, int i) { RESOLVE(obj); - - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_ARRAY) - fz_warn(obj->doc->ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); - else + if (obj) { - pdf_drop_obj(obj->u.a.items[i]); - obj->u.a.items[i] = 0; - obj->u.a.len--; - memmove(obj->u.a.items + i, obj->u.a.items + i + 1, (obj->u.a.len - i) * sizeof(pdf_obj*)); + if (obj->kind != PDF_ARRAY) + fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj)); + else + { + pdf_drop_obj(ctx, obj->u.a.items[i]); + obj->u.a.items[i] = 0; + obj->u.a.len--; + memmove(obj->u.a.items + i, obj->u.a.items + i + 1, (obj->u.a.len - i) * sizeof(pdf_obj*)); + } } + return; /* Can't warn :( */ } int -pdf_array_contains(pdf_obj *arr, pdf_obj *obj) +pdf_array_contains(fz_context *ctx, pdf_obj *arr, pdf_obj *obj) { int i, len; - len = pdf_array_len(arr); + len = pdf_array_len(ctx, arr); for (i = 0; i < len; i++) - if (!pdf_objcmp(pdf_array_get(arr, i), obj)) + if (!pdf_objcmp(ctx, pdf_array_get(ctx, arr, i), obj)) return 1; return 0; } -pdf_obj *pdf_new_rect(pdf_document *doc, const fz_rect *rect) +pdf_obj *pdf_new_rect(fz_context *ctx, pdf_document *doc, const fz_rect *rect) { pdf_obj *arr = NULL; pdf_obj *item = NULL; - fz_context *ctx = doc->ctx; fz_var(arr); fz_var(item); fz_try(ctx) { - arr = pdf_new_array(doc, 4); + arr = pdf_new_array(ctx, doc, 4); - item = pdf_new_real(doc, rect->x0); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, rect->x0); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, rect->y0); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, rect->y0); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, rect->x1); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, rect->x1); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, rect->y1); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, rect->y1); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; } fz_catch(ctx) { - pdf_drop_obj(item); - pdf_drop_obj(arr); + pdf_drop_obj(ctx, item); + pdf_drop_obj(ctx, arr); fz_rethrow(ctx); } return arr; } -pdf_obj *pdf_new_matrix(pdf_document *doc, const fz_matrix *mtx) +pdf_obj *pdf_new_matrix(fz_context *ctx, pdf_document *doc, const fz_matrix *mtx) { pdf_obj *arr = NULL; pdf_obj *item = NULL; - fz_context *ctx = doc->ctx; fz_var(arr); fz_var(item); fz_try(ctx) { - arr = pdf_new_array(doc, 6); + arr = pdf_new_array(ctx, doc, 6); - item = pdf_new_real(doc, mtx->a); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->a); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, mtx->b); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->b); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, mtx->c); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->c); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, mtx->d); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->d); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, mtx->e); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->e); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; - item = pdf_new_real(doc, mtx->f); - pdf_array_push(arr, item); - pdf_drop_obj(item); + item = pdf_new_real(ctx, doc, mtx->f); + pdf_array_push(ctx, arr, item); + pdf_drop_obj(ctx, item); item = NULL; } fz_catch(ctx) { - pdf_drop_obj(item); - pdf_drop_obj(arr); + pdf_drop_obj(ctx, item); + pdf_drop_obj(ctx, arr); fz_rethrow(ctx); } @@ -785,15 +770,16 @@ static int keyvalcmp(const void *ap, const void *bp) { const struct keyval *a = ap; const struct keyval *b = bp; - return strcmp(pdf_to_name(a->k), pdf_to_name(b->k)); + if (a->k->kind == PDF_NAME && b->k->kind == PDF_NAME) + return strcmp(a->k->u.n, b->k->u.n); + return 0; } pdf_obj * -pdf_new_dict(pdf_document *doc, int initialcap) +pdf_new_dict(fz_context *ctx, pdf_document *doc, int initialcap) { pdf_obj *obj; int i; - fz_context *ctx = doc->ctx; obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(dict)"); obj->doc = doc; @@ -824,12 +810,12 @@ pdf_new_dict(pdf_document *doc, int initialcap) } static void -pdf_dict_grow(pdf_obj *obj) +pdf_dict_grow(fz_context *ctx, pdf_obj *obj) { int i; int new_cap = (obj->u.d.cap * 3) / 2; - obj->u.d.items = fz_resize_array(obj->doc->ctx, obj->u.d.items, new_cap, sizeof(struct keyval)); + obj->u.d.items = fz_resize_array(ctx, obj->u.d.items, new_cap, sizeof(struct keyval)); obj->u.d.cap = new_cap; for (i = obj->u.d.len; i < obj->u.d.cap; i++) @@ -840,29 +826,31 @@ pdf_dict_grow(pdf_obj *obj) } pdf_obj * -pdf_copy_dict(pdf_obj *obj) +pdf_copy_dict(fz_context *ctx, pdf_obj *obj) { pdf_obj *dict; int i, n; - pdf_document *doc; RESOLVE(obj); - if (!obj) - return NULL; /* Can't warn :( */ - doc = obj->doc; - if (obj->kind != PDF_DICT) - fz_warn(doc->ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); + if (obj) + { + pdf_document *doc = obj->doc; - n = pdf_dict_len(obj); - dict = pdf_new_dict(doc, n); - for (i = 0; i < n; i++) - pdf_dict_put(dict, pdf_dict_get_key(obj, i), pdf_dict_get_val(obj, i)); + if (obj->kind != PDF_DICT) + fz_warn(ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); + + n = pdf_dict_len(ctx, obj); + dict = pdf_new_dict(ctx, doc, n); + for (i = 0; i < n; i++) + pdf_dict_put(ctx, dict, pdf_dict_get_key(ctx, obj, i), pdf_dict_get_val(ctx, obj, i)); - return dict; + return dict; + } + return NULL; /* Can't warn :( */ } int -pdf_dict_len(pdf_obj *obj) +pdf_dict_len(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_DICT) @@ -871,40 +859,36 @@ pdf_dict_len(pdf_obj *obj) } pdf_obj * -pdf_dict_get_key(pdf_obj *obj, int i) +pdf_dict_get_key(fz_context *ctx, pdf_obj *obj, int i) { RESOLVE(obj); if (!obj || obj->kind != PDF_DICT) return NULL; - if (i < 0 || i >= obj->u.d.len) return NULL; - return obj->u.d.items[i].k; } pdf_obj * -pdf_dict_get_val(pdf_obj *obj, int i) +pdf_dict_get_val(fz_context *ctx, pdf_obj *obj, int i) { RESOLVE(obj); if (!obj || obj->kind != PDF_DICT) return NULL; - if (i < 0 || i >= obj->u.d.len) return NULL; - return obj->u.d.items[i].v; } static int -pdf_dict_finds(pdf_obj *obj, const char *key, int *location) +pdf_dict_finds(fz_context *ctx, pdf_obj *obj, const char *key, int *location) { if ((obj->flags & PDF_FLAGS_SORTED) && obj->u.d.len > 0) { int l = 0; int r = obj->u.d.len - 1; - if (strcmp(pdf_to_name(obj->u.d.items[r].k), key) < 0) + if (strcmp(pdf_to_name(ctx, obj->u.d.items[r].k), key) < 0) { if (location) *location = r + 1; @@ -914,7 +898,7 @@ pdf_dict_finds(pdf_obj *obj, const char *key, int *location) while (l <= r) { int m = (l + r) >> 1; - int c = -strcmp(pdf_to_name(obj->u.d.items[m].k), key); + int c = -strcmp(pdf_to_name(ctx, obj->u.d.items[m].k), key); if (c < 0) r = m - 1; else if (c > 0) @@ -931,7 +915,7 @@ pdf_dict_finds(pdf_obj *obj, const char *key, int *location) { int i; for (i = 0; i < obj->u.d.len; i++) - if (strcmp(pdf_to_name(obj->u.d.items[i].k), key) == 0) + if (strcmp(pdf_to_name(ctx, obj->u.d.items[i].k), key) == 0) return i; if (location) @@ -942,7 +926,7 @@ pdf_dict_finds(pdf_obj *obj, const char *key, int *location) } pdf_obj * -pdf_dict_gets(pdf_obj *obj, const char *key) +pdf_dict_gets(fz_context *ctx, pdf_obj *obj, const char *key) { int i; @@ -950,7 +934,7 @@ pdf_dict_gets(pdf_obj *obj, const char *key) if (!obj || obj->kind != PDF_DICT) return NULL; - i = pdf_dict_finds(obj, key, NULL); + i = pdf_dict_finds(ctx, obj, key, NULL); if (i >= 0) return obj->u.d.items[i].v; @@ -958,155 +942,154 @@ pdf_dict_gets(pdf_obj *obj, const char *key) } pdf_obj * -pdf_dict_getp(pdf_obj *obj, const char *keys) +pdf_dict_getp(fz_context *ctx, pdf_obj *obj, const char *keys) { - char buf[256]; - char *k, *e; - - if (strlen(keys)+1 > 256) - fz_throw(obj->doc->ctx, FZ_ERROR_GENERIC, "buffer overflow in pdf_dict_getp"); + RESOLVE(obj); + if (obj) + { + char buf[256]; + char *k, *e; - strcpy(buf, keys); + if (strlen(keys)+1 > 256) + fz_throw(ctx, FZ_ERROR_GENERIC, "buffer overflow in pdf_dict_getp"); - e = buf; - while (*e && obj) - { - k = e; - while (*e != '/' && *e != '\0') - e++; + strcpy(buf, keys); - if (*e == '/') + e = buf; + while (*e && obj) { - *e = '\0'; - e++; + k = e; + while (*e != '/' && *e != '\0') + e++; + + if (*e == '/') + { + *e = '\0'; + e++; + } + + obj = pdf_dict_gets(ctx, obj, k); } - obj = pdf_dict_gets(obj, k); + return obj; } - - return obj; + return NULL; /* Can't warn */ } pdf_obj * -pdf_dict_get(pdf_obj *obj, pdf_obj *key) +pdf_dict_get(fz_context *ctx, pdf_obj *obj, pdf_obj *key) { if (!key || key->kind != PDF_NAME) return NULL; - return pdf_dict_gets(obj, pdf_to_name(key)); + return pdf_dict_gets(ctx, obj, pdf_to_name(ctx, key)); } pdf_obj * -pdf_dict_getsa(pdf_obj *obj, const char *key, const char *abbrev) +pdf_dict_getsa(fz_context *ctx, pdf_obj *obj, const char *key, const char *abbrev) { pdf_obj *v; - v = pdf_dict_gets(obj, key); + v = pdf_dict_gets(ctx, obj, key); if (v) return v; - return pdf_dict_gets(obj, abbrev); + return pdf_dict_gets(ctx, obj, abbrev); } void -pdf_dict_put(pdf_obj *obj, pdf_obj *key, pdf_obj *val) +pdf_dict_put(fz_context *ctx, pdf_obj *obj, pdf_obj *key, pdf_obj *val) { - int location; - char *s; - int i; - RESOLVE(obj); - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_DICT) + if (obj) { - fz_warn(obj->doc->ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); - return; - } + int location; + char *s; + int i; - RESOLVE(key); - if (!key || key->kind != PDF_NAME) - { - fz_warn(obj->doc->ctx, "assert: key is not a name (%s)", pdf_objkindstr(obj)); - return; - } - else - s = pdf_to_name(key); + if (obj->kind != PDF_DICT) + { + fz_warn(ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); + return; + } - if (!val) - { - fz_warn(obj->doc->ctx, "assert: val does not exist for key (%s)", s); - return; - } + RESOLVE(key); + if (!key || key->kind != PDF_NAME) + { + fz_warn(ctx, "assert: key is not a name (%s)", pdf_objkindstr(obj)); + return; + } + else + s = pdf_to_name(ctx, key); + + if (!val) + { + fz_warn(ctx, "assert: val does not exist for key (%s)", s); + return; + } - if (obj->u.d.len > 100 && !(obj->flags & PDF_FLAGS_SORTED)) - pdf_sort_dict(obj); + if (obj->u.d.len > 100 && !(obj->flags & PDF_FLAGS_SORTED)) + pdf_sort_dict(ctx, obj); - i = pdf_dict_finds(obj, s, &location); - if (i >= 0 && i < obj->u.d.len) - { - if (obj->u.d.items[i].v != val) + i = pdf_dict_finds(ctx, obj, s, &location); + if (i >= 0 && i < obj->u.d.len) { - pdf_obj *d = obj->u.d.items[i].v; - obj->u.d.items[i].v = pdf_keep_obj(val); - pdf_drop_obj(d); + if (obj->u.d.items[i].v != val) + { + pdf_obj *d = obj->u.d.items[i].v; + obj->u.d.items[i].v = pdf_keep_obj(ctx, val); + pdf_drop_obj(ctx, d); + } + } + else + { + if (obj->u.d.len + 1 > obj->u.d.cap) + pdf_dict_grow(ctx, obj); + + i = location; + if ((obj->flags & PDF_FLAGS_SORTED) && obj->u.d.len > 0) + memmove(&obj->u.d.items[i + 1], + &obj->u.d.items[i], + (obj->u.d.len - i) * sizeof(struct keyval)); + + obj->u.d.items[i].k = pdf_keep_obj(ctx, key); + obj->u.d.items[i].v = pdf_keep_obj(ctx, val); + obj->u.d.len ++; } - } - else - { - if (obj->u.d.len + 1 > obj->u.d.cap) - pdf_dict_grow(obj); - - i = location; - if ((obj->flags & PDF_FLAGS_SORTED) && obj->u.d.len > 0) - memmove(&obj->u.d.items[i + 1], - &obj->u.d.items[i], - (obj->u.d.len - i) * sizeof(struct keyval)); - - obj->u.d.items[i].k = pdf_keep_obj(key); - obj->u.d.items[i].v = pdf_keep_obj(val); - obj->u.d.len ++; - } - object_altered(obj, val); + object_altered(ctx, obj, val); + } + return; /* Can't warn :( */ } void -pdf_dict_puts(pdf_obj *obj, const char *key, pdf_obj *val) +pdf_dict_puts(fz_context *ctx, pdf_obj *obj, const char *key, pdf_obj *val) { pdf_document *doc = obj->doc; - fz_context *ctx = doc->ctx; - pdf_obj *keyobj = pdf_new_name(doc, key); + pdf_obj *keyobj = pdf_new_name(ctx, doc, key); fz_try(ctx) - { - pdf_dict_put(obj, keyobj, val); - } + pdf_dict_put(ctx, obj, keyobj, val); fz_always(ctx) - { - pdf_drop_obj(keyobj); - } + pdf_drop_obj(ctx, keyobj); fz_catch(ctx) - { fz_rethrow(ctx); - } } void -pdf_dict_puts_drop(pdf_obj *obj, const char *key, pdf_obj *val) +pdf_dict_puts_drop(fz_context *ctx, pdf_obj *obj, const char *key, pdf_obj *val) { pdf_document *doc = obj->doc; - fz_context *ctx = doc->ctx; pdf_obj *keyobj = NULL; fz_var(keyobj); fz_try(ctx) { - keyobj = pdf_new_name(doc, key); - pdf_dict_put(obj, keyobj, val); + keyobj = pdf_new_name(ctx, doc, key); + pdf_dict_put(ctx, obj, keyobj, val); } fz_always(ctx) { - pdf_drop_obj(keyobj); - pdf_drop_obj(val); + pdf_drop_obj(ctx, keyobj); + pdf_drop_obj(ctx, val); } fz_catch(ctx) { @@ -1115,122 +1098,113 @@ pdf_dict_puts_drop(pdf_obj *obj, const char *key, pdf_obj *val) } void -pdf_dict_putp(pdf_obj *obj, const char *keys, pdf_obj *val) +pdf_dict_putp(fz_context *ctx, pdf_obj *obj, const char *keys, pdf_obj *val) { - fz_context *ctx = obj->doc->ctx; - char buf[256]; - char *k, *e; - pdf_obj *cobj = NULL; + RESOLVE(obj); + if (obj) + { + pdf_document *doc = obj->doc; - if (strlen(keys)+1 > 256) - fz_throw(ctx, FZ_ERROR_GENERIC, "buffer overflow in pdf_dict_putp"); + char buf[256]; + char *k, *e; + pdf_obj *cobj = NULL; - strcpy(buf, keys); + if (strlen(keys)+1 > 256) + fz_throw(ctx, FZ_ERROR_GENERIC, "buffer overflow in pdf_dict_putp"); - e = buf; - while (*e) - { - k = e; - while (*e != '/' && *e != '\0') - e++; + strcpy(buf, keys); - if (*e == '/') + e = buf; + while (*e) { - *e = '\0'; - e++; - } + k = e; + while (*e != '/' && *e != '\0') + e++; - if (*e) - { - /* Not the last key in the key path. Create subdict if not already there. */ - cobj = pdf_dict_gets(obj, k); - if (cobj == NULL) + if (*e == '/') { - cobj = pdf_new_dict(obj->doc, 1); - fz_try(ctx) - { - pdf_dict_puts(obj, k, cobj); - } - fz_always(ctx) - { - pdf_drop_obj(cobj); - } - fz_catch(ctx) + *e = '\0'; + e++; + } + + if (*e) + { + /* Not the last key in the key path. Create subdict if not already there. */ + cobj = pdf_dict_gets(ctx, obj, k); + if (cobj == NULL) { - fz_rethrow(ctx); + cobj = pdf_new_dict(ctx, doc, 1); + fz_try(ctx) + pdf_dict_puts(ctx, obj, k, cobj); + fz_always(ctx) + pdf_drop_obj(ctx, cobj); + fz_catch(ctx) + fz_rethrow(ctx); } + /* Move to subdict */ + obj = cobj; } - /* Move to subdict */ - obj = cobj; - } - else - { - /* Last key. Use it to store the value */ - /* Use val = NULL to request delete */ - if (val) - pdf_dict_puts(obj, k, val); else - pdf_dict_dels(obj, k); + { + /* Last key. Use it to store the value */ + /* Use val = NULL to request delete */ + if (val) + pdf_dict_puts(ctx, obj, k, val); + else + pdf_dict_dels(ctx, obj, k); + } } } } void -pdf_dict_putp_drop(pdf_obj *obj, const char *keys, pdf_obj *val) +pdf_dict_putp_drop(fz_context *ctx, pdf_obj *obj, const char *keys, pdf_obj *val) { - fz_context *ctx = obj->doc->ctx; - fz_try(ctx) - { - pdf_dict_putp(obj, keys, val); - } + pdf_dict_putp(ctx, obj, keys, val); fz_always(ctx) - { - pdf_drop_obj(val); - } + pdf_drop_obj(ctx, val); fz_catch(ctx) - { fz_rethrow(ctx); - } } void -pdf_dict_dels(pdf_obj *obj, const char *key) +pdf_dict_dels(fz_context *ctx, pdf_obj *obj, const char *key) { RESOLVE(obj); - - if (!obj) - return; /* Can't warn :( */ - if (obj->kind != PDF_DICT) - fz_warn(obj->doc->ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); - else + if (obj) { - int i = pdf_dict_finds(obj, key, NULL); - if (i >= 0) + if (obj->kind != PDF_DICT) + fz_warn(ctx, "assert: not a dict (%s)", pdf_objkindstr(obj)); + else { - pdf_drop_obj(obj->u.d.items[i].k); - pdf_drop_obj(obj->u.d.items[i].v); - obj->flags &= ~PDF_FLAGS_SORTED; - obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1]; - obj->u.d.len --; + int i = pdf_dict_finds(ctx, obj, key, NULL); + if (i >= 0) + { + pdf_drop_obj(ctx, obj->u.d.items[i].k); + pdf_drop_obj(ctx, obj->u.d.items[i].v); + obj->flags &= ~PDF_FLAGS_SORTED; + obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1]; + obj->u.d.len --; + } } - } - object_altered(obj, NULL); + object_altered(ctx, obj, NULL); + } + return; /* Can't warn :( */ } void -pdf_dict_del(pdf_obj *obj, pdf_obj *key) +pdf_dict_del(fz_context *ctx, pdf_obj *obj, pdf_obj *key) { RESOLVE(key); - if (!key || key->kind != PDF_NAME) - fz_warn(obj->doc->ctx, "assert: key is not a name (%s)", pdf_objkindstr(obj)); - else - pdf_dict_dels(obj, key->u.n); + if (key && key->kind == PDF_NAME) + pdf_dict_dels(ctx, obj, key->u.n); + /* else Can't warn */ } void -pdf_sort_dict(pdf_obj *obj) +pdf_sort_dict(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj || obj->kind != PDF_DICT) @@ -1243,7 +1217,7 @@ pdf_sort_dict(pdf_obj *obj) } int -pdf_obj_marked(pdf_obj *obj) +pdf_obj_marked(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -1252,7 +1226,7 @@ pdf_obj_marked(pdf_obj *obj) } int -pdf_mark_obj(pdf_obj *obj) +pdf_mark_obj(fz_context *ctx, pdf_obj *obj) { int marked; RESOLVE(obj); @@ -1264,7 +1238,7 @@ pdf_mark_obj(pdf_obj *obj) } void -pdf_unmark_obj(pdf_obj *obj) +pdf_unmark_obj(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -1273,7 +1247,7 @@ pdf_unmark_obj(pdf_obj *obj) } void -pdf_set_obj_memo(pdf_obj *obj, int memo) +pdf_set_obj_memo(fz_context *ctx, pdf_obj *obj, int memo) { obj->flags |= PDF_FLAGS_MEMO; if (memo) @@ -1283,7 +1257,7 @@ pdf_set_obj_memo(pdf_obj *obj, int memo) } int -pdf_obj_memo(pdf_obj *obj, int *memo) +pdf_obj_memo(fz_context *ctx, pdf_obj *obj, int *memo) { if (!(obj->flags & PDF_FLAGS_MEMO)) return 0; @@ -1291,7 +1265,7 @@ pdf_obj_memo(pdf_obj *obj, int *memo) return 1; } -int pdf_obj_is_dirty(pdf_obj *obj) +int pdf_obj_is_dirty(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -1299,7 +1273,7 @@ int pdf_obj_is_dirty(pdf_obj *obj) return !!(obj->flags & PDF_FLAGS_DIRTY); } -void pdf_dirty_obj(pdf_obj *obj) +void pdf_dirty_obj(fz_context *ctx, pdf_obj *obj) { RESOLVE(obj); if (!obj) @@ -1307,7 +1281,7 @@ void pdf_dirty_obj(pdf_obj *obj) obj->flags |= PDF_FLAGS_DIRTY; } -void pdf_clean_obj(pdf_obj *obj) +void pdf_clean_obj(fz_context *ctx, pdf_obj *obj) { if (!obj) return; @@ -1315,27 +1289,25 @@ void pdf_clean_obj(pdf_obj *obj) } static void -pdf_drop_array(pdf_obj *obj) +pdf_drop_array(fz_context *ctx, pdf_obj *obj) { - fz_context *ctx = obj->doc->ctx; int i; for (i = 0; i < obj->u.a.len; i++) - pdf_drop_obj(obj->u.a.items[i]); + pdf_drop_obj(ctx, obj->u.a.items[i]); fz_free(ctx, obj->u.a.items); fz_free(ctx, obj); } static void -pdf_drop_dict(pdf_obj *obj) +pdf_drop_dict(fz_context *ctx, pdf_obj *obj) { int i; - fz_context *ctx = obj->doc->ctx; for (i = 0; i < obj->u.d.len; i++) { - pdf_drop_obj(obj->u.d.items[i].k); - pdf_drop_obj(obj->u.d.items[i].v); + pdf_drop_obj(ctx, obj->u.d.items[i].k); + pdf_drop_obj(ctx, obj->u.d.items[i].v); } fz_free(ctx, obj->u.d.items); @@ -1343,22 +1315,23 @@ pdf_drop_dict(pdf_obj *obj) } void -pdf_drop_obj(pdf_obj *obj) +pdf_drop_obj(fz_context *ctx, pdf_obj *obj) { - if (!obj) - return; - if (--obj->refs) - return; - if (obj->kind == PDF_ARRAY) - pdf_drop_array(obj); - else if (obj->kind == PDF_DICT) - pdf_drop_dict(obj); - else - fz_free(obj->doc->ctx, obj); + if (obj) + { + if (--obj->refs) + return; + if (obj->kind == PDF_ARRAY) + pdf_drop_array(ctx, obj); + else if (obj->kind == PDF_DICT) + pdf_drop_dict(ctx, obj); + else + fz_free(ctx, obj); + } } void -pdf_set_obj_parent(pdf_obj *obj, int num) +pdf_set_obj_parent(fz_context *ctx, pdf_obj *obj, int num) { int n, i; @@ -1370,39 +1343,38 @@ pdf_set_obj_parent(pdf_obj *obj, int num) switch(obj->kind) { case PDF_ARRAY: - n = pdf_array_len(obj); + n = pdf_array_len(ctx, obj); for (i = 0; i < n; i++) - pdf_set_obj_parent(pdf_array_get(obj, i), num); + pdf_set_obj_parent(ctx, pdf_array_get(ctx, obj, i), num); break; case PDF_DICT: - n = pdf_dict_len(obj); + n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) - pdf_set_obj_parent(pdf_dict_get_val(obj, i), num); + pdf_set_obj_parent(ctx, pdf_dict_get_val(ctx, obj, i), num); break; } } -int pdf_obj_parent_num(pdf_obj *obj) +int pdf_obj_parent_num(fz_context *ctx, pdf_obj *obj) { return obj->parent_num; } -pdf_obj *pdf_new_obj_from_str(pdf_document *doc, const char *src) +pdf_obj *pdf_new_obj_from_str(fz_context *ctx, pdf_document *doc, const char *src) { pdf_obj *result; pdf_lexbuf lexbuf; - fz_context *ctx = doc->ctx; fz_stream *stream = fz_open_memory(ctx, (unsigned char *)src, strlen(src)); pdf_lexbuf_init(ctx, &lexbuf, PDF_LEXBUF_SMALL); fz_try(ctx) { - result = pdf_parse_stm_obj(doc, stream, &lexbuf); + result = pdf_parse_stm_obj(ctx, doc, stream, &lexbuf); } fz_always(ctx) { - pdf_lexbuf_fin(&lexbuf); - fz_drop_stream(stream); + pdf_lexbuf_fin(ctx, &lexbuf); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -1426,7 +1398,7 @@ struct fmt int last; }; -static void fmt_obj(struct fmt *fmt, pdf_obj *obj); +static void fmt_obj(fz_context *ctx, struct fmt *fmt, pdf_obj *obj); static inline int iswhite(int ch) { @@ -1450,11 +1422,11 @@ static inline int isdelim(int ch) ch == '%'; } -static inline void fmt_putc(struct fmt *fmt, int c) +static inline void fmt_putc(fz_context *ctx, struct fmt *fmt, int c) { if (fmt->sep && !isdelim(fmt->last) && !isdelim(c)) { fmt->sep = 0; - fmt_putc(fmt, ' '); + fmt_putc(ctx, fmt, ' '); } fmt->sep = 0; @@ -1471,201 +1443,201 @@ static inline void fmt_putc(struct fmt *fmt, int c) fmt->last = c; } -static inline void fmt_indent(struct fmt *fmt) +static inline void fmt_indent(fz_context *ctx, struct fmt *fmt) { int i = fmt->indent; while (i--) { - fmt_putc(fmt, ' '); - fmt_putc(fmt, ' '); + fmt_putc(ctx, fmt, ' '); + fmt_putc(ctx, fmt, ' '); } } -static inline void fmt_puts(struct fmt *fmt, char *s) +static inline void fmt_puts(fz_context *ctx, struct fmt *fmt, char *s) { while (*s) - fmt_putc(fmt, *s++); + fmt_putc(ctx, fmt, *s++); } -static inline void fmt_sep(struct fmt *fmt) +static inline void fmt_sep(fz_context *ctx, struct fmt *fmt) { fmt->sep = 1; } -static void fmt_str(struct fmt *fmt, pdf_obj *obj) +static void fmt_str(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { - char *s = pdf_to_str_buf(obj); - int n = pdf_to_str_len(obj); + char *s = pdf_to_str_buf(ctx, obj); + int n = pdf_to_str_len(ctx, obj); int i, c; - fmt_putc(fmt, '('); + fmt_putc(ctx, fmt, '('); for (i = 0; i < n; i++) { c = (unsigned char)s[i]; if (c == '\n') - fmt_puts(fmt, "\\n"); + fmt_puts(ctx, fmt, "\\n"); else if (c == '\r') - fmt_puts(fmt, "\\r"); + fmt_puts(ctx, fmt, "\\r"); else if (c == '\t') - fmt_puts(fmt, "\\t"); + fmt_puts(ctx, fmt, "\\t"); else if (c == '\b') - fmt_puts(fmt, "\\b"); + fmt_puts(ctx, fmt, "\\b"); else if (c == '\f') - fmt_puts(fmt, "\\f"); + fmt_puts(ctx, fmt, "\\f"); else if (c == '(') - fmt_puts(fmt, "\\("); + fmt_puts(ctx, fmt, "\\("); else if (c == ')') - fmt_puts(fmt, "\\)"); + fmt_puts(ctx, fmt, "\\)"); else if (c == '\\') - fmt_puts(fmt, "\\\\"); + fmt_puts(ctx, fmt, "\\\\"); else if (c < 32 || c >= 127) { - fmt_putc(fmt, '\\'); - fmt_putc(fmt, '0' + ((c / 64) & 7)); - fmt_putc(fmt, '0' + ((c / 8) & 7)); - fmt_putc(fmt, '0' + ((c) & 7)); + fmt_putc(ctx, fmt, '\\'); + fmt_putc(ctx, fmt, '0' + ((c / 64) & 7)); + fmt_putc(ctx, fmt, '0' + ((c / 8) & 7)); + fmt_putc(ctx, fmt, '0' + ((c) & 7)); } else - fmt_putc(fmt, c); + fmt_putc(ctx, fmt, c); } - fmt_putc(fmt, ')'); + fmt_putc(ctx, fmt, ')'); } -static void fmt_hex(struct fmt *fmt, pdf_obj *obj) +static void fmt_hex(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { - char *s = pdf_to_str_buf(obj); - int n = pdf_to_str_len(obj); + char *s = pdf_to_str_buf(ctx, obj); + int n = pdf_to_str_len(ctx, obj); int i, b, c; - fmt_putc(fmt, '<'); + fmt_putc(ctx, fmt, '<'); for (i = 0; i < n; i++) { b = (unsigned char) s[i]; c = (b >> 4) & 0x0f; - fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + fmt_putc(ctx, fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); c = (b) & 0x0f; - fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + fmt_putc(ctx, fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); } - fmt_putc(fmt, '>'); + fmt_putc(ctx, fmt, '>'); } -static void fmt_name(struct fmt *fmt, pdf_obj *obj) +static void fmt_name(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { - unsigned char *s = (unsigned char *) pdf_to_name(obj); + unsigned char *s = (unsigned char *) pdf_to_name(ctx, obj); int i, c; - fmt_putc(fmt, '/'); + fmt_putc(ctx, fmt, '/'); for (i = 0; s[i]; i++) { if (isdelim(s[i]) || iswhite(s[i]) || s[i] == '#' || s[i] < 32 || s[i] >= 127) { - fmt_putc(fmt, '#'); + fmt_putc(ctx, fmt, '#'); c = (s[i] >> 4) & 0xf; - fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + fmt_putc(ctx, fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); c = s[i] & 0xf; - fmt_putc(fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); + fmt_putc(ctx, fmt, c < 0xA ? c + '0' : c + 'A' - 0xA); } else { - fmt_putc(fmt, s[i]); + fmt_putc(ctx, fmt, s[i]); } } } -static void fmt_array(struct fmt *fmt, pdf_obj *obj) +static void fmt_array(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { int i, n; - n = pdf_array_len(obj); + n = pdf_array_len(ctx, obj); if (fmt->tight) { - fmt_putc(fmt, '['); + fmt_putc(ctx, fmt, '['); for (i = 0; i < n; i++) { - fmt_obj(fmt, pdf_array_get(obj, i)); - fmt_sep(fmt); + fmt_obj(ctx, fmt, pdf_array_get(ctx, obj, i)); + fmt_sep(ctx, fmt); } - fmt_putc(fmt, ']'); + fmt_putc(ctx, fmt, ']'); } else { - fmt_puts(fmt, "[ "); + fmt_puts(ctx, fmt, "[ "); for (i = 0; i < n; i++) { if (fmt->col > 60) { - fmt_putc(fmt, '\n'); - fmt_indent(fmt); + fmt_putc(ctx, fmt, '\n'); + fmt_indent(ctx, fmt); } - fmt_obj(fmt, pdf_array_get(obj, i)); - fmt_putc(fmt, ' '); + fmt_obj(ctx, fmt, pdf_array_get(ctx, obj, i)); + fmt_putc(ctx, fmt, ' '); } - fmt_putc(fmt, ']'); - fmt_sep(fmt); + fmt_putc(ctx, fmt, ']'); + fmt_sep(ctx, fmt); } } -static void fmt_dict(struct fmt *fmt, pdf_obj *obj) +static void fmt_dict(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { int i, n; pdf_obj *key, *val; - n = pdf_dict_len(obj); + n = pdf_dict_len(ctx, obj); if (fmt->tight) { - fmt_puts(fmt, "<<"); + fmt_puts(ctx, fmt, "<<"); for (i = 0; i < n; i++) { - fmt_obj(fmt, pdf_dict_get_key(obj, i)); - fmt_sep(fmt); - fmt_obj(fmt, pdf_dict_get_val(obj, i)); - fmt_sep(fmt); + fmt_obj(ctx, fmt, pdf_dict_get_key(ctx, obj, i)); + fmt_sep(ctx, fmt); + fmt_obj(ctx, fmt, pdf_dict_get_val(ctx, obj, i)); + fmt_sep(ctx, fmt); } - fmt_puts(fmt, ">>"); + fmt_puts(ctx, fmt, ">>"); } else { - fmt_puts(fmt, "<<\n"); + fmt_puts(ctx, fmt, "<<\n"); fmt->indent ++; for (i = 0; i < n; i++) { - key = pdf_dict_get_key(obj, i); - val = pdf_dict_get_val(obj, i); - fmt_indent(fmt); - fmt_obj(fmt, key); - fmt_putc(fmt, ' '); - if (!pdf_is_indirect(val) && pdf_is_array(val)) + key = pdf_dict_get_key(ctx, obj, i); + val = pdf_dict_get_val(ctx, obj, i); + fmt_indent(ctx, fmt); + fmt_obj(ctx, fmt, key); + fmt_putc(ctx, fmt, ' '); + if (!pdf_is_indirect(ctx, val) && pdf_is_array(ctx, val)) fmt->indent ++; - fmt_obj(fmt, val); - fmt_putc(fmt, '\n'); - if (!pdf_is_indirect(val) && pdf_is_array(val)) + fmt_obj(ctx, fmt, val); + fmt_putc(ctx, fmt, '\n'); + if (!pdf_is_indirect(ctx, val) && pdf_is_array(ctx, val)) fmt->indent --; } fmt->indent --; - fmt_indent(fmt); - fmt_puts(fmt, ">>"); + fmt_indent(ctx, fmt); + fmt_puts(ctx, fmt, ">>"); } } -static void fmt_obj(struct fmt *fmt, pdf_obj *obj) +static void fmt_obj(fz_context *ctx, struct fmt *fmt, pdf_obj *obj) { char buf[256]; if (!obj) - fmt_puts(fmt, "<NULL>"); - else if (pdf_is_indirect(obj)) + fmt_puts(ctx, fmt, "<NULL>"); + else if (pdf_is_indirect(ctx, obj)) { - fz_snprintf(buf, sizeof buf, "%d %d R", pdf_to_num(obj), pdf_to_gen(obj)); - fmt_puts(fmt, buf); - } - else if (pdf_is_null(obj)) - fmt_puts(fmt, "null"); - else if (pdf_is_bool(obj)) - fmt_puts(fmt, pdf_to_bool(obj) ? "true" : "false"); - else if (pdf_is_int(obj)) + fz_snprintf(buf, sizeof buf, "%d %d R", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); + fmt_puts(ctx, fmt, buf); + } + else if (pdf_is_null(ctx, obj)) + fmt_puts(ctx, fmt, "null"); + else if (pdf_is_bool(ctx, obj)) + fmt_puts(ctx, fmt, pdf_to_bool(ctx, obj) ? "true" : "false"); + else if (pdf_is_int(ctx, obj)) { - fz_snprintf(buf, sizeof buf, "%d", pdf_to_int(obj)); - fmt_puts(fmt, buf); + fz_snprintf(buf, sizeof buf, "%d", pdf_to_int(ctx, obj)); + fmt_puts(ctx, fmt, buf); } - else if (pdf_is_real(obj)) + else if (pdf_is_real(ctx, obj)) { - fz_snprintf(buf, sizeof buf, "%g", pdf_to_real(obj)); - fmt_puts(fmt, buf); + fz_snprintf(buf, sizeof buf, "%g", pdf_to_real(ctx, obj)); + fmt_puts(ctx, fmt, buf); } - else if (pdf_is_string(obj)) + else if (pdf_is_string(ctx, obj)) { - char *str = pdf_to_str_buf(obj); - int len = pdf_to_str_len(obj); + char *str = pdf_to_str_buf(ctx, obj); + int len = pdf_to_str_len(ctx, obj); int added = 0; int i, c; for (i = 0; i < len; i++) { @@ -1676,22 +1648,22 @@ static void fmt_obj(struct fmt *fmt, pdf_obj *obj) added += 3; } if (added < len) - fmt_str(fmt, obj); + fmt_str(ctx, fmt, obj); else - fmt_hex(fmt, obj); - } - else if (pdf_is_name(obj)) - fmt_name(fmt, obj); - else if (pdf_is_array(obj)) - fmt_array(fmt, obj); - else if (pdf_is_dict(obj)) - fmt_dict(fmt, obj); + fmt_hex(ctx, fmt, obj); + } + else if (pdf_is_name(ctx, obj)) + fmt_name(ctx, fmt, obj); + else if (pdf_is_array(ctx, obj)) + fmt_array(ctx, fmt, obj); + else if (pdf_is_dict(ctx, obj)) + fmt_dict(ctx, fmt, obj); else - fmt_puts(fmt, "<unknown object>"); + fmt_puts(ctx, fmt, "<unknown object>"); } int -pdf_sprint_obj(char *s, int n, pdf_obj *obj, int tight) +pdf_sprint_obj(fz_context *ctx, char *s, int n, pdf_obj *obj, int tight) { struct fmt fmt; @@ -1704,7 +1676,7 @@ pdf_sprint_obj(char *s, int n, pdf_obj *obj, int tight) fmt.buf = s; fmt.cap = n; fmt.len = 0; - fmt_obj(&fmt, obj); + fmt_obj(ctx, &fmt, obj); if (fmt.buf && fmt.len < fmt.cap) fmt.buf[fmt.len] = '\0'; @@ -1713,67 +1685,67 @@ pdf_sprint_obj(char *s, int n, pdf_obj *obj, int tight) } int -pdf_fprint_obj(FILE *fp, pdf_obj *obj, int tight) +pdf_fprint_obj(fz_context *ctx, FILE *fp, pdf_obj *obj, int tight) { char buf[1024]; char *ptr; int n; - n = pdf_sprint_obj(NULL, 0, obj, tight); + n = pdf_sprint_obj(ctx, NULL, 0, obj, tight); if ((n + 1) < sizeof buf) { - pdf_sprint_obj(buf, sizeof buf, obj, tight); + pdf_sprint_obj(ctx, buf, sizeof buf, obj, tight); fputs(buf, fp); fputc('\n', fp); } else { - ptr = fz_malloc(obj->doc->ctx, n + 1); - pdf_sprint_obj(ptr, n + 1, obj, tight); + ptr = fz_malloc(ctx, n + 1); + pdf_sprint_obj(ctx, ptr, n + 1, obj, tight); fputs(ptr, fp); fputc('\n', fp); - fz_free(obj->doc->ctx, ptr); + fz_free(ctx, ptr); } return n; } -int pdf_output_obj(fz_output *out, pdf_obj *obj, int tight) +int pdf_output_obj(fz_context *ctx, fz_output *out, pdf_obj *obj, int tight) { char buf[1024]; char *ptr; int n; - n = pdf_sprint_obj(NULL, 0, obj, tight); + n = pdf_sprint_obj(ctx, NULL, 0, obj, tight); if ((n + 1) < sizeof buf) { - pdf_sprint_obj(buf, sizeof buf, obj, tight); - fz_printf(out, "%s\n", buf); + pdf_sprint_obj(ctx, buf, sizeof buf, obj, tight); + fz_printf(ctx, out, "%s\n", buf); } else { - ptr = fz_malloc(obj->doc->ctx, n + 1); - pdf_sprint_obj(ptr, n + 1, obj, tight); - fz_printf(out, "%s\n", ptr); - fz_free(obj->doc->ctx, ptr); + ptr = fz_malloc(ctx, n + 1); + pdf_sprint_obj(ctx, ptr, n + 1, obj, tight); + fz_printf(ctx, out, "%s\n", ptr); + fz_free(ctx, ptr); } return n; } #ifndef NDEBUG void -pdf_print_obj(pdf_obj *obj) +pdf_print_obj(fz_context *ctx, pdf_obj *obj) { - pdf_fprint_obj(stdout, obj, 0); + pdf_fprint_obj(ctx, stdout, obj, 0); } void -pdf_print_ref(pdf_obj *ref) +pdf_print_ref(fz_context *ctx, pdf_obj *ref) { - pdf_print_obj(pdf_resolve_indirect(ref)); + pdf_print_obj(ctx, pdf_resolve_indirect(ctx, ref)); } #endif -int pdf_obj_refs(pdf_obj *ref) +int pdf_obj_refs(fz_context *ctx, pdf_obj *ref) { return (ref ? ref->refs : 0); } diff --git a/source/pdf/pdf-op-buffer.c b/source/pdf/pdf-op-buffer.c index 6142620c..e2bbd343 100644 --- a/source/pdf/pdf-op-buffer.c +++ b/source/pdf/pdf-op-buffer.c @@ -9,18 +9,18 @@ typedef struct pdf_buffer_state_s pdf_buffer_state; static void -put_hexstring(pdf_csi *csi, fz_output *out) +put_hexstring(fz_context *ctx, fz_output *out, pdf_csi *csi) { int i; - fz_printf(out, "<"); + fz_printf(ctx, out, "<"); for (i = 0; i < csi->string_len; i++) - fz_printf(out, "%02x", csi->string[i]); - fz_printf(out, ">"); + fz_printf(ctx, out, "%02x", csi->string[i]); + fz_printf(ctx, out, ">"); } static void -put_string(pdf_csi *csi, fz_output *out) +put_string(fz_context *ctx, fz_output *out, pdf_csi *csi) { int i; @@ -28,40 +28,40 @@ put_string(pdf_csi *csi, fz_output *out) if (csi->string[i] < 32 || csi->string[i] >= 127) break; if (i < csi->string_len) - put_hexstring(csi, out); + put_hexstring(ctx, out, csi); else { - fz_printf(out, "("); + fz_printf(ctx, out, "("); for (i = 0; i < csi->string_len; i++) { char c = csi->string[i]; switch (c) { case '(': - fz_printf(out, "\\("); + fz_printf(ctx, out, "\\("); break; case ')': - fz_printf(out, "\\)"); + fz_printf(ctx, out, "\\)"); break; case '\\': - fz_printf(out, "\\\\"); + fz_printf(ctx, out, "\\\\"); break; default: - fz_printf(out, "%c", csi->string[i]); + fz_printf(ctx, out, "%c", csi->string[i]); break; } } - fz_printf(out, ")"); + fz_printf(ctx, out, ")"); } } static void -put_string_or_obj(pdf_csi *csi, fz_output *out) +put_string_or_obj(fz_context *ctx, fz_output *out, pdf_csi *csi) { if (csi->string_len) - put_string(csi, out); + put_string(ctx, out, csi); else - pdf_output_obj(out, csi->obj, 1); + pdf_output_obj(ctx, out, csi->obj, 1); } static void @@ -69,9 +69,9 @@ pdf_buffer_dquote(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f ", csi->stack[0], csi->stack[1]); - put_string_or_obj(csi, state->out); - fz_printf(state->out, " \"\n"); + fz_printf(state->ctx, state->out, "%f %f ", csi->stack[0], csi->stack[1]); + put_string_or_obj(state->ctx, state->out, csi); + fz_printf(state->ctx, state->out, " \"\n"); } static void @@ -79,8 +79,8 @@ pdf_buffer_squote(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - put_string_or_obj(csi, state->out); - fz_printf(state->out, " \'\n"); + put_string_or_obj(state->ctx, state->out, csi); + fz_printf(state->ctx, state->out, " \'\n"); } static void @@ -88,7 +88,7 @@ pdf_buffer_B(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "B\n"); + fz_printf(state->ctx, state->out, "B\n"); } static void @@ -96,7 +96,7 @@ pdf_buffer_Bstar(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "B*\n"); + fz_printf(state->ctx, state->out, "B*\n"); } static void @@ -104,9 +104,9 @@ pdf_buffer_BDC(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s ", csi->name); - pdf_output_obj(state->out, csi->obj, 1); - fz_printf(state->out, " BDC\n"); + fz_printf(state->ctx, state->out, "/%s ", csi->name); + pdf_output_obj(state->ctx, state->out, csi->obj, 1); + fz_printf(state->ctx, state->out, " BDC\n"); } static void @@ -120,7 +120,7 @@ pdf_buffer_BI(pdf_csi *csi, void *state_) const char *match; const char *match2; pdf_obj *filter; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; if (csi->img == NULL) return; @@ -163,44 +163,44 @@ pdf_buffer_BI(pdf_csi *csi, void *state_) return; } - filter = pdf_dict_gets(csi->obj, "Filter"); + filter = pdf_dict_gets(ctx, csi->obj, "Filter"); if (filter == NULL) - filter = pdf_dict_gets(csi->obj, "F"); + filter = pdf_dict_gets(ctx, csi->obj, "F"); if (match == NULL) { /* Remove any filter entry (e.g. Ascii85Decode) */ if (filter) { - pdf_dict_dels(csi->obj, "Filter"); - pdf_dict_dels(csi->obj, "F"); + pdf_dict_dels(ctx, csi->obj, "Filter"); + pdf_dict_dels(ctx, csi->obj, "F"); } - pdf_dict_dels(csi->obj, "DecodeParms"); - pdf_dict_dels(csi->obj, "DP"); + pdf_dict_dels(ctx, csi->obj, "DecodeParms"); + pdf_dict_dels(ctx, csi->obj, "DP"); } - else if (pdf_is_array(filter)) + else if (pdf_is_array(ctx, filter)) { - int l = pdf_array_len(filter); - pdf_obj *o = (l == 0 ? NULL : pdf_array_get(filter, l-1)); - const char *fil = pdf_to_name(o); + int l = pdf_array_len(ctx, filter); + pdf_obj *o = (l == 0 ? NULL : pdf_array_get(ctx, filter, l-1)); + const char *fil = pdf_to_name(ctx, o); if (l == 0 || (strcmp(fil, match) && strcmp(fil, match2))) { fz_warn(ctx, "Unexpected Filter configuration in inline image"); return; } - pdf_dict_puts(csi->obj, "F", o); + pdf_dict_puts(ctx, csi->obj, "F", o); - o = pdf_dict_gets(csi->obj, "DecodeParms"); + o = pdf_dict_gets(ctx, csi->obj, "DecodeParms"); if (o == NULL) - o = pdf_dict_gets(csi->obj, "DP"); + o = pdf_dict_gets(ctx, csi->obj, "DP"); if (o) { - o = pdf_array_get(o, l-1); + o = pdf_array_get(ctx, o, l-1); if (o) - pdf_dict_puts(csi->obj, "DP", o); + pdf_dict_puts(ctx, csi->obj, "DP", o); else - pdf_dict_dels(csi->obj, "DP"); - pdf_dict_dels(csi->obj, "DecodeParms"); + pdf_dict_dels(ctx, csi->obj, "DP"); + pdf_dict_dels(ctx, csi->obj, "DecodeParms"); } } else @@ -208,25 +208,25 @@ pdf_buffer_BI(pdf_csi *csi, void *state_) /* It's a singleton. It must be correct */ } - fz_printf(state->out, "BI\n"); + fz_printf(state->ctx, state->out, "BI\n"); - len = pdf_dict_len(csi->obj); + len = pdf_dict_len(ctx, csi->obj); for (i = 0; i < len; i++) { - pdf_output_obj(state->out, pdf_dict_get_key(csi->obj, i), 1); - pdf_output_obj(state->out, pdf_dict_get_val(csi->obj, i), 1); + pdf_output_obj(state->ctx, state->out, pdf_dict_get_key(ctx, csi->obj, i), 1); + pdf_output_obj(state->ctx, state->out, pdf_dict_get_val(ctx, csi->obj, i), 1); } - fz_printf(state->out, "ID\n"); + fz_printf(state->ctx, state->out, "ID\n"); buffer = csi->img->buffer->buffer; len = buffer->len; data = buffer->data; for (i = 0; i < len; i++) { - fz_printf(state->out, "%c", data[i]); + fz_printf(state->ctx, state->out, "%c", data[i]); } - fz_printf(state->out, "\nEI\n"); + fz_printf(state->ctx, state->out, "\nEI\n"); } static void @@ -234,7 +234,7 @@ pdf_buffer_BMC(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s BMC\n", csi->name); + fz_printf(state->ctx, state->out, "/%s BMC\n", csi->name); } static void @@ -242,7 +242,7 @@ pdf_buffer_BT(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "BT\n"); + fz_printf(state->ctx, state->out, "BT\n"); } static void @@ -250,7 +250,7 @@ pdf_buffer_BX(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "BX\n"); + fz_printf(state->ctx, state->out, "BX\n"); } static void @@ -258,7 +258,7 @@ pdf_buffer_CS(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s CS\n", csi->name); + fz_printf(state->ctx, state->out, "/%s CS\n", csi->name); } static void @@ -266,9 +266,9 @@ pdf_buffer_DP(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s ", csi->name); - pdf_output_obj(state->out, csi->obj, 1); - fz_printf(state->out, " DP\n"); + fz_printf(state->ctx, state->out, "/%s ", csi->name); + pdf_output_obj(state->ctx, state->out, csi->obj, 1); + fz_printf(state->ctx, state->out, " DP\n"); } static void @@ -276,7 +276,7 @@ pdf_buffer_EMC(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "EMC\n"); + fz_printf(state->ctx, state->out, "EMC\n"); } static void @@ -284,7 +284,7 @@ pdf_buffer_ET(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "ET\n"); + fz_printf(state->ctx, state->out, "ET\n"); } static void @@ -292,7 +292,7 @@ pdf_buffer_EX(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "EX\n"); + fz_printf(state->ctx, state->out, "EX\n"); } static void @@ -300,7 +300,7 @@ pdf_buffer_F(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "F\n"); + fz_printf(state->ctx, state->out, "F\n"); } static void @@ -308,7 +308,7 @@ pdf_buffer_G(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f G\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f G\n", csi->stack[0]); } static void @@ -316,7 +316,7 @@ pdf_buffer_J(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%d J\n", (int)csi->stack[0]); + fz_printf(state->ctx, state->out, "%d J\n", (int)csi->stack[0]); } static void @@ -324,7 +324,7 @@ pdf_buffer_K(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f K\n", csi->stack[0], + fz_printf(state->ctx, state->out, "%f %f %f %f K\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3]); } @@ -333,7 +333,7 @@ pdf_buffer_M(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f M\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f M\n", csi->stack[0]); } static void @@ -341,7 +341,7 @@ pdf_buffer_MP(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s MP\n", csi->name); + fz_printf(state->ctx, state->out, "/%s MP\n", csi->name); } static void @@ -349,7 +349,7 @@ pdf_buffer_Q(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "Q\n"); + fz_printf(state->ctx, state->out, "Q\n"); } static void @@ -357,7 +357,7 @@ pdf_buffer_RG(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f RG\n", csi->stack[0], csi->stack[1], csi->stack[2]); + fz_printf(state->ctx, state->out, "%f %f %f RG\n", csi->stack[0], csi->stack[1], csi->stack[2]); } static void @@ -365,7 +365,7 @@ pdf_buffer_S(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "S\n"); + fz_printf(state->ctx, state->out, "S\n"); } static void @@ -375,8 +375,8 @@ pdf_buffer_SC(pdf_csi *csi, void *state_) int i; for (i = 0; i < csi->top; i++) - fz_printf(state->out, "%f ", csi->stack[i]); - fz_printf(state->out, "SC\n"); + fz_printf(state->ctx, state->out, "%f ", csi->stack[i]); + fz_printf(state->ctx, state->out, "SC\n"); } static void @@ -386,10 +386,10 @@ pdf_buffer_SCN(pdf_csi *csi, void *state_) int i; for (i = 0; i < csi->top; i++) - fz_printf(state->out, "%f ", csi->stack[i]); + fz_printf(state->ctx, state->out, "%f ", csi->stack[i]); if (csi->name[0]) - fz_printf(state->out, "/%s ", csi->name); - fz_printf(state->out, "SCN\n"); + fz_printf(state->ctx, state->out, "/%s ", csi->name); + fz_printf(state->ctx, state->out, "SCN\n"); } static void @@ -397,7 +397,7 @@ pdf_buffer_Tstar(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "T*\n"); + fz_printf(state->ctx, state->out, "T*\n"); } static void @@ -405,7 +405,7 @@ pdf_buffer_TD(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f TD\n", csi->stack[0], csi->stack[1]); + fz_printf(state->ctx, state->out, "%f %f TD\n", csi->stack[0], csi->stack[1]); } static void @@ -413,8 +413,8 @@ pdf_buffer_TJ(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - pdf_output_obj(state->out, csi->obj, 1); - fz_printf(state->out, " TJ\n"); + pdf_output_obj(state->ctx, state->out, csi->obj, 1); + fz_printf(state->ctx, state->out, " TJ\n"); } static void @@ -422,7 +422,7 @@ pdf_buffer_TL(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f TL\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f TL\n", csi->stack[0]); } static void @@ -430,7 +430,7 @@ pdf_buffer_Tc(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f Tc\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f Tc\n", csi->stack[0]); } static void @@ -438,7 +438,7 @@ pdf_buffer_Td(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f Td\n", csi->stack[0], csi->stack[1]); + fz_printf(state->ctx, state->out, "%f %f Td\n", csi->stack[0], csi->stack[1]); } static void @@ -446,8 +446,8 @@ pdf_buffer_Tj(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - put_string_or_obj(csi, state->out); - fz_printf(state->out, " Tj\n"); + put_string_or_obj(state->ctx, state->out, csi); + fz_printf(state->ctx, state->out, " Tj\n"); } static void @@ -455,7 +455,7 @@ pdf_buffer_Tm(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f %f %f Tm\n", + fz_printf(state->ctx, state->out, "%f %f %f %f %f %f Tm\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3], csi->stack[4], csi->stack[5]); } @@ -465,7 +465,7 @@ pdf_buffer_Tr(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f Tr\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f Tr\n", csi->stack[0]); } static void @@ -473,7 +473,7 @@ pdf_buffer_Ts(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f Ts\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f Ts\n", csi->stack[0]); } static void @@ -481,7 +481,7 @@ pdf_buffer_Tw(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f Tw\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f Tw\n", csi->stack[0]); } static void @@ -489,7 +489,7 @@ pdf_buffer_Tz(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f Tz\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f Tz\n", csi->stack[0]); } static void @@ -497,7 +497,7 @@ pdf_buffer_W(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "W\n"); + fz_printf(state->ctx, state->out, "W\n"); } static void @@ -505,7 +505,7 @@ pdf_buffer_Wstar(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "W*\n"); + fz_printf(state->ctx, state->out, "W*\n"); } static void @@ -513,7 +513,7 @@ pdf_buffer_b(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "b\n"); + fz_printf(state->ctx, state->out, "b\n"); } static void @@ -521,7 +521,7 @@ pdf_buffer_bstar(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "b*\n"); + fz_printf(state->ctx, state->out, "b*\n"); } static void @@ -529,7 +529,7 @@ pdf_buffer_c(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f %f %f c\n", + fz_printf(state->ctx, state->out, "%f %f %f %f %f %f c\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3], csi->stack[4], csi->stack[5]); } @@ -539,7 +539,7 @@ pdf_buffer_cm(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f %f %f cm\n", + fz_printf(state->ctx, state->out, "%f %f %f %f %f %f cm\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3], csi->stack[4], csi->stack[5]); } @@ -549,7 +549,7 @@ pdf_buffer_cs(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s cs\n", csi->name); + fz_printf(state->ctx, state->out, "/%s cs\n", csi->name); } static void @@ -557,8 +557,8 @@ pdf_buffer_d(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - pdf_output_obj(state->out, csi->obj, 1); - fz_printf(state->out, " %f d\n", csi->stack[0]); + pdf_output_obj(state->ctx, state->out, csi->obj, 1); + fz_printf(state->ctx, state->out, " %f d\n", csi->stack[0]); } static void @@ -566,7 +566,7 @@ pdf_buffer_d0(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f d0\n", csi->stack[0], csi->stack[1]); + fz_printf(state->ctx, state->out, "%f %f d0\n", csi->stack[0], csi->stack[1]); } static void @@ -574,7 +574,7 @@ pdf_buffer_d1(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f %f %f d1\n", + fz_printf(state->ctx, state->out, "%f %f %f %f %f %f d1\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3], csi->stack[4], csi->stack[5]); } @@ -584,7 +584,7 @@ pdf_buffer_f(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "f\n"); + fz_printf(state->ctx, state->out, "f\n"); } static void @@ -592,7 +592,7 @@ pdf_buffer_fstar(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "f*\n"); + fz_printf(state->ctx, state->out, "f*\n"); } static void @@ -600,7 +600,7 @@ pdf_buffer_g(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f g\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f g\n", csi->stack[0]); } static void @@ -608,7 +608,7 @@ pdf_buffer_h(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "h\n"); + fz_printf(state->ctx, state->out, "h\n"); } static void @@ -616,7 +616,7 @@ pdf_buffer_i(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f i\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f i\n", csi->stack[0]); } static void @@ -624,7 +624,7 @@ pdf_buffer_j(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%d j\n", (int)csi->stack[0]); + fz_printf(state->ctx, state->out, "%d j\n", (int)csi->stack[0]); } static void @@ -632,7 +632,7 @@ pdf_buffer_k(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f k\n", csi->stack[0], + fz_printf(state->ctx, state->out, "%f %f %f %f k\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3]); } @@ -641,7 +641,7 @@ pdf_buffer_l(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f l\n", csi->stack[0], csi->stack[1]); + fz_printf(state->ctx, state->out, "%f %f l\n", csi->stack[0], csi->stack[1]); } static void @@ -649,7 +649,7 @@ pdf_buffer_m(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f m\n", csi->stack[0], csi->stack[1]); + fz_printf(state->ctx, state->out, "%f %f m\n", csi->stack[0], csi->stack[1]); } static void @@ -657,7 +657,7 @@ pdf_buffer_n(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "n\n"); + fz_printf(state->ctx, state->out, "n\n"); } static void @@ -665,7 +665,7 @@ pdf_buffer_q(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "q\n"); + fz_printf(state->ctx, state->out, "q\n"); } static void @@ -673,7 +673,7 @@ pdf_buffer_re(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f re\n", csi->stack[0], + fz_printf(state->ctx, state->out, "%f %f %f %f re\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3]); } @@ -682,7 +682,7 @@ pdf_buffer_rg(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f rg\n", + fz_printf(state->ctx, state->out, "%f %f %f rg\n", csi->stack[0], csi->stack[1], csi->stack[2]); } @@ -691,7 +691,7 @@ pdf_buffer_ri(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s ri\n", csi->name); + fz_printf(state->ctx, state->out, "/%s ri\n", csi->name); } static void @@ -699,7 +699,7 @@ pdf_buffer_s(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "s\n"); + fz_printf(state->ctx, state->out, "s\n"); } static void @@ -709,8 +709,8 @@ pdf_buffer_sc(pdf_csi *csi, void *state_) int i; for (i = 0; i < csi->top; i++) - fz_printf(state->out, "%f ", csi->stack[i]); - fz_printf(state->out, "sc\n"); + fz_printf(state->ctx, state->out, "%f ", csi->stack[i]); + fz_printf(state->ctx, state->out, "sc\n"); } static void @@ -720,10 +720,10 @@ pdf_buffer_scn(pdf_csi *csi, void *state_) int i; for (i = 0; i < csi->top; i++) - fz_printf(state->out, "%f ", csi->stack[i]); + fz_printf(state->ctx, state->out, "%f ", csi->stack[i]); if (csi->name[0]) - fz_printf(state->out, "/%s ", csi->name); - fz_printf(state->out, "scn\n"); + fz_printf(state->ctx, state->out, "/%s ", csi->name); + fz_printf(state->ctx, state->out, "scn\n"); } static void @@ -731,7 +731,7 @@ pdf_buffer_v(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f v\n", csi->stack[0], + fz_printf(state->ctx, state->out, "%f %f %f %f v\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3]); } @@ -740,7 +740,7 @@ pdf_buffer_w(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f w\n", csi->stack[0]); + fz_printf(state->ctx, state->out, "%f w\n", csi->stack[0]); } static void @@ -748,7 +748,7 @@ pdf_buffer_y(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "%f %f %f %f y\n", csi->stack[0], + fz_printf(state->ctx, state->out, "%f %f %f %f y\n", csi->stack[0], csi->stack[1], csi->stack[2], csi->stack[3]); } @@ -757,7 +757,7 @@ pdf_buffer_Do(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s Do\n", csi->name); + fz_printf(state->ctx, state->out, "/%s Do\n", csi->name); } static void @@ -765,7 +765,7 @@ pdf_buffer_Tf(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s %f Tf\n", csi->name, csi->stack[0]); + fz_printf(state->ctx, state->out, "/%s %f Tf\n", csi->name, csi->stack[0]); } static void @@ -773,7 +773,7 @@ pdf_buffer_gs(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s gs\n", csi->name); + fz_printf(state->ctx, state->out, "/%s gs\n", csi->name); } static void @@ -781,27 +781,26 @@ pdf_buffer_sh(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_printf(state->out, "/%s sh\n", csi->name); + fz_printf(state->ctx, state->out, "/%s sh\n", csi->name); } static void free_processor_buffer(pdf_csi *csi, void *state_) { pdf_buffer_state *state = (pdf_buffer_state *)state_; - fz_context *ctx = state->ctx; - fz_drop_output(state->out); - fz_free(ctx, state); + fz_drop_output(state->ctx, state->out); + fz_free(state->ctx, state); } static void process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_xobject *xobj = annot->ap; /* Avoid infinite recursion */ - if (xobj == NULL || pdf_mark_obj(xobj->me)) + if (xobj == NULL || pdf_mark_obj(ctx, xobj->me)) return; fz_try(ctx) @@ -813,7 +812,7 @@ process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot) } fz_always(ctx) { - pdf_unmark_obj(xobj->me); + pdf_unmark_obj(ctx, xobj->me); } fz_catch(ctx) { @@ -914,7 +913,7 @@ static const pdf_processor pdf_processor_buffer = process_contents }; -pdf_process *pdf_process_buffer(pdf_process *process, fz_context *ctx, fz_buffer *buffer) +pdf_process *pdf_init_process_buffer(fz_context *ctx, pdf_process *process, fz_buffer *buffer) { fz_output *out = fz_new_output_with_buffer(ctx, buffer); pdf_buffer_state *p = NULL; @@ -930,7 +929,7 @@ pdf_process *pdf_process_buffer(pdf_process *process, fz_context *ctx, fz_buffer } fz_catch(ctx) { - fz_drop_output(out); + fz_drop_output(ctx, out); fz_rethrow(ctx); } diff --git a/source/pdf/pdf-op-filter.c b/source/pdf/pdf-op-filter.c index 17bd3af0..ec08b305 100644 --- a/source/pdf/pdf-op-filter.c +++ b/source/pdf/pdf-op-filter.c @@ -47,21 +47,22 @@ typedef struct pdf_filter_state_s static void insert_resource_name(pdf_csi *csi, pdf_filter_state *state, const char *key, const char *name) { + fz_context *ctx = csi->ctx; pdf_obj *xobj; pdf_obj *obj; if (!state->resources || !name || name[0] == 0) return; - xobj = pdf_dict_gets(csi->rdb, key); - obj = pdf_dict_gets(xobj, name); + xobj = pdf_dict_gets(ctx, csi->rdb, key); + obj = pdf_dict_gets(ctx, xobj, name); - xobj = pdf_dict_gets(state->resources, key); + xobj = pdf_dict_gets(ctx, state->resources, key); if (xobj == NULL) { - xobj = pdf_new_dict(csi->doc, 1); - pdf_dict_puts_drop(state->resources, key, xobj); + xobj = pdf_new_dict(csi->ctx, csi->doc, 1); + pdf_dict_puts_drop(ctx, state->resources, key, xobj); } - pdf_dict_putp(xobj, name, obj); + pdf_dict_putp(ctx, xobj, name, obj); } static void insert_resource(pdf_csi *csi, pdf_filter_state *state, const char *key) @@ -408,7 +409,7 @@ pdf_filter_BDC(pdf_csi *csi, void *state_) { pdf_filter_state *state = (pdf_filter_state *)state_; - insert_resource_name(csi, state, "Properties", pdf_to_name(csi->obj)); + insert_resource_name(csi, state, "Properties", pdf_to_name(csi->ctx, csi->obj)); filter_flush(csi, state, 0); call_op(csi, state, PDF_OP_BDC); @@ -467,7 +468,7 @@ pdf_filter_DP(pdf_csi *csi, void *state_) { pdf_filter_state *state = (pdf_filter_state *)state_; - insert_resource_name(csi, state, "Properties", pdf_to_name(csi->obj)); + insert_resource_name(csi, state, "Properties", pdf_to_name(csi->ctx, csi->obj)); filter_flush(csi, state, 0); call_op(csi, state, PDF_OP_DP); @@ -1085,11 +1086,11 @@ free_processor_filter(pdf_csi *csi, void *state_) static void process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_xobject *xobj = annot->ap; /* Avoid infinite recursion */ - if (xobj == NULL || pdf_mark_obj(xobj->me)) + if (xobj == NULL || pdf_mark_obj(ctx, xobj->me)) return; fz_try(ctx) @@ -1101,7 +1102,7 @@ process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot) } fz_always(ctx) { - pdf_unmark_obj(xobj->me); + pdf_unmark_obj(ctx, xobj->me); } fz_catch(ctx) { @@ -1203,7 +1204,7 @@ static const pdf_processor pdf_processor_filter = }; pdf_process * -pdf_process_filter(pdf_process *process, fz_context *ctx, pdf_process *underlying, pdf_obj *resources) +pdf_init_process_filter(fz_context *ctx, pdf_process *process, pdf_process *underlying, pdf_obj *resources) { pdf_filter_state *p = NULL; diff --git a/source/pdf/pdf-op-run.c b/source/pdf/pdf-op-run.c index 52000b40..139f7e50 100644 --- a/source/pdf/pdf-op-run.c +++ b/source/pdf/pdf-op-run.c @@ -107,7 +107,7 @@ static void run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, const fz_matrix *transform); static int -ocg_intents_include(pdf_ocg_descriptor *desc, char *name) +ocg_intents_include(fz_context *ctx, pdf_ocg_descriptor *desc, char *name) { int i, len; @@ -118,20 +118,20 @@ ocg_intents_include(pdf_ocg_descriptor *desc, char *name) if (!desc->intent) return (strcmp(name, "View") == 0); - if (pdf_is_name(desc->intent)) + if (pdf_is_name(ctx, desc->intent)) { - char *intent = pdf_to_name(desc->intent); + char *intent = pdf_to_name(ctx, desc->intent); if (strcmp(intent, "All") == 0) return 1; return (strcmp(intent, name) == 0); } - if (!pdf_is_array(desc->intent)) + if (!pdf_is_array(ctx, desc->intent)) return 0; - len = pdf_array_len(desc->intent); + len = pdf_array_len(ctx, desc->intent); for (i=0; i < len; i++) { - char *intent = pdf_to_name(pdf_array_get(desc->intent, i)); + char *intent = pdf_to_name(ctx, pdf_array_get(ctx, desc->intent, i)); if (strcmp(intent, "All") == 0) return 1; if (strcmp(intent, name) == 0) @@ -147,10 +147,10 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) pdf_obj *obj, *obj2; char *type; pdf_ocg_descriptor *desc = csi->doc->ocg; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; /* Avoid infinite recursions */ - if (pdf_obj_marked(ocg)) + if (pdf_obj_marked(ctx, ocg)) return 0; /* If no ocg descriptor, everything is visible */ @@ -158,9 +158,9 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) return 0; /* If we've been handed a name, look it up in the properties. */ - if (pdf_is_name(ocg)) + if (pdf_is_name(ctx, ocg)) { - ocg = pdf_dict_gets(pdf_dict_gets(rdb, "Properties"), pdf_to_name(ocg)); + ocg = pdf_dict_gets(ctx, pdf_dict_gets(ctx, rdb, "Properties"), pdf_to_name(ctx, ocg)); } /* If we haven't been given an ocg at all, then we're visible */ if (!ocg) @@ -169,14 +169,14 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) fz_strlcpy(event_state, pr->event, sizeof event_state); fz_strlcat(event_state, "State", sizeof event_state); - type = pdf_to_name(pdf_dict_gets(ocg, "Type")); + type = pdf_to_name(ctx, pdf_dict_gets(ctx, ocg, "Type")); if (strcmp(type, "OCG") == 0) { /* An Optional Content Group */ int default_value = 0; - int num = pdf_to_num(ocg); - int gen = pdf_to_gen(ocg); + int num = pdf_to_num(ctx, ocg); + int gen = pdf_to_gen(ctx, ocg); int len = desc->len; int i; @@ -192,19 +192,19 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) /* Check Intents; if our intent is not part of the set given * by the current config, we should ignore it. */ - obj = pdf_dict_gets(ocg, "Intent"); - if (pdf_is_name(obj)) + obj = pdf_dict_gets(ctx, ocg, "Intent"); + if (pdf_is_name(ctx, obj)) { /* If it doesn't match, it's hidden */ - if (ocg_intents_include(desc, pdf_to_name(obj)) == 0) + if (ocg_intents_include(ctx, desc, pdf_to_name(ctx, obj)) == 0) return 1; } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { int match = 0; - len = pdf_array_len(obj); + len = pdf_array_len(ctx, obj); for (i=0; i<len; i++) { - match |= ocg_intents_include(desc, pdf_to_name(pdf_array_get(obj, i))); + match |= ocg_intents_include(ctx, desc, pdf_to_name(ctx, pdf_array_get(ctx, obj, i))); if (match) break; } @@ -215,7 +215,7 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) else { /* If it doesn't match, it's hidden */ - if (ocg_intents_include(desc, "View") == 0) + if (ocg_intents_include(ctx, desc, "View") == 0) return 1; } @@ -228,19 +228,19 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) * correspond to entries in the AS list in the OCG config. * Given that we don't handle Zoom or User, or Language * dicts, this is not really a problem. */ - obj = pdf_dict_gets(ocg, "Usage"); - if (!pdf_is_dict(obj)) + obj = pdf_dict_gets(ctx, ocg, "Usage"); + if (!pdf_is_dict(ctx, obj)) return default_value; /* FIXME: Should look at Zoom (and return hidden if out of * max/min range) */ /* FIXME: Could provide hooks to the caller to check if * User is appropriate - if not return hidden. */ - obj2 = pdf_dict_gets(obj, pr->event); - if (strcmp(pdf_to_name(pdf_dict_gets(obj2, event_state)), "OFF") == 0) + obj2 = pdf_dict_gets(ctx, obj, pr->event); + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, obj2, event_state)), "OFF") == 0) { return 1; } - if (strcmp(pdf_to_name(pdf_dict_gets(obj2, event_state)), "ON") == 0) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, obj2, event_state)), "ON") == 0) { return 0; } @@ -252,12 +252,12 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) char *name; int combine, on; - obj = pdf_dict_gets(ocg, "VE"); - if (pdf_is_array(obj)) { + obj = pdf_dict_gets(ctx, ocg, "VE"); + if (pdf_is_array(ctx, obj)) { /* FIXME: Calculate visibility from array */ return 0; } - name = pdf_to_name(pdf_dict_gets(ocg, "P")); + name = pdf_to_name(ctx, pdf_dict_gets(ctx, ocg, "P")); /* Set combine; Bit 0 set => AND, Bit 1 set => true means * Off, otherwise true means On */ if (strcmp(name, "AllOn") == 0) @@ -277,19 +277,19 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) combine = 0; } - if (pdf_mark_obj(ocg)) + if (pdf_mark_obj(ctx, ocg)) return 0; /* Should never happen */ fz_try(ctx) { - obj = pdf_dict_gets(ocg, "OCGs"); + obj = pdf_dict_gets(ctx, ocg, "OCGs"); on = combine & 1; - if (pdf_is_array(obj)) { + if (pdf_is_array(ctx, obj)) { int i, len; - len = pdf_array_len(obj); + len = pdf_array_len(ctx, obj); for (i = 0; i < len; i++) { int hidden; - hidden = pdf_is_hidden_ocg(pdf_array_get(obj, i), csi, pr, rdb); + hidden = pdf_is_hidden_ocg(pdf_array_get(ctx, obj, i), csi, pr, rdb); if ((combine & 1) == 0) hidden = !hidden; if (combine & 2) @@ -307,7 +307,7 @@ pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb) } fz_always(ctx) { - pdf_unmark_obj(ocg); + pdf_unmark_obj(ctx, ocg); } fz_catch(ctx) { @@ -349,7 +349,7 @@ begin_softmask(pdf_csi *csi, pdf_run_state *pr, softmask_save *save) gstate->softmask = NULL; gstate->ctm = gstate->softmask_ctm; - fz_begin_mask(pr->dev, &mask_bbox, gstate->luminosity, + fz_begin_mask(ctx, pr->dev, &mask_bbox, gstate->luminosity, softmask->colorspace, gstate->softmask_bc); fz_try(ctx) { @@ -364,7 +364,7 @@ begin_softmask(pdf_csi *csi, pdf_run_state *pr, softmask_save *save) csi->cookie->errors++; } - fz_end_mask(pr->dev); + fz_end_mask(ctx, pr->dev); pr->tm = save_tm; pr->tlm = save_tlm; @@ -378,6 +378,7 @@ begin_softmask(pdf_csi *csi, pdf_run_state *pr, softmask_save *save) static void end_softmask(pdf_csi *csi, pdf_run_state *pr, softmask_save *save) { + fz_context *ctx = pr->ctx; pdf_gstate *gstate = pr->gstate + pr->gtop; if (save->softmask == NULL) @@ -385,7 +386,7 @@ end_softmask(pdf_csi *csi, pdf_run_state *pr, softmask_save *save) gstate->softmask = save->softmask; gstate->softmask_ctm = save->ctm; - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } static pdf_gstate * @@ -394,7 +395,7 @@ pdf_begin_group(pdf_csi *csi, pdf_run_state *pr, const fz_rect *bbox, softmask_s pdf_gstate *gstate = begin_softmask(csi, pr, softmask); if (gstate->blendmode) - fz_begin_group(pr->dev, bbox, 1, 0, gstate->blendmode, 1); + fz_begin_group(pr->ctx, pr->dev, bbox, 1, 0, gstate->blendmode, 1); return pr->gstate + pr->gtop; } @@ -405,7 +406,7 @@ pdf_end_group(pdf_csi *csi, pdf_run_state *pr, softmask_save *softmask) pdf_gstate *gstate = pr->gstate + pr->gtop; if (gstate->blendmode) - fz_end_group(pr->dev); + fz_end_group(pr->ctx, pr->dev); end_softmask(csi, pr, softmask); } @@ -427,7 +428,7 @@ pdf_show_shade(pdf_csi *csi, pdf_run_state *pr, fz_shade *shd) /* FIXME: The gstate->ctm in the next line may be wrong; maybe * it should be the parent gstates ctm? */ - fz_fill_shade(pr->dev, shd, &gstate->ctm, gstate->fill.alpha); + fz_fill_shade(ctx, pr->dev, shd, &gstate->ctm, gstate->fill.alpha); pdf_end_group(csi, pr, &softmask); } @@ -549,7 +550,7 @@ pdf_grestore(pdf_run_state *pr) { fz_try(ctx) { - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } fz_catch(ctx) { @@ -649,14 +650,14 @@ pdf_show_pattern(pdf_csi *csi, pdf_run_state *pr, pdf_pattern *pat, pdf_gstate * if (0) #endif { - fz_begin_tile(pr->dev, &local_area, &pat->bbox, pat->xstep, pat->ystep, &ptm); + fz_begin_tile(ctx, pr->dev, &local_area, &pat->bbox, pat->xstep, pat->ystep, &ptm); gstate->ctm = ptm; pdf_gsave(pr); pdf_process_contents_object(csi, pat->resources, pat->contents); pdf_grestore(pr); while (oldtop < pr->gtop) pdf_grestore(pr); - fz_end_tile(pr->dev); + fz_end_tile(ctx, pr->dev); } else { @@ -720,6 +721,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_run_state *pr, pdf_pattern *pat, pdf_gstate * static void pdf_show_image(pdf_csi *csi, pdf_run_state *pr, fz_image *image) { + fz_context *ctx = pr->ctx; pdf_gstate *gstate = pr->gstate + pr->gtop; fz_matrix image_ctm; fz_rect bbox; @@ -739,8 +741,8 @@ pdf_show_image(pdf_csi *csi, pdf_run_state *pr, fz_image *image) { /* apply blend group even though we skip the soft mask */ if (gstate->blendmode) - fz_begin_group(pr->dev, &bbox, 0, 0, gstate->blendmode, 1); - fz_clip_image_mask(pr->dev, image->mask, &bbox, &image_ctm); + fz_begin_group(ctx, pr->dev, &bbox, 0, 0, gstate->blendmode, 1); + fz_clip_image_mask(ctx, pr->dev, image->mask, &bbox, &image_ctm); } else gstate = pdf_begin_group(csi, pr, &bbox, &softmask); @@ -753,37 +755,37 @@ pdf_show_image(pdf_csi *csi, pdf_run_state *pr, fz_image *image) case PDF_MAT_NONE: break; case PDF_MAT_COLOR: - fz_fill_image_mask(pr->dev, image, &image_ctm, + fz_fill_image_mask(ctx, pr->dev, image, &image_ctm, gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha); break; case PDF_MAT_PATTERN: if (gstate->fill.pattern) { - fz_clip_image_mask(pr->dev, image, &bbox, &image_ctm); + fz_clip_image_mask(ctx, pr->dev, image, &bbox, &image_ctm); pdf_show_pattern(csi, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], &bbox, PDF_FILL); - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } break; case PDF_MAT_SHADE: if (gstate->fill.shade) { - fz_clip_image_mask(pr->dev, image, &bbox, &image_ctm); - fz_fill_shade(pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); - fz_pop_clip(pr->dev); + fz_clip_image_mask(ctx, pr->dev, image, &bbox, &image_ctm); + fz_fill_shade(ctx, pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); + fz_pop_clip(ctx, pr->dev); } break; } } else { - fz_fill_image(pr->dev, image, &image_ctm, gstate->fill.alpha); + fz_fill_image(ctx, pr->dev, image, &image_ctm, gstate->fill.alpha); } if (image->mask) { - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); if (gstate->blendmode) - fz_end_group(pr->dev); + fz_end_group(ctx, pr->dev); } else pdf_end_group(csi, pr, &softmask); @@ -825,7 +827,7 @@ pdf_show_path(pdf_csi *csi, pdf_run_state *pr, int doclose, int dofill, int dost if (pr->clip) { gstate->clip_depth++; - fz_clip_path(pr->dev, path, &bbox, pr->clip_even_odd, &gstate->ctm); + fz_clip_path(ctx, pr->dev, path, &bbox, pr->clip_even_odd, &gstate->ctm); pr->clip = 0; } @@ -849,7 +851,7 @@ pdf_show_path(pdf_csi *csi, pdf_run_state *pr, int doclose, int dofill, int dost else { knockout_group = 1; - fz_begin_group(pr->dev, &bbox, 0, 1, FZ_BLEND_NORMAL, 1); + fz_begin_group(ctx, pr->dev, &bbox, 0, 1, FZ_BLEND_NORMAL, 1); } } @@ -860,24 +862,24 @@ pdf_show_path(pdf_csi *csi, pdf_run_state *pr, int doclose, int dofill, int dost case PDF_MAT_NONE: break; case PDF_MAT_COLOR: - fz_fill_path(pr->dev, path, even_odd, &gstate->ctm, + fz_fill_path(ctx, pr->dev, path, even_odd, &gstate->ctm, gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha); break; case PDF_MAT_PATTERN: if (gstate->fill.pattern) { - fz_clip_path(pr->dev, path, &bbox, even_odd, &gstate->ctm); + fz_clip_path(ctx, pr->dev, path, &bbox, even_odd, &gstate->ctm); pdf_show_pattern(csi, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], &bbox, PDF_FILL); - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } break; case PDF_MAT_SHADE: if (gstate->fill.shade) { - fz_clip_path(pr->dev, path, &bbox, even_odd, &gstate->ctm); + fz_clip_path(ctx, pr->dev, path, &bbox, even_odd, &gstate->ctm); /* The cluster and page 2 of patterns.pdf shows that fz_fill_shade should NOT be called with gstate->ctm. */ - fz_fill_shade(pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); - fz_pop_clip(pr->dev); + fz_fill_shade(ctx, pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); + fz_pop_clip(ctx, pr->dev); } break; } @@ -890,30 +892,30 @@ pdf_show_path(pdf_csi *csi, pdf_run_state *pr, int doclose, int dofill, int dost case PDF_MAT_NONE: break; case PDF_MAT_COLOR: - fz_stroke_path(pr->dev, path, gstate->stroke_state, &gstate->ctm, + fz_stroke_path(ctx, pr->dev, path, gstate->stroke_state, &gstate->ctm, gstate->stroke.colorspace, gstate->stroke.v, gstate->stroke.alpha); break; case PDF_MAT_PATTERN: if (gstate->stroke.pattern) { - fz_clip_stroke_path(pr->dev, path, &bbox, gstate->stroke_state, &gstate->ctm); + fz_clip_stroke_path(ctx, pr->dev, path, &bbox, gstate->stroke_state, &gstate->ctm); pdf_show_pattern(csi, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], &bbox, PDF_STROKE); - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } break; case PDF_MAT_SHADE: if (gstate->stroke.shade) { - fz_clip_stroke_path(pr->dev, path, &bbox, gstate->stroke_state, &gstate->ctm); - fz_fill_shade(pr->dev, gstate->stroke.shade, &pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha); - fz_pop_clip(pr->dev); + fz_clip_stroke_path(ctx, pr->dev, path, &bbox, gstate->stroke_state, &gstate->ctm); + fz_fill_shade(ctx, pr->dev, gstate->stroke.shade, &pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha); + fz_pop_clip(ctx, pr->dev); } break; } } if (knockout_group) - fz_end_group(pr->dev); + fz_end_group(ctx, pr->dev); if (dofill || dostroke) pdf_end_group(csi, pr, &softmask); @@ -978,7 +980,7 @@ pdf_flush_text(pdf_csi *csi, pdf_run_state *pr) gstate = pdf_begin_group(csi, pr, &tb, &softmask); if (doinvisible) - fz_ignore_text(pr->dev, text, &gstate->ctm); + fz_ignore_text(ctx, pr->dev, text, &gstate->ctm); if (dofill) { @@ -987,24 +989,24 @@ pdf_flush_text(pdf_csi *csi, pdf_run_state *pr) case PDF_MAT_NONE: break; case PDF_MAT_COLOR: - fz_fill_text(pr->dev, text, &gstate->ctm, + fz_fill_text(ctx, pr->dev, text, &gstate->ctm, gstate->fill.colorspace, gstate->fill.v, gstate->fill.alpha); break; case PDF_MAT_PATTERN: if (gstate->fill.pattern) { - fz_clip_text(pr->dev, text, &gstate->ctm, 0); + fz_clip_text(ctx, pr->dev, text, &gstate->ctm, 0); pdf_show_pattern(csi, pr, gstate->fill.pattern, &pr->gstate[gstate->fill.gstate_num], &tb, PDF_FILL); - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } break; case PDF_MAT_SHADE: if (gstate->fill.shade) { - fz_clip_text(pr->dev, text, &gstate->ctm, 0); + fz_clip_text(ctx, pr->dev, text, &gstate->ctm, 0); /* Page 2 of patterns.pdf shows that fz_fill_shade should NOT be called with gstate->ctm */ - fz_fill_shade(pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); - fz_pop_clip(pr->dev); + fz_fill_shade(ctx, pr->dev, gstate->fill.shade, &pr->gstate[gstate->fill.gstate_num].ctm, gstate->fill.alpha); + fz_pop_clip(ctx, pr->dev); } break; } @@ -1017,23 +1019,23 @@ pdf_flush_text(pdf_csi *csi, pdf_run_state *pr) case PDF_MAT_NONE: break; case PDF_MAT_COLOR: - fz_stroke_text(pr->dev, text, gstate->stroke_state, &gstate->ctm, + fz_stroke_text(ctx, pr->dev, text, gstate->stroke_state, &gstate->ctm, gstate->stroke.colorspace, gstate->stroke.v, gstate->stroke.alpha); break; case PDF_MAT_PATTERN: if (gstate->stroke.pattern) { - fz_clip_stroke_text(pr->dev, text, gstate->stroke_state, &gstate->ctm); + fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, &gstate->ctm); pdf_show_pattern(csi, pr, gstate->stroke.pattern, &pr->gstate[gstate->stroke.gstate_num], &tb, PDF_STROKE); - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); } break; case PDF_MAT_SHADE: if (gstate->stroke.shade) { - fz_clip_stroke_text(pr->dev, text, gstate->stroke_state, &gstate->ctm); - fz_fill_shade(pr->dev, gstate->stroke.shade, &pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha); - fz_pop_clip(pr->dev); + fz_clip_stroke_text(ctx, pr->dev, text, gstate->stroke_state, &gstate->ctm); + fz_fill_shade(ctx, pr->dev, gstate->stroke.shade, &pr->gstate[gstate->stroke.gstate_num].ctm, gstate->stroke.alpha); + fz_pop_clip(ctx, pr->dev); } break; } @@ -1043,7 +1045,7 @@ pdf_flush_text(pdf_csi *csi, pdf_run_state *pr) { if (pr->accumulate < 2) gstate->clip_depth++; - fz_clip_text(pr->dev, text, &gstate->ctm, pr->accumulate); + fz_clip_text(ctx, pr->dev, text, &gstate->ctm, pr->accumulate); pr->accumulate = 2; } @@ -1231,24 +1233,25 @@ pdf_show_string(pdf_csi *csi, pdf_run_state *pr, unsigned char *buf, int len) static void pdf_show_text(pdf_csi *csi, pdf_run_state *pr, pdf_obj *text) { + fz_context *ctx = csi->ctx; pdf_gstate *gstate = pr->gstate + pr->gtop; int i; - if (pdf_is_array(text)) + if (pdf_is_array(ctx, text)) { - int n = pdf_array_len(text); + int n = pdf_array_len(ctx, text); for (i = 0; i < n; i++) { - pdf_obj *item = pdf_array_get(text, i); - if (pdf_is_string(item)) - pdf_show_string(csi, pr, (unsigned char *)pdf_to_str_buf(item), pdf_to_str_len(item)); + pdf_obj *item = pdf_array_get(ctx, text, i); + if (pdf_is_string(ctx, item)) + pdf_show_string(csi, pr, (unsigned char *)pdf_to_str_buf(ctx, item), pdf_to_str_len(ctx, item)); else - pdf_show_space(pr, - pdf_to_real(item) * gstate->size * 0.001f); + pdf_show_space(pr, - pdf_to_real(ctx, item) * gstate->size * 0.001f); } } - else if (pdf_is_string(text)) + else if (pdf_is_string(ctx, text)) { - pdf_show_string(csi, pr, (unsigned char *)pdf_to_str_buf(text), pdf_to_str_len(text)); + pdf_show_string(csi, pr, (unsigned char *)pdf_to_str_buf(ctx, text), pdf_to_str_len(ctx, text)); } } @@ -1328,7 +1331,7 @@ pdf_set_colorspace(pdf_csi *csi, pdf_run_state *pr, int what, fz_colorspace *col mat->v[2] = 0; mat->v[3] = 1; - if (pdf_is_tint_colorspace(colorspace)) + if (pdf_is_tint_colorspace(ctx, colorspace)) { int i; for (i = 0; i < colorspace->n; i++) @@ -1352,7 +1355,7 @@ pdf_set_color(pdf_csi *csi, pdf_run_state *pr, int what, float *v) { case PDF_MAT_PATTERN: case PDF_MAT_COLOR: - if (fz_colorspace_is_indexed(mat->colorspace)) + if (fz_colorspace_is_indexed(ctx, mat->colorspace)) { mat->v[0] = v[0] / 255; break; @@ -1411,13 +1414,13 @@ pdf_set_pattern(pdf_csi *csi, pdf_run_state *pr, int what, pdf_pattern *pat, flo static pdf_font_desc * load_font_or_hail_mary(pdf_csi *csi, pdf_obj *rdb, pdf_obj *font, int depth) { + fz_context *ctx = csi->ctx; pdf_document *doc = csi->doc; - fz_context *ctx = doc->ctx; pdf_font_desc *desc; fz_try(ctx) { - desc = pdf_load_font(doc, rdb, font, depth); + desc = pdf_load_font(ctx, doc, rdb, font, depth); } fz_catch(ctx) { @@ -1429,7 +1432,7 @@ load_font_or_hail_mary(pdf_csi *csi, pdf_obj *rdb, pdf_obj *font, int depth) csi->cookie->incomplete++; } if (desc == NULL) - desc = pdf_load_hail_mary_font(doc); + desc = pdf_load_hail_mary_font(ctx, doc); return desc; } @@ -1443,18 +1446,18 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst gstate = pdf_flush_text(csi, pr); - n = pdf_dict_len(extgstate); + n = pdf_dict_len(ctx, extgstate); for (i = 0; i < n; i++) { - pdf_obj *key = pdf_dict_get_key(extgstate, i); - pdf_obj *val = pdf_dict_get_val(extgstate, i); - char *s = pdf_to_name(key); + pdf_obj *key = pdf_dict_get_key(ctx, extgstate, i); + pdf_obj *val = pdf_dict_get_val(ctx, extgstate, i); + char *s = pdf_to_name(ctx, key); if (!strcmp(s, "Font")) { - if (pdf_is_array(val) && pdf_array_len(val) == 2) + if (pdf_is_array(ctx, val) && pdf_array_len(ctx, val) == 2) { - pdf_obj *font = pdf_array_get(val, 0); + pdf_obj *font = pdf_array_get(ctx, val, 0); if (gstate->font) { @@ -1465,7 +1468,7 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst gstate->font = load_font_or_hail_mary(csi, rdb, font, pr->nested_depth); if (!gstate->font) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find font in store"); - gstate->size = pdf_to_real(pdf_array_get(val, 1)); + gstate->size = pdf_to_real(ctx, pdf_array_get(ctx, val, 1)); } else fz_throw(ctx, FZ_ERROR_GENERIC, "malformed /Font dictionary"); @@ -1475,61 +1478,61 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst { pr->dev->flags &= ~(FZ_DEVFLAG_STARTCAP_UNDEFINED | FZ_DEVFLAG_DASHCAP_UNDEFINED | FZ_DEVFLAG_ENDCAP_UNDEFINED); gstate->stroke_state = fz_unshare_stroke_state(ctx, gstate->stroke_state); - gstate->stroke_state->start_cap = pdf_to_int(val); - gstate->stroke_state->dash_cap = pdf_to_int(val); - gstate->stroke_state->end_cap = pdf_to_int(val); + gstate->stroke_state->start_cap = pdf_to_int(ctx, val); + gstate->stroke_state->dash_cap = pdf_to_int(ctx, val); + gstate->stroke_state->end_cap = pdf_to_int(ctx, val); } else if (!strcmp(s, "LW")) { pr->dev->flags &= ~FZ_DEVFLAG_LINEWIDTH_UNDEFINED; gstate->stroke_state = fz_unshare_stroke_state(ctx, gstate->stroke_state); - gstate->stroke_state->linewidth = pdf_to_real(val); + gstate->stroke_state->linewidth = pdf_to_real(ctx, val); } else if (!strcmp(s, "LJ")) { pr->dev->flags &= ~FZ_DEVFLAG_LINEJOIN_UNDEFINED; gstate->stroke_state = fz_unshare_stroke_state(ctx, gstate->stroke_state); - gstate->stroke_state->linejoin = pdf_to_int(val); + gstate->stroke_state->linejoin = pdf_to_int(ctx, val); } else if (!strcmp(s, "ML")) { pr->dev->flags &= ~FZ_DEVFLAG_MITERLIMIT_UNDEFINED; gstate->stroke_state = fz_unshare_stroke_state(ctx, gstate->stroke_state); - gstate->stroke_state->miterlimit = pdf_to_real(val); + gstate->stroke_state->miterlimit = pdf_to_real(ctx, val); } else if (!strcmp(s, "D")) { - if (pdf_is_array(val) && pdf_array_len(val) == 2) + if (pdf_is_array(ctx, val) && pdf_array_len(ctx, val) == 2) { - pdf_obj *dashes = pdf_array_get(val, 0); - int len = pdf_array_len(dashes); + pdf_obj *dashes = pdf_array_get(ctx, val, 0); + int len = pdf_array_len(ctx, dashes); gstate->stroke_state = fz_unshare_stroke_state_with_dash_len(ctx, gstate->stroke_state, len); gstate->stroke_state->dash_len = len; for (k = 0; k < len; k++) - gstate->stroke_state->dash_list[k] = pdf_to_real(pdf_array_get(dashes, k)); - gstate->stroke_state->dash_phase = pdf_to_real(pdf_array_get(val, 1)); + gstate->stroke_state->dash_list[k] = pdf_to_real(ctx, pdf_array_get(ctx, dashes, k)); + gstate->stroke_state->dash_phase = pdf_to_real(ctx, pdf_array_get(ctx, val, 1)); } else fz_throw(ctx, FZ_ERROR_GENERIC, "malformed /D"); } else if (!strcmp(s, "CA")) - gstate->stroke.alpha = fz_clamp(pdf_to_real(val), 0, 1); + gstate->stroke.alpha = fz_clamp(pdf_to_real(ctx, val), 0, 1); else if (!strcmp(s, "ca")) - gstate->fill.alpha = fz_clamp(pdf_to_real(val), 0, 1); + gstate->fill.alpha = fz_clamp(pdf_to_real(ctx, val), 0, 1); else if (!strcmp(s, "BM")) { - if (pdf_is_array(val)) - val = pdf_array_get(val, 0); - gstate->blendmode = fz_lookup_blendmode(pdf_to_name(val)); + if (pdf_is_array(ctx, val)) + val = pdf_array_get(ctx, val, 0); + gstate->blendmode = fz_lookup_blendmode(pdf_to_name(ctx, val)); } else if (!strcmp(s, "SMask")) { - if (pdf_is_dict(val)) + if (pdf_is_dict(ctx, val)) { pdf_xobject *xobj; pdf_obj *group, *luminosity, *bc, *tr; @@ -1540,10 +1543,10 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst gstate->softmask = NULL; } - group = pdf_dict_gets(val, "G"); + group = pdf_dict_gets(ctx, val, "G"); if (!group) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load softmask xobject (%d %d R)", pdf_to_num(val), pdf_to_gen(val)); - xobj = pdf_load_xobject(csi->doc, group); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load softmask xobject (%d %d R)", pdf_to_num(ctx, val), pdf_to_gen(ctx, val)); + xobj = pdf_load_xobject(ctx, csi->doc, group); colorspace = xobj->colorspace; if (!colorspace) @@ -1556,24 +1559,24 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst for (k = 0; k < colorspace->n; k++) gstate->softmask_bc[k] = 0; - bc = pdf_dict_gets(val, "BC"); - if (pdf_is_array(bc)) + bc = pdf_dict_gets(ctx, val, "BC"); + if (pdf_is_array(ctx, bc)) { for (k = 0; k < colorspace->n; k++) - gstate->softmask_bc[k] = pdf_to_real(pdf_array_get(bc, k)); + gstate->softmask_bc[k] = pdf_to_real(ctx, pdf_array_get(ctx, bc, k)); } - luminosity = pdf_dict_gets(val, "S"); - if (pdf_is_name(luminosity) && !strcmp(pdf_to_name(luminosity), "Luminosity")) + luminosity = pdf_dict_gets(ctx, val, "S"); + if (pdf_is_name(ctx, luminosity) && !strcmp(pdf_to_name(ctx, luminosity), "Luminosity")) gstate->luminosity = 1; else gstate->luminosity = 0; - tr = pdf_dict_gets(val, "TR"); - if (tr && strcmp(pdf_to_name(tr), "Identity")) + tr = pdf_dict_gets(ctx, val, "TR"); + if (tr && strcmp(pdf_to_name(ctx, tr), "Identity")) fz_warn(ctx, "ignoring transfer function"); } - else if (pdf_is_name(val) && !strcmp(pdf_to_name(val), "None")) + else if (pdf_is_name(ctx, val) && !strcmp(pdf_to_name(ctx, val), "None")) { if (gstate->softmask) { @@ -1585,15 +1588,15 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst else if (!strcmp(s, "TR2")) { - if (strcmp(pdf_to_name(val), "Identity") && strcmp(pdf_to_name(val), "Default")) + if (strcmp(pdf_to_name(ctx, val), "Identity") && strcmp(pdf_to_name(ctx, val), "Default")) fz_warn(ctx, "ignoring transfer function"); } else if (!strcmp(s, "TR")) { /* TR is ignored in the presence of TR2 */ - pdf_obj *tr2 = pdf_dict_gets(extgstate, "TR2"); - if (tr2 && strcmp(pdf_to_name(val), "Identity")) + pdf_obj *tr2 = pdf_dict_gets(ctx, extgstate, "TR2"); + if (tr2 && strcmp(pdf_to_name(ctx, val), "Identity")) fz_warn(ctx, "ignoring transfer function"); } } @@ -1602,7 +1605,7 @@ pdf_run_extgstate(pdf_csi *csi, pdf_run_state *pr, pdf_obj *rdb, pdf_obj *extgst static void run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, const fz_matrix *transform) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_gstate *gstate = NULL; int oldtop = 0; fz_matrix local_transform = *transform; @@ -1614,7 +1617,7 @@ run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, co char errmess[256] = ""; /* Avoid infinite recursion */ - if (xobj == NULL || pdf_mark_obj(xobj->me)) + if (xobj == NULL || pdf_mark_obj(ctx, xobj->me)) return; fz_var(cleanup_state); @@ -1653,7 +1656,7 @@ run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, co /* Remember that we tried to call fz_begin_group. Even * if it throws an error, we must call fz_end_group. */ cleanup_state = 2; - fz_begin_group(pr->dev, &bbox, + fz_begin_group(ctx, pr->dev, &bbox, xobj->isolated, xobj->knockout, gstate->blendmode, gstate->fill.alpha); gstate->blendmode = 0; @@ -1694,7 +1697,7 @@ run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, co { fz_try(ctx) { - fz_end_group(pr->dev); + fz_end_group(ctx, pr->dev); } fz_catch(ctx) { @@ -1727,7 +1730,7 @@ run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, co pdf_grestore(pr); } - pdf_unmark_obj(xobj->me); + pdf_unmark_obj(ctx, xobj->me); } fz_catch(ctx) { @@ -1741,6 +1744,7 @@ run_xobject(pdf_csi *csi, void *state, pdf_obj *resources, pdf_xobject *xobj, co static void pdf_run_BDC(pdf_csi *csi, void *state) { + fz_context *ctx = csi->ctx; pdf_run_state *pr = (pdf_run_state *)state; pdf_obj *ocg; pdf_obj *rdb = csi->rdb; @@ -1758,9 +1762,9 @@ static void pdf_run_BDC(pdf_csi *csi, void *state) return; } - if (pdf_is_name(csi->obj)) + if (pdf_is_name(ctx, csi->obj)) { - ocg = pdf_dict_gets(pdf_dict_gets(rdb, "Properties"), pdf_to_name(csi->obj)); + ocg = pdf_dict_gets(ctx, pdf_dict_gets(ctx, rdb, "Properties"), pdf_to_name(ctx, csi->obj)); } else ocg = csi->obj; @@ -1771,7 +1775,7 @@ static void pdf_run_BDC(pdf_csi *csi, void *state) * means visible. */ return; } - if (strcmp(pdf_to_name(pdf_dict_gets(ocg, "Type")), "OCG") != 0) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, ocg, "Type")), "OCG") != 0) { /* Wrong type of property */ return; @@ -1847,13 +1851,13 @@ static void pdf_run_cs_imp(pdf_csi *csi, pdf_run_state *pr, int what) colorspace = fz_device_cmyk(ctx); /* No fz_keep_colorspace as static */ else { - dict = pdf_dict_gets(rdb, "ColorSpace"); + dict = pdf_dict_gets(ctx, rdb, "ColorSpace"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find ColorSpace dictionary"); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find colorspace resource '%s'", csi->name); - colorspace = pdf_load_colorspace(csi->doc, obj); + colorspace = pdf_load_colorspace(ctx, csi->doc, obj); } pdf_set_colorspace(csi, pr, what, colorspace); @@ -1887,39 +1891,39 @@ static void pdf_run_DP(pdf_csi *csi, void *state) static void pdf_run_Do(pdf_csi *csi, void *state) { pdf_run_state *pr = (pdf_run_state *)state; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_obj *dict; pdf_obj *obj; pdf_obj *subtype; pdf_obj *rdb = csi->rdb; - dict = pdf_dict_gets(rdb, "XObject"); + dict = pdf_dict_gets(ctx, rdb, "XObject"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find XObject dictionary when looking for: '%s'", csi->name); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find xobject resource: '%s'", csi->name); - subtype = pdf_dict_gets(obj, "Subtype"); - if (!pdf_is_name(subtype)) + subtype = pdf_dict_gets(ctx, obj, "Subtype"); + if (!pdf_is_name(ctx, subtype)) fz_throw(ctx, FZ_ERROR_GENERIC, "no XObject subtype specified"); - if (pdf_is_hidden_ocg(pdf_dict_gets(obj, "OC"), csi, pr, rdb)) + if (pdf_is_hidden_ocg(pdf_dict_gets(ctx, obj, "OC"), csi, pr, rdb)) return; - if (!strcmp(pdf_to_name(subtype), "Form") && pdf_dict_gets(obj, "Subtype2")) - subtype = pdf_dict_gets(obj, "Subtype2"); + if (!strcmp(pdf_to_name(ctx, subtype), "Form") && pdf_dict_gets(ctx, obj, "Subtype2")) + subtype = pdf_dict_gets(ctx, obj, "Subtype2"); - if (!strcmp(pdf_to_name(subtype), "Form")) + if (!strcmp(pdf_to_name(ctx, subtype), "Form")) { pdf_xobject *xobj; - xobj = pdf_load_xobject(csi->doc, obj); + xobj = pdf_load_xobject(ctx, csi->doc, obj); /* Inherit parent resources, in case this one was empty XXX check where it's loaded */ if (!xobj->resources) - xobj->resources = pdf_keep_obj(rdb); + xobj->resources = pdf_keep_obj(ctx, rdb); fz_try(ctx) { @@ -1931,15 +1935,15 @@ static void pdf_run_Do(pdf_csi *csi, void *state) } fz_catch(ctx) { - fz_rethrow_message(ctx, "cannot draw xobject (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_rethrow_message(ctx, "cannot draw xobject (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } } - else if (!strcmp(pdf_to_name(subtype), "Image")) + else if (!strcmp(pdf_to_name(ctx, subtype), "Image")) { if ((pr->dev->hints & FZ_IGNORE_IMAGE) == 0) { - fz_image *img = pdf_load_image(csi->doc, obj); + fz_image *img = pdf_load_image(ctx, csi->doc, obj); fz_try(ctx) { @@ -1956,14 +1960,14 @@ static void pdf_run_Do(pdf_csi *csi, void *state) } } - else if (!strcmp(pdf_to_name(subtype), "PS")) + else if (!strcmp(pdf_to_name(ctx, subtype), "PS")) { fz_warn(ctx, "ignoring XObject with subtype PS"); } else { - fz_throw(ctx, FZ_ERROR_GENERIC, "unknown XObject subtype: '%s'", pdf_to_name(subtype)); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown XObject subtype: '%s'", pdf_to_name(ctx, subtype)); } } @@ -1999,7 +2003,7 @@ static void pdf_run_G(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_STROKECOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_gray(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_gray(csi->ctx)); pdf_set_color(csi, pr, PDF_STROKE, csi->stack); } @@ -2009,7 +2013,7 @@ static void pdf_run_J(pdf_csi *csi, void *state) pdf_gstate *gstate = pr->gstate + pr->gtop; pr->dev->flags &= ~(FZ_DEVFLAG_STARTCAP_UNDEFINED | FZ_DEVFLAG_DASHCAP_UNDEFINED | FZ_DEVFLAG_ENDCAP_UNDEFINED); - gstate->stroke_state = fz_unshare_stroke_state(csi->doc->ctx, gstate->stroke_state); + gstate->stroke_state = fz_unshare_stroke_state(csi->ctx, gstate->stroke_state); gstate->stroke_state->start_cap = csi->stack[0]; gstate->stroke_state->dash_cap = csi->stack[0]; gstate->stroke_state->end_cap = csi->stack[0]; @@ -2020,7 +2024,7 @@ static void pdf_run_K(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_STROKECOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_cmyk(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_cmyk(csi->ctx)); pdf_set_color(csi, pr, PDF_STROKE, csi->stack); } @@ -2030,7 +2034,7 @@ static void pdf_run_M(pdf_csi *csi, void *state) pdf_gstate *gstate = pr->gstate + pr->gtop; pr->dev->flags &= ~FZ_DEVFLAG_MITERLIMIT_UNDEFINED; - gstate->stroke_state = fz_unshare_stroke_state(csi->doc->ctx, gstate->stroke_state); + gstate->stroke_state = fz_unshare_stroke_state(csi->ctx, gstate->stroke_state); gstate->stroke_state->miterlimit = csi->stack[0]; } @@ -2050,7 +2054,7 @@ static void pdf_run_RG(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_STROKECOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_rgb(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_STROKE, fz_device_rgb(csi->ctx)); pdf_set_color(csi, pr, PDF_STROKE, csi->stack); } @@ -2084,33 +2088,33 @@ static void pdf_run_SC_imp(pdf_csi *csi, pdf_run_state *pr, int what, pdf_materi break; case PDF_MAT_PATTERN: - dict = pdf_dict_gets(rdb, "Pattern"); + dict = pdf_dict_gets(ctx, rdb, "Pattern"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find Pattern dictionary"); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find pattern resource '%s'", csi->name); - patterntype = pdf_dict_gets(obj, "PatternType"); + patterntype = pdf_dict_gets(ctx, obj, "PatternType"); - if (pdf_to_int(patterntype) == 1) + if (pdf_to_int(ctx, patterntype) == 1) { pdf_pattern *pat; - pat = pdf_load_pattern(csi->doc, obj); + pat = pdf_load_pattern(ctx, csi->doc, obj); pdf_set_pattern(csi, pr, what, pat, csi->top > 0 ? csi->stack : NULL); pdf_drop_pattern(ctx, pat); } - else if (pdf_to_int(patterntype) == 2) + else if (pdf_to_int(ctx, patterntype) == 2) { fz_shade *shd; - shd = pdf_load_shading(csi->doc, obj); + shd = pdf_load_shading(ctx, csi->doc, obj); pdf_set_shade(csi, pr, what, shd); fz_drop_shade(ctx, shd); } else { - fz_throw(ctx, FZ_ERROR_GENERIC, "unknown pattern type: %d", pdf_to_int(patterntype)); + fz_throw(ctx, FZ_ERROR_GENERIC, "unknown pattern type: %d", pdf_to_int(ctx, patterntype)); } break; @@ -2175,7 +2179,7 @@ static void pdf_run_TL(pdf_csi *csi, void *state) static void pdf_run_Tf(pdf_csi *csi, void *state) { pdf_run_state *pr = (pdf_run_state *)state; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_obj *rdb = csi->rdb; pdf_gstate *gstate = pr->gstate + pr->gtop; pdf_obj *dict; @@ -2186,11 +2190,11 @@ static void pdf_run_Tf(pdf_csi *csi, void *state) pdf_drop_font(ctx, gstate->font); gstate->font = NULL; - dict = pdf_dict_gets(rdb, "Font"); + dict = pdf_dict_gets(ctx, rdb, "Font"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find Font dictionary"); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find font resource: '%s'", csi->name); @@ -2314,7 +2318,7 @@ static void pdf_run_c(pdf_csi *csi, void *state) d = csi->stack[3]; e = csi->stack[4]; f = csi->stack[5]; - fz_curveto(csi->doc->ctx, pr->path, a, b, c, d, e, f); + fz_curveto(csi->ctx, pr->path, a, b, c, d, e, f); } static void pdf_run_cm(pdf_csi *csi, void *state) @@ -2336,6 +2340,7 @@ static void pdf_run_cm(pdf_csi *csi, void *state) static void pdf_run_d(pdf_csi *csi, void *state) { + fz_context *ctx = csi->ctx; pdf_run_state *pr = (pdf_run_state *)state; pdf_gstate *gstate = pr->gstate + pr->gtop; pdf_obj *array; @@ -2343,11 +2348,11 @@ static void pdf_run_d(pdf_csi *csi, void *state) int len; array = csi->obj; - len = pdf_array_len(array); - gstate->stroke_state = fz_unshare_stroke_state_with_dash_len(csi->doc->ctx, gstate->stroke_state, len); + len = pdf_array_len(ctx, array); + gstate->stroke_state = fz_unshare_stroke_state_with_dash_len(csi->ctx, gstate->stroke_state, len); gstate->stroke_state->dash_len = len; for (i = 0; i < len; i++) - gstate->stroke_state->dash_list[i] = pdf_to_real(pdf_array_get(array, i)); + gstate->stroke_state->dash_list[i] = pdf_to_real(ctx, pdf_array_get(ctx, array, i)); gstate->stroke_state->dash_phase = csi->stack[0]; } @@ -2396,7 +2401,7 @@ static void pdf_run_g(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_FILLCOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_gray(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_gray(csi->ctx)); pdf_set_color(csi, pr, PDF_FILL, csi->stack); } @@ -2405,14 +2410,14 @@ static void pdf_run_gs(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pdf_obj *dict; pdf_obj *obj; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_obj *rdb = csi->rdb; - dict = pdf_dict_gets(rdb, "ExtGState"); + dict = pdf_dict_gets(ctx, rdb, "ExtGState"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find ExtGState dictionary"); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find extgstate resource '%s'", csi->name); @@ -2423,7 +2428,7 @@ static void pdf_run_h(pdf_csi *csi, void *state) { pdf_run_state *pr = (pdf_run_state *)state; - fz_closepath(csi->doc->ctx, pr->path); + fz_closepath(csi->ctx, pr->path); } static void pdf_run_i(pdf_csi *csi, void *state) @@ -2436,7 +2441,7 @@ static void pdf_run_j(pdf_csi *csi, void *state) pdf_gstate *gstate = pr->gstate + pr->gtop; pr->dev->flags &= ~FZ_DEVFLAG_LINEJOIN_UNDEFINED; - gstate->stroke_state = fz_unshare_stroke_state(csi->doc->ctx, gstate->stroke_state); + gstate->stroke_state = fz_unshare_stroke_state(csi->ctx, gstate->stroke_state); gstate->stroke_state->linejoin = csi->stack[0]; } @@ -2445,7 +2450,7 @@ static void pdf_run_k(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_FILLCOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_cmyk(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_cmyk(csi->ctx)); pdf_set_color(csi, pr, PDF_FILL, csi->stack); } @@ -2456,7 +2461,7 @@ static void pdf_run_l(pdf_csi *csi, void *state) a = csi->stack[0]; b = csi->stack[1]; - fz_lineto(csi->doc->ctx, pr->path, a, b); + fz_lineto(csi->ctx, pr->path, a, b); } static void pdf_run_m(pdf_csi *csi, void *state) @@ -2466,7 +2471,7 @@ static void pdf_run_m(pdf_csi *csi, void *state) a = csi->stack[0]; b = csi->stack[1]; - fz_moveto(csi->doc->ctx, pr->path, a, b); + fz_moveto(csi->ctx, pr->path, a, b); } static void pdf_run_n(pdf_csi *csi, void *state) @@ -2486,7 +2491,7 @@ static void pdf_run_q(pdf_csi *csi, void *state) static void pdf_run_re(pdf_csi *csi, void *state) { pdf_run_state *pr = (pdf_run_state *)state; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; float x, y, w, h; x = csi->stack[0]; @@ -2506,7 +2511,7 @@ static void pdf_run_rg(pdf_csi *csi, void *state) pdf_run_state *pr = (pdf_run_state *)state; pr->dev->flags &= ~FZ_DEVFLAG_FILLCOLOR_UNDEFINED; - pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_rgb(csi->doc->ctx)); + pdf_set_colorspace(csi, pr, PDF_FILL, fz_device_rgb(csi->ctx)); pdf_set_color(csi, pr, PDF_FILL, csi->stack); } @@ -2524,23 +2529,23 @@ static void pdf_run_s(pdf_csi *csi, void *state) static void pdf_run_sh(pdf_csi *csi, void *state) { pdf_run_state *pr = (pdf_run_state *)state; - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_obj *rdb = csi->rdb; pdf_obj *dict; pdf_obj *obj; fz_shade *shd; - dict = pdf_dict_gets(rdb, "Shading"); + dict = pdf_dict_gets(ctx, rdb, "Shading"); if (!dict) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find shading dictionary"); - obj = pdf_dict_gets(dict, csi->name); + obj = pdf_dict_gets(ctx, dict, csi->name); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find shading resource: '%s'", csi->name); if ((pr->dev->hints & FZ_IGNORE_SHADE) == 0) { - shd = pdf_load_shading(csi->doc, obj); + shd = pdf_load_shading(ctx, csi->doc, obj); fz_try(ctx) { @@ -2566,7 +2571,7 @@ static void pdf_run_v(pdf_csi *csi, void *state) b = csi->stack[1]; c = csi->stack[2]; d = csi->stack[3]; - fz_curvetov(csi->doc->ctx, pr->path, a, b, c, d); + fz_curvetov(csi->ctx, pr->path, a, b, c, d); } static void pdf_run_w(pdf_csi *csi, void *state) @@ -2576,7 +2581,7 @@ static void pdf_run_w(pdf_csi *csi, void *state) gstate = pdf_flush_text(csi, pr); /* linewidth affects stroked text rendering mode */ pr->dev->flags &= ~FZ_DEVFLAG_LINEWIDTH_UNDEFINED; - gstate->stroke_state = fz_unshare_stroke_state(csi->doc->ctx, gstate->stroke_state); + gstate->stroke_state = fz_unshare_stroke_state(csi->ctx, gstate->stroke_state); gstate->stroke_state->linewidth = csi->stack[0]; } @@ -2589,7 +2594,7 @@ static void pdf_run_y(pdf_csi *csi, void *state) b = csi->stack[1]; c = csi->stack[2]; d = csi->stack[3]; - fz_curvetoy(csi->doc->ctx, pr->path, a, b, c, d); + fz_curvetoy(csi->ctx, pr->path, a, b, c, d); } static void pdf_run_squote(pdf_csi *csi, void *state) @@ -2625,7 +2630,7 @@ static void pdf_run_dquote(pdf_csi *csi, void *state) static void free_processor_normal(pdf_csi *csi, void *state) { - fz_context *ctx = csi->doc->ctx; + fz_context *ctx = csi->ctx; pdf_run_state *pr = (pdf_run_state *)state; while (pr->gtop) @@ -2640,7 +2645,7 @@ static void free_processor_normal(pdf_csi *csi, void *state) fz_drop_stroke_state(ctx, pr->gstate[0].stroke_state); while (pr->gstate[0].clip_depth--) - fz_pop_clip(pr->dev); + fz_pop_clip(ctx, pr->dev); if (pr->path) fz_drop_path(ctx, pr->path); if (pr->text) fz_drop_text(ctx, pr->text); @@ -2656,10 +2661,10 @@ process_annot(pdf_csi *csi, void *state, pdf_obj *resources, pdf_annot *annot) fz_context *ctx = pr->ctx; int flags; - if (pdf_is_hidden_ocg(pdf_dict_gets(annot->obj, "OC"), csi, pr, resources)) + if (pdf_is_hidden_ocg(pdf_dict_gets(ctx, annot->obj, "OC"), csi, pr, resources)) return; - flags = pdf_to_int(pdf_dict_gets(annot->obj, "F")); + flags = pdf_to_int(ctx, pdf_dict_gets(ctx, annot->obj, "F")); if (!strcmp(pr->event, "Print") && !(flags & (1 << 2))) /* Print */ return; if (!strcmp(pr->event, "View") && (flags & (1 << 5))) /* NoView */ @@ -2810,9 +2815,8 @@ const pdf_processor pdf_processor_normal = process_contents }; -pdf_process *pdf_process_run(pdf_process *process, fz_device *dev, const fz_matrix *ctm, const char *event, pdf_gstate *gstate, int nested) +pdf_process *pdf_init_process_run(fz_context *ctx, pdf_process *process, fz_device *dev, const fz_matrix *ctm, const char *event, pdf_gstate *gstate, int nested) { - fz_context *ctx = dev->ctx; pdf_run_state *pr; pr = fz_malloc_struct(ctx, pdf_run_state); diff --git a/source/pdf/pdf-outline.c b/source/pdf/pdf-outline.c index 4e4ad642..34bb79ed 100644 --- a/source/pdf/pdf-outline.c +++ b/source/pdf/pdf-outline.c @@ -1,9 +1,8 @@ #include "mupdf/pdf.h" static fz_outline * -pdf_load_outline_imp(pdf_document *doc, pdf_obj *dict) +pdf_load_outline_imp(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { - fz_context *ctx = doc->ctx; fz_outline *node, **prev, *first; pdf_obj *obj; pdf_obj *odict = dict; @@ -15,9 +14,9 @@ pdf_load_outline_imp(pdf_document *doc, pdf_obj *dict) { first = NULL; prev = &first; - while (dict && pdf_is_dict(dict)) + while (dict && pdf_is_dict(ctx, dict)) { - if (pdf_mark_obj(dict)) + if (pdf_mark_obj(ctx, dict)) break; node = fz_malloc_struct(ctx, fz_outline); node->title = NULL; @@ -27,26 +26,26 @@ pdf_load_outline_imp(pdf_document *doc, pdf_obj *dict) *prev = node; prev = &node->next; - obj = pdf_dict_gets(dict, "Title"); + obj = pdf_dict_gets(ctx, dict, "Title"); if (obj) - node->title = pdf_to_utf8(doc, obj); + node->title = pdf_to_utf8(ctx, doc, obj); - if ((obj = pdf_dict_gets(dict, "Dest")) != NULL) - node->dest = pdf_parse_link_dest(doc, FZ_LINK_GOTO, obj); - else if ((obj = pdf_dict_gets(dict, "A")) != NULL) - node->dest = pdf_parse_action(doc, obj); + if ((obj = pdf_dict_gets(ctx, dict, "Dest")) != NULL) + node->dest = pdf_parse_link_dest(ctx, doc, FZ_LINK_GOTO, obj); + else if ((obj = pdf_dict_gets(ctx, dict, "A")) != NULL) + node->dest = pdf_parse_action(ctx, doc, obj); - obj = pdf_dict_gets(dict, "First"); + obj = pdf_dict_gets(ctx, dict, "First"); if (obj) - node->down = pdf_load_outline_imp(doc, obj); + node->down = pdf_load_outline_imp(ctx, doc, obj); - dict = pdf_dict_gets(dict, "Next"); + dict = pdf_dict_gets(ctx, dict, "Next"); } } fz_always(ctx) { - for (dict = odict; dict && pdf_obj_marked(dict); dict = pdf_dict_gets(dict, "Next")) - pdf_unmark_obj(dict); + for (dict = odict; dict && pdf_obj_marked(ctx, dict); dict = pdf_dict_gets(ctx, dict, "Next")) + pdf_unmark_obj(ctx, dict); } fz_catch(ctx) { @@ -58,15 +57,15 @@ pdf_load_outline_imp(pdf_document *doc, pdf_obj *dict) } fz_outline * -pdf_load_outline(pdf_document *doc) +pdf_load_outline(fz_context *ctx, pdf_document *doc) { pdf_obj *root, *obj, *first; - root = pdf_dict_gets(pdf_trailer(doc), "Root"); - obj = pdf_dict_gets(root, "Outlines"); - first = pdf_dict_gets(obj, "First"); + root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + obj = pdf_dict_gets(ctx, root, "Outlines"); + first = pdf_dict_gets(ctx, obj, "First"); if (first) - return pdf_load_outline_imp(doc, first); + return pdf_load_outline_imp(ctx, doc, first); return NULL; } diff --git a/source/pdf/pdf-page.c b/source/pdf/pdf-page.c index cf4d1803..c9c92307 100644 --- a/source/pdf/pdf-page.c +++ b/source/pdf/pdf-page.c @@ -1,12 +1,12 @@ #include "mupdf/pdf.h" int -pdf_count_pages(pdf_document *doc) +pdf_count_pages(fz_context *ctx, pdf_document *doc) { if (doc->page_count == 0) { - pdf_obj *count = pdf_dict_getp(pdf_trailer(doc), "Root/Pages/Count"); - doc->page_count = pdf_to_int(count); + pdf_obj *count = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/Pages/Count"); + doc->page_count = pdf_to_int(ctx, count); } return doc->page_count; } @@ -17,9 +17,8 @@ enum }; static pdf_obj * -pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **parentp, int *indexp) +pdf_lookup_page_loc_imp(fz_context *ctx, pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **parentp, int *indexp) { - fz_context *ctx = doc->ctx; pdf_obj *kids; pdf_obj *hit = NULL; int i, len; @@ -37,8 +36,8 @@ pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **p { do { - kids = pdf_dict_gets(node, "Kids"); - len = pdf_array_len(kids); + kids = pdf_dict_gets(ctx, node, "Kids"); + len = pdf_array_len(ctx, kids); if (len == 0) fz_throw(ctx, FZ_ERROR_GENERIC, "Malformed pages tree"); @@ -57,16 +56,16 @@ pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **p } stack[stack_len++] = node; - if (pdf_mark_obj(node)) + if (pdf_mark_obj(ctx, node)) fz_throw(ctx, FZ_ERROR_GENERIC, "cycle in page tree"); for (i = 0; i < len; i++) { - pdf_obj *kid = pdf_array_get(kids, i); - char *type = pdf_to_name(pdf_dict_gets(kid, "Type")); - if (*type ? !strcmp(type, "Pages") : pdf_dict_gets(kid, "Kids") && !pdf_dict_gets(kid, "MediaBox")) + pdf_obj *kid = pdf_array_get(ctx, kids, i); + char *type = pdf_to_name(ctx, pdf_dict_gets(ctx, kid, "Type")); + if (*type ? !strcmp(type, "Pages") : pdf_dict_gets(ctx, kid, "Kids") && !pdf_dict_gets(ctx, kid, "MediaBox")) { - int count = pdf_to_int(pdf_dict_gets(kid, "Count")); + int count = pdf_to_int(ctx, pdf_dict_gets(ctx, kid, "Count")); if (*skip < count) { node = kid; @@ -79,7 +78,7 @@ pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **p } else { - if (*type ? strcmp(type, "Page") != 0 : !pdf_dict_gets(kid, "MediaBox")) + if (*type ? strcmp(type, "Page") != 0 : !pdf_dict_gets(ctx, kid, "MediaBox")) fz_warn(ctx, "non-page object in page tree (%s)", type); if (*skip == 0) { @@ -100,7 +99,7 @@ pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **p fz_always(ctx) { for (i = stack_len; i > 0; i--) - pdf_unmark_obj(stack[i-1]); + pdf_unmark_obj(ctx, stack[i-1]); if (stack != &local_stack[0]) fz_free(ctx, stack); } @@ -113,74 +112,73 @@ pdf_lookup_page_loc_imp(pdf_document *doc, pdf_obj *node, int *skip, pdf_obj **p } pdf_obj * -pdf_lookup_page_loc(pdf_document *doc, int needle, pdf_obj **parentp, int *indexp) +pdf_lookup_page_loc(fz_context *ctx, pdf_document *doc, int needle, pdf_obj **parentp, int *indexp) { - pdf_obj *root = pdf_dict_gets(pdf_trailer(doc), "Root"); - pdf_obj *node = pdf_dict_gets(root, "Pages"); + pdf_obj *root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pdf_obj *node = pdf_dict_gets(ctx, root, "Pages"); int skip = needle; pdf_obj *hit; if (!node) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find page tree"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find page tree"); - hit = pdf_lookup_page_loc_imp(doc, node, &skip, parentp, indexp); + hit = pdf_lookup_page_loc_imp(ctx, doc, node, &skip, parentp, indexp); if (!hit) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find page %d in page tree", needle); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find page %d in page tree", needle); return hit; } pdf_obj * -pdf_lookup_page_obj(pdf_document *doc, int needle) +pdf_lookup_page_obj(fz_context *ctx, pdf_document *doc, int needle) { - return pdf_lookup_page_loc(doc, needle, NULL, NULL); + return pdf_lookup_page_loc(ctx, doc, needle, NULL, NULL); } static int -pdf_count_pages_before_kid(pdf_document *doc, pdf_obj *parent, int kid_num) +pdf_count_pages_before_kid(fz_context *ctx, pdf_document *doc, pdf_obj *parent, int kid_num) { - pdf_obj *kids = pdf_dict_gets(parent, "Kids"); - int i, total = 0, len = pdf_array_len(kids); + pdf_obj *kids = pdf_dict_gets(ctx, parent, "Kids"); + int i, total = 0, len = pdf_array_len(ctx, kids); for (i = 0; i < len; i++) { - pdf_obj *kid = pdf_array_get(kids, i); - if (pdf_to_num(kid) == kid_num) + pdf_obj *kid = pdf_array_get(ctx, kids, i); + if (pdf_to_num(ctx, kid) == kid_num) return total; - if (!strcmp(pdf_to_name(pdf_dict_gets(kid, "Type")), "Pages")) + if (!strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, kid, "Type")), "Pages")) { - pdf_obj *count = pdf_dict_gets(kid, "Count"); - int n = pdf_to_int(count); - if (!pdf_is_int(count) || n < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "illegal or missing count in pages tree"); + pdf_obj *count = pdf_dict_gets(ctx, kid, "Count"); + int n = pdf_to_int(ctx, count); + if (!pdf_is_int(ctx, count) || n < 0) + fz_throw(ctx, FZ_ERROR_GENERIC, "illegal or missing count in pages tree"); total += n; } else total++; } - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "kid not found in parent's kids array"); + fz_throw(ctx, FZ_ERROR_GENERIC, "kid not found in parent's kids array"); } int -pdf_lookup_page_number(pdf_document *doc, pdf_obj *node) +pdf_lookup_page_number(fz_context *ctx, pdf_document *doc, pdf_obj *node) { - fz_context *ctx = doc->ctx; - int needle = pdf_to_num(node); + int needle = pdf_to_num(ctx, node); int total = 0; pdf_obj *parent, *parent2; - if (strcmp(pdf_to_name(pdf_dict_gets(node, "Type")), "Page") != 0) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, node, "Type")), "Page") != 0) fz_throw(ctx, FZ_ERROR_GENERIC, "invalid page object"); - parent2 = parent = pdf_dict_gets(node, "Parent"); + parent2 = parent = pdf_dict_gets(ctx, node, "Parent"); fz_var(parent); fz_try(ctx) { - while (pdf_is_dict(parent)) + while (pdf_is_dict(ctx, parent)) { - if (pdf_mark_obj(parent)) + if (pdf_mark_obj(ctx, parent)) fz_throw(ctx, FZ_ERROR_GENERIC, "cycle in page tree (parents)"); - total += pdf_count_pages_before_kid(doc, parent, needle); - needle = pdf_to_num(parent); - parent = pdf_dict_gets(parent, "Parent"); + total += pdf_count_pages_before_kid(ctx, doc, parent, needle); + needle = pdf_to_num(ctx, parent); + parent = pdf_dict_gets(ctx, parent, "Parent"); } } fz_always(ctx) @@ -188,10 +186,10 @@ pdf_lookup_page_number(pdf_document *doc, pdf_obj *node) /* Run back and unmark */ while (parent2) { - pdf_unmark_obj(parent2); + pdf_unmark_obj(ctx, parent2); if (parent2 == parent) break; - parent2 = pdf_dict_gets(parent2, "Parent"); + parent2 = pdf_dict_gets(ctx, parent2, "Parent"); } } fz_catch(ctx) @@ -203,9 +201,8 @@ pdf_lookup_page_number(pdf_document *doc, pdf_obj *node) } static pdf_obj * -pdf_lookup_inherited_page_item(pdf_document *doc, pdf_obj *node, const char *key) +pdf_lookup_inherited_page_item(fz_context *ctx, pdf_document *doc, pdf_obj *node, const char *key) { - fz_context *ctx = doc->ctx; pdf_obj *node2 = node; pdf_obj *val; @@ -215,12 +212,12 @@ pdf_lookup_inherited_page_item(pdf_document *doc, pdf_obj *node, const char *key { do { - val = pdf_dict_gets(node, key); + val = pdf_dict_gets(ctx, node, key); if (val) break; - if (pdf_mark_obj(node)) + if (pdf_mark_obj(ctx, node)) fz_throw(ctx, FZ_ERROR_GENERIC, "cycle in page tree (parents)"); - node = pdf_dict_gets(node, "Parent"); + node = pdf_dict_gets(ctx, node, "Parent"); } while (node); } @@ -228,10 +225,10 @@ pdf_lookup_inherited_page_item(pdf_document *doc, pdf_obj *node, const char *key { do { - pdf_unmark_obj(node2); + pdf_unmark_obj(ctx, node2); if (node2 == node) break; - node2 = pdf_dict_gets(node2, "Parent"); + node2 = pdf_dict_gets(ctx, node2, "Parent"); } while (node2); } @@ -245,41 +242,40 @@ pdf_lookup_inherited_page_item(pdf_document *doc, pdf_obj *node, const char *key /* We need to know whether to install a page-level transparency group */ -static int pdf_resources_use_blending(pdf_document *doc, pdf_obj *rdb); +static int pdf_resources_use_blending(fz_context *ctx, pdf_document *doc, pdf_obj *rdb); static int -pdf_extgstate_uses_blending(pdf_document *doc, pdf_obj *dict) +pdf_extgstate_uses_blending(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { - pdf_obj *obj = pdf_dict_gets(dict, "BM"); - if (pdf_is_name(obj) && strcmp(pdf_to_name(obj), "Normal")) + pdf_obj *obj = pdf_dict_gets(ctx, dict, "BM"); + if (pdf_is_name(ctx, obj) && strcmp(pdf_to_name(ctx, obj), "Normal")) return 1; return 0; } static int -pdf_pattern_uses_blending(pdf_document *doc, pdf_obj *dict) +pdf_pattern_uses_blending(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { pdf_obj *obj; - obj = pdf_dict_gets(dict, "Resources"); - if (pdf_resources_use_blending(doc, obj)) + obj = pdf_dict_gets(ctx, dict, "Resources"); + if (pdf_resources_use_blending(ctx, doc, obj)) return 1; - obj = pdf_dict_gets(dict, "ExtGState"); - return pdf_extgstate_uses_blending(doc, obj); + obj = pdf_dict_gets(ctx, dict, "ExtGState"); + return pdf_extgstate_uses_blending(ctx, doc, obj); } static int -pdf_xobject_uses_blending(pdf_document *doc, pdf_obj *dict) +pdf_xobject_uses_blending(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { - pdf_obj *obj = pdf_dict_gets(dict, "Resources"); - if (!strcmp(pdf_to_name(pdf_dict_getp(dict, "Group/S")), "Transparency")) + pdf_obj *obj = pdf_dict_gets(ctx, dict, "Resources"); + if (!strcmp(pdf_to_name(ctx, pdf_dict_getp(ctx, dict, "Group/S")), "Transparency")) return 1; - return pdf_resources_use_blending(doc, obj); + return pdf_resources_use_blending(ctx, doc, obj); } static int -pdf_resources_use_blending(pdf_document *doc, pdf_obj *rdb) +pdf_resources_use_blending(fz_context *ctx, pdf_document *doc, pdf_obj *rdb) { - fz_context *ctx = doc->ctx; pdf_obj *obj; int i, n, useBM = 0; @@ -287,31 +283,31 @@ pdf_resources_use_blending(pdf_document *doc, pdf_obj *rdb) return 0; /* Have we been here before and remembered an answer? */ - if (pdf_obj_memo(rdb, &useBM)) + if (pdf_obj_memo(ctx, rdb, &useBM)) return useBM; /* stop on cyclic resource dependencies */ - if (pdf_mark_obj(rdb)) + if (pdf_mark_obj(ctx, rdb)) return 0; fz_try(ctx) { - obj = pdf_dict_gets(rdb, "ExtGState"); - n = pdf_dict_len(obj); + obj = pdf_dict_gets(ctx, rdb, "ExtGState"); + n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) - if (pdf_extgstate_uses_blending(doc, pdf_dict_get_val(obj, i))) + if (pdf_extgstate_uses_blending(ctx, doc, pdf_dict_get_val(ctx, obj, i))) goto found; - obj = pdf_dict_gets(rdb, "Pattern"); - n = pdf_dict_len(obj); + obj = pdf_dict_gets(ctx, rdb, "Pattern"); + n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) - if (pdf_pattern_uses_blending(doc, pdf_dict_get_val(obj, i))) + if (pdf_pattern_uses_blending(ctx, doc, pdf_dict_get_val(ctx, obj, i))) goto found; - obj = pdf_dict_gets(rdb, "XObject"); - n = pdf_dict_len(obj); + obj = pdf_dict_gets(ctx, rdb, "XObject"); + n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) - if (pdf_xobject_uses_blending(doc, pdf_dict_get_val(obj, i))) + if (pdf_xobject_uses_blending(ctx, doc, pdf_dict_get_val(ctx, obj, i))) goto found; if (0) { @@ -321,36 +317,36 @@ found: } fz_always(ctx) { - pdf_unmark_obj(rdb); + pdf_unmark_obj(ctx, rdb); } fz_catch(ctx) { fz_rethrow(ctx); } - pdf_set_obj_memo(rdb, useBM); + pdf_set_obj_memo(ctx, rdb, useBM); return useBM; } static void -pdf_load_transition(pdf_document *doc, pdf_page *page, pdf_obj *transdict) +pdf_load_transition(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_obj *transdict) { char *name; pdf_obj *obj; int type; - obj = pdf_dict_gets(transdict, "D"); - page->transition.duration = (obj ? pdf_to_real(obj) : 1); + obj = pdf_dict_gets(ctx, transdict, "D"); + page->transition.duration = (obj ? pdf_to_real(ctx, obj) : 1); - page->transition.vertical = (pdf_to_name(pdf_dict_gets(transdict, "Dm"))[0] != 'H'); - page->transition.outwards = (pdf_to_name(pdf_dict_gets(transdict, "M"))[0] != 'I'); + page->transition.vertical = (pdf_to_name(ctx, pdf_dict_gets(ctx, transdict, "Dm"))[0] != 'H'); + page->transition.outwards = (pdf_to_name(ctx, pdf_dict_gets(ctx, transdict, "M"))[0] != 'I'); /* FIXME: If 'Di' is None, it should be handled differently, but * this only affects Fly, and we don't implement that currently. */ - page->transition.direction = (pdf_to_int(pdf_dict_gets(transdict, "Di"))); + page->transition.direction = (pdf_to_int(ctx, pdf_dict_gets(ctx, transdict, "Di"))); /* FIXME: Read SS for Fly when we implement it */ /* FIXME: Read B for Fly when we implement it */ - name = pdf_to_name(pdf_dict_gets(transdict, "S")); + name = pdf_to_name(ctx, pdf_dict_gets(ctx, transdict, "S")); if (!strcmp(name, "Split")) type = FZ_TRANSITION_SPLIT; else if (!strcmp(name, "Blinds")) @@ -378,10 +374,55 @@ pdf_load_transition(pdf_document *doc, pdf_page *page, pdf_obj *transdict) page->transition.type = type; } +fz_rect * +pdf_bound_page(fz_context *ctx, pdf_page *page, fz_rect *bounds) +{ + fz_matrix mtx; + fz_rect mediabox = page->mediabox; + fz_transform_rect(&mediabox, fz_rotate(&mtx, page->rotate)); + bounds->x0 = bounds->y0 = 0; + bounds->x1 = mediabox.x1 - mediabox.x0; + bounds->y1 = mediabox.y1 - mediabox.y0; + return bounds; +} + +fz_link * +pdf_load_links(fz_context *ctx, pdf_page *page) +{ + return fz_keep_link(ctx, page->links); +} + +static void +pdf_drop_page_imp(fz_context *ctx, pdf_page *page) +{ + pdf_document *doc = page->doc; + + if (page == NULL) + return; + + pdf_drop_obj(ctx, page->resources); + pdf_drop_obj(ctx, page->contents); + if (page->links) + fz_drop_link(ctx, page->links); + if (page->annots) + pdf_drop_annot(ctx, page->annots); + if (page->deleted_annots) + pdf_drop_annot(ctx, page->deleted_annots); + if (page->tmp_annots) + pdf_drop_annot(ctx, page->tmp_annots); + /* doc->focus, when not NULL, refers to one of + * the annotations and must be NULLed when the + * annotations are destroyed. doc->focus_obj + * keeps track of the actual annotation object. */ + doc->focus = NULL; + pdf_drop_obj(ctx, page->me); + + fz_drop_document(ctx, &page->doc->super); +} + pdf_page * -pdf_load_page(pdf_document *doc, int number) +pdf_load_page(fz_context *ctx, pdf_document *doc, int number) { - fz_context *ctx = doc->ctx; pdf_page *page; pdf_annot *annot; pdf_obj *pageobj, *pageref, *obj; @@ -391,15 +432,27 @@ pdf_load_page(pdf_document *doc, int number) if (doc->file_reading_linearly) { - pageref = pdf_progressive_advance(doc, number); + pageref = pdf_progressive_advance(ctx, doc, number); if (pageref == NULL) - fz_throw(doc->ctx, FZ_ERROR_TRYLATER, "page %d not available yet", number); + fz_throw(ctx, FZ_ERROR_TRYLATER, "page %d not available yet", number); } else - pageref = pdf_lookup_page_obj(doc, number); - pageobj = pdf_resolve_indirect(pageref); + pageref = pdf_lookup_page_obj(ctx, doc, number); + pageobj = pdf_resolve_indirect(ctx, pageref); page = fz_malloc_struct(ctx, pdf_page); + page->doc = (pdf_document*) fz_keep_document(ctx, &doc->super); + + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)pdf_drop_page_imp; + page->super.load_links = (fz_page_load_links_fn *)pdf_load_links; + page->super.bound_page = (fz_page_bound_page_fn *)pdf_bound_page; + page->super.first_annot = (fz_page_first_annot_fn *)pdf_first_annot; + page->super.next_annot = (fz_page_next_annot_fn *)pdf_next_annot; + page->super.bound_annot = (fz_page_bound_annot_fn *)pdf_bound_annot; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)pdf_run_page_contents; + page->super.run_annot = (fz_page_run_annot_fn *)pdf_run_annot; + page->super.page_presentation = (fz_page_page_presentation_fn *)pdf_page_presentation; + page->resources = NULL; page->contents = NULL; page->transparency = 0; @@ -408,16 +461,16 @@ pdf_load_page(pdf_document *doc, int number) page->annot_tailp = &page->annots; page->deleted_annots = NULL; page->tmp_annots = NULL; - page->me = pdf_keep_obj(pageobj); + page->me = pdf_keep_obj(ctx, pageobj); page->incomplete = 0; - obj = pdf_dict_gets(pageobj, "UserUnit"); - if (pdf_is_real(obj)) - userunit = pdf_to_real(obj); + obj = pdf_dict_gets(ctx, pageobj, "UserUnit"); + if (pdf_is_real(ctx, obj)) + userunit = pdf_to_real(ctx, obj); else userunit = 1; - pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "MediaBox"), &mediabox); + pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, doc, pageobj, "MediaBox"), &mediabox); if (fz_is_empty_rect(&mediabox)) { fz_warn(ctx, "cannot find page size for page %d", number + 1); @@ -427,7 +480,7 @@ pdf_load_page(pdf_document *doc, int number) mediabox.y1 = 792; } - pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "CropBox"), &cropbox); + pdf_to_rect(ctx, pdf_lookup_inherited_page_item(ctx, doc, pageobj, "CropBox"), &cropbox); if (!fz_is_empty_rect(&cropbox)) fz_intersect_rect(&mediabox, &cropbox); @@ -442,7 +495,7 @@ pdf_load_page(pdf_document *doc, int number) page->mediabox = fz_unit_rect; } - page->rotate = pdf_to_int(pdf_lookup_inherited_page_item(doc, pageobj, "Rotate")); + page->rotate = pdf_to_int(ctx, pdf_lookup_inherited_page_item(ctx, doc, pageobj, "Rotate")); /* Snap page->rotate to 0, 90, 180 or 270 */ if (page->rotate < 0) page->rotate = 360 - ((-page->rotate) % 360); @@ -460,11 +513,11 @@ pdf_load_page(pdf_document *doc, int number) fz_try(ctx) { - obj = pdf_dict_gets(pageobj, "Annots"); + obj = pdf_dict_gets(ctx, pageobj, "Annots"); if (obj) { - page->links = pdf_load_link_annots(doc, obj, &page->ctm); - pdf_load_annots(doc, page, obj); + page->links = pdf_load_link_annots(ctx, doc, obj, &page->ctm); + pdf_load_annots(ctx, doc, page, obj); } } fz_catch(ctx) @@ -476,40 +529,40 @@ pdf_load_page(pdf_document *doc, int number) page->links = NULL; } - page->duration = pdf_to_real(pdf_dict_gets(pageobj, "Dur")); + page->duration = pdf_to_real(ctx, pdf_dict_gets(ctx, pageobj, "Dur")); - obj = pdf_dict_gets(pageobj, "Trans"); + obj = pdf_dict_gets(ctx, pageobj, "Trans"); page->transition_present = (obj != NULL); if (obj) { - pdf_load_transition(doc, page, obj); + pdf_load_transition(ctx, doc, page, obj); } // TODO: inherit - page->resources = pdf_lookup_inherited_page_item(doc, pageobj, "Resources"); + page->resources = pdf_lookup_inherited_page_item(ctx, doc, pageobj, "Resources"); if (page->resources) - pdf_keep_obj(page->resources); + pdf_keep_obj(ctx, page->resources); - obj = pdf_dict_gets(pageobj, "Contents"); + obj = pdf_dict_gets(ctx, pageobj, "Contents"); fz_try(ctx) { - page->contents = pdf_keep_obj(obj); + page->contents = pdf_keep_obj(ctx, obj); - if (pdf_resources_use_blending(doc, page->resources)) + if (pdf_resources_use_blending(ctx, doc, page->resources)) page->transparency = 1; - else if (!strcmp(pdf_to_name(pdf_dict_getp(pageobj, "Group/S")), "Transparency")) + else if (!strcmp(pdf_to_name(ctx, pdf_dict_getp(ctx, pageobj, "Group/S")), "Transparency")) page->transparency = 1; for (annot = page->annots; annot && !page->transparency; annot = annot->next) - if (annot->ap && pdf_resources_use_blending(doc, annot->ap->resources)) + if (annot->ap && pdf_resources_use_blending(ctx, doc, annot->ap->resources)) page->transparency = 1; } fz_catch(ctx) { if (fz_caught(ctx) != FZ_ERROR_TRYLATER) { - pdf_drop_page(doc, page); - fz_rethrow_message(ctx, "cannot load page %d contents (%d 0 R)", number + 1, pdf_to_num(pageref)); + fz_drop_page(ctx, &page->super); + fz_rethrow_message(ctx, "cannot load page %d contents (%d 0 R)", number + 1, pdf_to_num(ctx, pageref)); } page->incomplete |= PDF_PAGE_INCOMPLETE_CONTENTS; } @@ -517,93 +570,50 @@ pdf_load_page(pdf_document *doc, int number) return page; } -fz_rect * -pdf_bound_page(pdf_document *doc, pdf_page *page, fz_rect *bounds) -{ - fz_matrix mtx; - fz_rect mediabox = page->mediabox; - fz_transform_rect(&mediabox, fz_rotate(&mtx, page->rotate)); - bounds->x0 = bounds->y0 = 0; - bounds->x1 = mediabox.x1 - mediabox.x0; - bounds->y1 = mediabox.y1 - mediabox.y0; - return bounds; -} - -fz_link * -pdf_load_links(pdf_document *doc, pdf_page *page) -{ - return fz_keep_link(doc->ctx, page->links); -} - -void -pdf_drop_page(pdf_document *doc, pdf_page *page) -{ - if (page == NULL) - return; - pdf_drop_obj(page->resources); - pdf_drop_obj(page->contents); - if (page->links) - fz_drop_link(doc->ctx, page->links); - if (page->annots) - pdf_drop_annot(doc->ctx, page->annots); - if (page->deleted_annots) - pdf_drop_annot(doc->ctx, page->deleted_annots); - if (page->tmp_annots) - pdf_drop_annot(doc->ctx, page->tmp_annots); - /* doc->focus, when not NULL, refers to one of - * the annotations and must be NULLed when the - * annotations are destroyed. doc->focus_obj - * keeps track of the actual annotation object. */ - doc->focus = NULL; - pdf_drop_obj(page->me); - fz_free(doc->ctx, page); -} - void -pdf_delete_page(pdf_document *doc, int at) +pdf_delete_page(fz_context *ctx, pdf_document *doc, int at) { pdf_obj *parent, *kids; int i; - pdf_lookup_page_loc(doc, at, &parent, &i); - kids = pdf_dict_gets(parent, "Kids"); - pdf_array_delete(kids, i); + pdf_lookup_page_loc(ctx, doc, at, &parent, &i); + kids = pdf_dict_gets(ctx, parent, "Kids"); + pdf_array_delete(ctx, kids, i); while (parent) { - int count = pdf_to_int(pdf_dict_gets(parent, "Count")); - pdf_dict_puts_drop(parent, "Count", pdf_new_int(doc, count - 1)); - parent = pdf_dict_gets(parent, "Parent"); + int count = pdf_to_int(ctx, pdf_dict_gets(ctx, parent, "Count")); + pdf_dict_puts_drop(ctx, parent, "Count", pdf_new_int(ctx, doc, count - 1)); + parent = pdf_dict_gets(ctx, parent, "Parent"); } doc->page_count = 0; /* invalidate cached value */ } void -pdf_insert_page(pdf_document *doc, pdf_page *page, int at) +pdf_insert_page(fz_context *ctx, pdf_document *doc, pdf_page *page, int at) { - fz_context *ctx = doc->ctx; - int count = pdf_count_pages(doc); + int count = pdf_count_pages(ctx, doc); pdf_obj *parent, *kids; pdf_obj *page_ref; int i; - page_ref = pdf_new_ref(doc, page->me); + page_ref = pdf_new_ref(ctx, doc, page->me); fz_try(ctx) { if (count == 0) { - pdf_obj *root = pdf_dict_gets(pdf_trailer(doc), "Root"); - parent = pdf_dict_gets(root, "Pages"); + pdf_obj *root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + parent = pdf_dict_gets(ctx, root, "Pages"); if (!parent) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find page tree"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find page tree"); - kids = pdf_dict_gets(parent, "Kids"); + kids = pdf_dict_gets(ctx, parent, "Kids"); if (!kids) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "malformed page tree"); + fz_throw(ctx, FZ_ERROR_GENERIC, "malformed page tree"); - pdf_array_insert(kids, page_ref, 0); + pdf_array_insert(ctx, kids, page_ref, 0); } else if (at >= count) { @@ -614,32 +624,32 @@ pdf_insert_page(pdf_document *doc, pdf_page *page, int at) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot insert page beyond end of page tree"); /* append after last page */ - pdf_lookup_page_loc(doc, count - 1, &parent, &i); - kids = pdf_dict_gets(parent, "Kids"); - pdf_array_insert(kids, page_ref, i + 1); + pdf_lookup_page_loc(ctx, doc, count - 1, &parent, &i); + kids = pdf_dict_gets(ctx, parent, "Kids"); + pdf_array_insert(ctx, kids, page_ref, i + 1); } else { /* insert before found page */ - pdf_lookup_page_loc(doc, at, &parent, &i); - kids = pdf_dict_gets(parent, "Kids"); - pdf_array_insert(kids, page_ref, i); + pdf_lookup_page_loc(ctx, doc, at, &parent, &i); + kids = pdf_dict_gets(ctx, parent, "Kids"); + pdf_array_insert(ctx, kids, page_ref, i); } - pdf_dict_puts(page->me, "Parent", parent); + pdf_dict_puts(ctx, page->me, "Parent", parent); /* Adjust page counts */ while (parent) { - int count = pdf_to_int(pdf_dict_gets(parent, "Count")); - pdf_dict_puts_drop(parent, "Count", pdf_new_int(doc, count + 1)); - parent = pdf_dict_gets(parent, "Parent"); + int count = pdf_to_int(ctx, pdf_dict_gets(ctx, parent, "Count")); + pdf_dict_puts_drop(ctx, parent, "Count", pdf_new_int(ctx, doc, count + 1)); + parent = pdf_dict_gets(ctx, parent, "Parent"); } } fz_always(ctx) { - pdf_drop_obj(page_ref); + pdf_drop_obj(ctx, page_ref); } fz_catch(ctx) { @@ -650,19 +660,18 @@ pdf_insert_page(pdf_document *doc, pdf_page *page, int at) } void -pdf_delete_page_range(pdf_document *doc, int start, int end) +pdf_delete_page_range(fz_context *ctx, pdf_document *doc, int start, int end) { while (start < end) - pdf_delete_page(doc, start++); + pdf_delete_page(ctx, doc, start++); } pdf_page * -pdf_create_page(pdf_document *doc, fz_rect mediabox, int res, int rotate) +pdf_create_page(fz_context *ctx, pdf_document *doc, fz_rect mediabox, int res, int rotate) { pdf_page *page = NULL; pdf_obj *pageobj; float userunit = 1; - fz_context *ctx = doc->ctx; fz_matrix ctm, tmp; fz_rect realbox; @@ -675,15 +684,15 @@ pdf_create_page(pdf_document *doc, fz_rect mediabox, int res, int rotate) page->transparency = 0; page->links = NULL; page->annots = NULL; - page->me = pageobj = pdf_new_dict(doc, 4); + page->me = pageobj = pdf_new_dict(ctx, doc, 4); - pdf_dict_puts_drop(pageobj, "Type", pdf_new_name(doc, "Page")); + pdf_dict_puts_drop(ctx, pageobj, "Type", pdf_new_name(ctx, doc, "Page")); page->mediabox.x0 = fz_min(mediabox.x0, mediabox.x1) * userunit; page->mediabox.y0 = fz_min(mediabox.y0, mediabox.y1) * userunit; page->mediabox.x1 = fz_max(mediabox.x0, mediabox.x1) * userunit; page->mediabox.y1 = fz_max(mediabox.y0, mediabox.y1) * userunit; - pdf_dict_puts_drop(pageobj, "MediaBox", pdf_new_rect(doc, &page->mediabox)); + pdf_dict_puts_drop(ctx, pageobj, "MediaBox", pdf_new_rect(ctx, doc, &page->mediabox)); /* Snap page->rotate to 0, 90, 180 or 270 */ if (page->rotate < 0) @@ -693,7 +702,7 @@ pdf_create_page(pdf_document *doc, fz_rect mediabox, int res, int rotate) page->rotate = 90*((page->rotate + 45)/90); if (page->rotate > 360) page->rotate = 0; - pdf_dict_puts_drop(pageobj, "Rotate", pdf_new_int(doc, page->rotate)); + pdf_dict_puts_drop(ctx, pageobj, "Rotate", pdf_new_int(ctx, doc, page->rotate)); fz_pre_rotate(fz_scale(&ctm, 1, -1), -page->rotate); realbox = page->mediabox; @@ -706,7 +715,7 @@ pdf_create_page(pdf_document *doc, fz_rect mediabox, int res, int rotate) } fz_catch(ctx) { - pdf_drop_obj(page->me); + pdf_drop_obj(ctx, page->me); fz_free(ctx, page); fz_rethrow_message(ctx, "Failed to create page"); } diff --git a/source/pdf/pdf-parse.c b/source/pdf/pdf-parse.c index a2fd09db..48761374 100644 --- a/source/pdf/pdf-parse.c +++ b/source/pdf/pdf-parse.c @@ -3,10 +3,10 @@ fz_rect * pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *r) { - float a = pdf_to_real(pdf_array_get(array, 0)); - float b = pdf_to_real(pdf_array_get(array, 1)); - float c = pdf_to_real(pdf_array_get(array, 2)); - float d = pdf_to_real(pdf_array_get(array, 3)); + float a = pdf_to_real(ctx, pdf_array_get(ctx, array, 0)); + float b = pdf_to_real(ctx, pdf_array_get(ctx, array, 1)); + float c = pdf_to_real(ctx, pdf_array_get(ctx, array, 2)); + float d = pdf_to_real(ctx, pdf_array_get(ctx, array, 3)); r->x0 = fz_min(a, c); r->y0 = fz_min(b, d); r->x1 = fz_max(a, c); @@ -17,20 +17,19 @@ pdf_to_rect(fz_context *ctx, pdf_obj *array, fz_rect *r) fz_matrix * pdf_to_matrix(fz_context *ctx, pdf_obj *array, fz_matrix *m) { - m->a = pdf_to_real(pdf_array_get(array, 0)); - m->b = pdf_to_real(pdf_array_get(array, 1)); - m->c = pdf_to_real(pdf_array_get(array, 2)); - m->d = pdf_to_real(pdf_array_get(array, 3)); - m->e = pdf_to_real(pdf_array_get(array, 4)); - m->f = pdf_to_real(pdf_array_get(array, 5)); + m->a = pdf_to_real(ctx, pdf_array_get(ctx, array, 0)); + m->b = pdf_to_real(ctx, pdf_array_get(ctx, array, 1)); + m->c = pdf_to_real(ctx, pdf_array_get(ctx, array, 2)); + m->d = pdf_to_real(ctx, pdf_array_get(ctx, array, 3)); + m->e = pdf_to_real(ctx, pdf_array_get(ctx, array, 4)); + m->f = pdf_to_real(ctx, pdf_array_get(ctx, array, 5)); return m; } /* Convert Unicode/PdfDocEncoding string into utf-8 */ char * -pdf_to_utf8(pdf_document *doc, pdf_obj *src) +pdf_to_utf8(fz_context *ctx, pdf_document *doc, pdf_obj *src) { - fz_context *ctx = doc->ctx; fz_buffer *strmbuf = NULL; unsigned char *srcptr; char *dstptr, *dst; @@ -42,14 +41,14 @@ pdf_to_utf8(pdf_document *doc, pdf_obj *src) fz_var(strmbuf); fz_try(ctx) { - if (pdf_is_string(src)) + if (pdf_is_string(ctx, src)) { - srcptr = (unsigned char *) pdf_to_str_buf(src); - srclen = pdf_to_str_len(src); + srcptr = (unsigned char *) pdf_to_str_buf(ctx, src); + srclen = pdf_to_str_len(ctx, src); } - else if (pdf_is_stream(doc, pdf_to_num(src), pdf_to_gen(src))) + else if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, src), pdf_to_gen(ctx, src))) { - strmbuf = pdf_load_stream(doc, pdf_to_num(src), pdf_to_gen(src)); + strmbuf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, src), pdf_to_gen(ctx, src)); srclen = fz_buffer_storage(ctx, strmbuf, (unsigned char **)&srcptr); } else @@ -118,12 +117,11 @@ pdf_to_utf8(pdf_document *doc, pdf_obj *src) /* Convert Unicode/PdfDocEncoding string into ucs-2 */ unsigned short * -pdf_to_ucs2(pdf_document *doc, pdf_obj *src) +pdf_to_ucs2(fz_context *ctx, pdf_document *doc, pdf_obj *src) { - fz_context *ctx = doc->ctx; - unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(src); + unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(ctx, src); unsigned short *dstptr, *dst; - int srclen = pdf_to_str_len(src); + int srclen = pdf_to_str_len(ctx, src); int i; if (srclen >= 2 && srcptr[0] == 254 && srcptr[1] == 255) @@ -152,11 +150,11 @@ pdf_to_ucs2(pdf_document *doc, pdf_obj *src) /* allow to convert to UCS-2 without the need for an fz_context */ /* (buffer must be at least (fz_to_str_len(src) + 1) * 2 bytes in size) */ void -pdf_to_ucs2_buf(unsigned short *buffer, pdf_obj *src) +pdf_to_ucs2_buf(fz_context *ctx, unsigned short *buffer, pdf_obj *src) { - unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(src); + unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(ctx, src); unsigned short *dstptr = buffer; - int srclen = pdf_to_str_len(src); + int srclen = pdf_to_str_len(ctx, src); int i; if (srclen >= 2 && srcptr[0] == 254 && srcptr[1] == 255) @@ -180,9 +178,8 @@ pdf_to_ucs2_buf(unsigned short *buffer, pdf_obj *src) /* Convert UCS-2 string into PdfDocEncoding for authentication */ char * -pdf_from_ucs2(pdf_document *doc, unsigned short *src) +pdf_from_ucs2(fz_context *ctx, pdf_document *doc, unsigned short *src) { - fz_context *ctx = doc->ctx; int i, j, len; char *docstr; @@ -219,48 +216,47 @@ pdf_from_ucs2(pdf_document *doc, unsigned short *src) } pdf_obj * -pdf_to_utf8_name(pdf_document *doc, pdf_obj *src) +pdf_to_utf8_name(fz_context *ctx, pdf_document *doc, pdf_obj *src) { - char *buf = pdf_to_utf8(doc, src); - pdf_obj *dst = pdf_new_name(doc, buf); - fz_free(doc->ctx, buf); + char *buf = pdf_to_utf8(ctx, doc, src); + pdf_obj *dst = pdf_new_name(ctx, doc, buf); + fz_free(ctx, buf); return dst; } pdf_obj * -pdf_parse_array(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) +pdf_parse_array(fz_context *ctx, pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) { pdf_obj *ary = NULL; pdf_obj *obj = NULL; int a = 0, b = 0, n = 0; pdf_token tok; - fz_context *ctx = file->ctx; pdf_obj *op = NULL; fz_var(obj); - ary = pdf_new_array(doc, 4); + ary = pdf_new_array(ctx, doc, 4); fz_try(ctx) { while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_INT && tok != PDF_TOK_R) { if (n > 0) { - obj = pdf_new_int(doc, a); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, a); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; } if (n > 1) { - obj = pdf_new_int(doc, b); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, b); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; } n = 0; @@ -268,9 +264,9 @@ pdf_parse_array(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) if (tok == PDF_TOK_INT && n == 2) { - obj = pdf_new_int(doc, a); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, a); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; a = b; n --; @@ -293,61 +289,61 @@ pdf_parse_array(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) case PDF_TOK_R: if (n != 2) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot parse indirect reference in array"); - obj = pdf_new_indirect(doc, a, b); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_indirect(ctx, doc, a, b); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; n = 0; break; case PDF_TOK_OPEN_ARRAY: - obj = pdf_parse_array(doc, file, buf); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_parse_array(ctx, doc, file, buf); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_OPEN_DICT: - obj = pdf_parse_dict(doc, file, buf); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_parse_dict(ctx, doc, file, buf); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_NAME: - obj = pdf_new_name(doc, buf->scratch); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_name(ctx, doc, buf->scratch); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_REAL: - obj = pdf_new_real(doc, buf->f); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_real(ctx, doc, buf->f); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_STRING: - obj = pdf_new_string(doc, buf->scratch, buf->len); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_string(ctx, doc, buf->scratch, buf->len); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_TRUE: - obj = pdf_new_bool(doc, 1); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_bool(ctx, doc, 1); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_FALSE: - obj = pdf_new_bool(doc, 0); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_bool(ctx, doc, 0); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; case PDF_TOK_NULL: - obj = pdf_new_null(doc); - pdf_array_push(ary, obj); - pdf_drop_obj(obj); + obj = pdf_new_null(ctx, doc); + pdf_array_push(ctx, ary, obj); + pdf_drop_obj(ctx, obj); obj = NULL; break; @@ -360,24 +356,23 @@ end: } fz_catch(ctx) { - pdf_drop_obj(obj); - pdf_drop_obj(ary); + pdf_drop_obj(ctx, obj); + pdf_drop_obj(ctx, ary); fz_rethrow_message(ctx, "cannot parse array"); } return op; } pdf_obj * -pdf_parse_dict(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) +pdf_parse_dict(fz_context *ctx, pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) { pdf_obj *dict; pdf_obj *key = NULL; pdf_obj *val = NULL; pdf_token tok; int a, b; - fz_context *ctx = file->ctx; - dict = pdf_new_dict(doc, 8); + dict = pdf_new_dict(ctx, doc, 8); fz_var(key); fz_var(val); @@ -386,7 +381,7 @@ pdf_parse_dict(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) { while (1) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); skip: if (tok == PDF_TOK_CLOSE_DICT) break; @@ -398,49 +393,49 @@ pdf_parse_dict(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) if (tok != PDF_TOK_NAME) fz_throw(ctx, FZ_ERROR_GENERIC, "invalid key in dict"); - key = pdf_new_name(doc, buf->scratch); + key = pdf_new_name(ctx, doc, buf->scratch); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); switch (tok) { case PDF_TOK_OPEN_ARRAY: - val = pdf_parse_array(doc, file, buf); + val = pdf_parse_array(ctx, doc, file, buf); break; case PDF_TOK_OPEN_DICT: - val = pdf_parse_dict(doc, file, buf); + val = pdf_parse_dict(ctx, doc, file, buf); break; - case PDF_TOK_NAME: val = pdf_new_name(doc, buf->scratch); break; - case PDF_TOK_REAL: val = pdf_new_real(doc, buf->f); break; - case PDF_TOK_STRING: val = pdf_new_string(doc, buf->scratch, buf->len); break; - case PDF_TOK_TRUE: val = pdf_new_bool(doc, 1); break; - case PDF_TOK_FALSE: val = pdf_new_bool(doc, 0); break; - case PDF_TOK_NULL: val = pdf_new_null(doc); break; + case PDF_TOK_NAME: val = pdf_new_name(ctx, doc, buf->scratch); break; + case PDF_TOK_REAL: val = pdf_new_real(ctx, doc, buf->f); break; + case PDF_TOK_STRING: val = pdf_new_string(ctx, doc, buf->scratch, buf->len); break; + case PDF_TOK_TRUE: val = pdf_new_bool(ctx, doc, 1); break; + case PDF_TOK_FALSE: val = pdf_new_bool(ctx, doc, 0); break; + case PDF_TOK_NULL: val = pdf_new_null(ctx, doc); break; case PDF_TOK_INT: /* 64-bit to allow for numbers > INT_MAX and overflow */ a = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_CLOSE_DICT || tok == PDF_TOK_NAME || (tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "ID"))) { - val = pdf_new_int(doc, a); - pdf_dict_put(dict, key, val); - pdf_drop_obj(val); + val = pdf_new_int(ctx, doc, a); + pdf_dict_put(ctx, dict, key, val); + pdf_drop_obj(ctx, val); val = NULL; - pdf_drop_obj(key); + pdf_drop_obj(ctx, key); key = NULL; goto skip; } if (tok == PDF_TOK_INT) { b = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_R) { - val = pdf_new_indirect(doc, a, b); + val = pdf_new_indirect(ctx, doc, a, b); break; } } @@ -450,50 +445,49 @@ pdf_parse_dict(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) fz_throw(ctx, FZ_ERROR_GENERIC, "unknown token in dict"); } - pdf_dict_put(dict, key, val); - pdf_drop_obj(val); + pdf_dict_put(ctx, dict, key, val); + pdf_drop_obj(ctx, val); val = NULL; - pdf_drop_obj(key); + pdf_drop_obj(ctx, key); key = NULL; } } fz_catch(ctx) { - pdf_drop_obj(dict); - pdf_drop_obj(key); - pdf_drop_obj(val); + pdf_drop_obj(ctx, dict); + pdf_drop_obj(ctx, key); + pdf_drop_obj(ctx, val); fz_rethrow_message(ctx, "cannot parse dict"); } return dict; } pdf_obj * -pdf_parse_stm_obj(pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) +pdf_parse_stm_obj(fz_context *ctx, pdf_document *doc, fz_stream *file, pdf_lexbuf *buf) { pdf_token tok; - fz_context *ctx = file->ctx; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); switch (tok) { case PDF_TOK_OPEN_ARRAY: - return pdf_parse_array(doc, file, buf); + return pdf_parse_array(ctx, doc, file, buf); case PDF_TOK_OPEN_DICT: - return pdf_parse_dict(doc, file, buf); - case PDF_TOK_NAME: return pdf_new_name(doc, buf->scratch); break; - case PDF_TOK_REAL: return pdf_new_real(doc, buf->f); break; - case PDF_TOK_STRING: return pdf_new_string(doc, buf->scratch, buf->len); break; - case PDF_TOK_TRUE: return pdf_new_bool(doc, 1); break; - case PDF_TOK_FALSE: return pdf_new_bool(doc, 0); break; - case PDF_TOK_NULL: return pdf_new_null(doc); break; - case PDF_TOK_INT: return pdf_new_int(doc, buf->i); break; + return pdf_parse_dict(ctx, doc, file, buf); + case PDF_TOK_NAME: return pdf_new_name(ctx, doc, buf->scratch); break; + case PDF_TOK_REAL: return pdf_new_real(ctx, doc, buf->f); break; + case PDF_TOK_STRING: return pdf_new_string(ctx, doc, buf->scratch, buf->len); break; + case PDF_TOK_TRUE: return pdf_new_bool(ctx, doc, 1); break; + case PDF_TOK_FALSE: return pdf_new_bool(ctx, doc, 0); break; + case PDF_TOK_NULL: return pdf_new_null(ctx, doc); break; + case PDF_TOK_INT: return pdf_new_int(ctx, doc, buf->i); break; default: fz_throw(ctx, FZ_ERROR_GENERIC, "unknown token in object stream"); } } pdf_obj * -pdf_parse_ind_obj(pdf_document *doc, +pdf_parse_ind_obj(fz_context *ctx, pdf_document *doc, fz_stream *file, pdf_lexbuf *buf, int *onum, int *ogen, int *ostmofs, int *try_repair) { @@ -501,11 +495,10 @@ pdf_parse_ind_obj(pdf_document *doc, int num = 0, gen = 0, stm_ofs; pdf_token tok; int a, b; - fz_context *ctx = file->ctx; fz_var(obj); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_INT) { if (try_repair) @@ -514,7 +507,7 @@ pdf_parse_ind_obj(pdf_document *doc, } num = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_INT) { if (try_repair) @@ -523,7 +516,7 @@ pdf_parse_ind_obj(pdf_document *doc, } gen = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_OBJ) { if (try_repair) @@ -531,48 +524,48 @@ pdf_parse_ind_obj(pdf_document *doc, fz_throw(ctx, FZ_ERROR_GENERIC, "expected 'obj' keyword (%d %d ?)", num, gen); } - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); switch (tok) { case PDF_TOK_OPEN_ARRAY: - obj = pdf_parse_array(doc, file, buf); + obj = pdf_parse_array(ctx, doc, file, buf); break; case PDF_TOK_OPEN_DICT: - obj = pdf_parse_dict(doc, file, buf); + obj = pdf_parse_dict(ctx, doc, file, buf); break; - case PDF_TOK_NAME: obj = pdf_new_name(doc, buf->scratch); break; - case PDF_TOK_REAL: obj = pdf_new_real(doc, buf->f); break; - case PDF_TOK_STRING: obj = pdf_new_string(doc, buf->scratch, buf->len); break; - case PDF_TOK_TRUE: obj = pdf_new_bool(doc, 1); break; - case PDF_TOK_FALSE: obj = pdf_new_bool(doc, 0); break; - case PDF_TOK_NULL: obj = pdf_new_null(doc); break; + case PDF_TOK_NAME: obj = pdf_new_name(ctx, doc, buf->scratch); break; + case PDF_TOK_REAL: obj = pdf_new_real(ctx, doc, buf->f); break; + case PDF_TOK_STRING: obj = pdf_new_string(ctx, doc, buf->scratch, buf->len); break; + case PDF_TOK_TRUE: obj = pdf_new_bool(ctx, doc, 1); break; + case PDF_TOK_FALSE: obj = pdf_new_bool(ctx, doc, 0); break; + case PDF_TOK_NULL: obj = pdf_new_null(ctx, doc); break; case PDF_TOK_INT: a = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_STREAM || tok == PDF_TOK_ENDOBJ) { - obj = pdf_new_int(doc, a); + obj = pdf_new_int(ctx, doc, a); goto skip; } if (tok == PDF_TOK_INT) { b = buf->i; - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_R) { - obj = pdf_new_indirect(doc, a, b); + obj = pdf_new_indirect(ctx, doc, a, b); break; } } fz_throw(ctx, FZ_ERROR_GENERIC, "expected 'R' keyword (%d %d R)", num, gen); case PDF_TOK_ENDOBJ: - obj = pdf_new_null(doc); + obj = pdf_new_null(ctx, doc); goto skip; default: @@ -581,29 +574,29 @@ pdf_parse_ind_obj(pdf_document *doc, fz_try(ctx) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); } fz_catch(ctx) { - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); fz_rethrow_message(ctx, "cannot parse indirect object (%d %d R)", num, gen); } skip: if (tok == PDF_TOK_STREAM) { - int c = fz_read_byte(file); + int c = fz_read_byte(ctx, file); while (c == ' ') - c = fz_read_byte(file); + c = fz_read_byte(ctx, file); if (c == '\r') { - c = fz_peek_byte(file); + c = fz_peek_byte(ctx, file); if (c != '\n') fz_warn(ctx, "line feed missing after stream begin marker (%d %d R)", num, gen); else - fz_read_byte(file); + fz_read_byte(ctx, file); } - stm_ofs = fz_tell(file); + stm_ofs = fz_tell(ctx, file); } else if (tok == PDF_TOK_ENDOBJ) { diff --git a/source/pdf/pdf-pattern.c b/source/pdf/pdf-pattern.c index 785acfe5..93fbdd3e 100644 --- a/source/pdf/pdf-pattern.c +++ b/source/pdf/pdf-pattern.c @@ -18,9 +18,9 @@ pdf_drop_pattern_imp(fz_context *ctx, fz_storable *pat_) pdf_pattern *pat = (pdf_pattern *)pat_; if (pat->resources) - pdf_drop_obj(pat->resources); + pdf_drop_obj(ctx, pat->resources); if (pat->contents) - pdf_drop_obj(pat->contents); + pdf_drop_obj(ctx, pat->contents); fz_free(ctx, pat); } @@ -33,11 +33,10 @@ pdf_pattern_size(pdf_pattern *pat) } pdf_pattern * -pdf_load_pattern(pdf_document *doc, pdf_obj *dict) +pdf_load_pattern(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { pdf_pattern *pat; pdf_obj *obj; - fz_context *ctx = doc->ctx; if ((pat = pdf_find_item(ctx, pdf_drop_pattern_imp, dict)) != NULL) { @@ -52,32 +51,32 @@ pdf_load_pattern(pdf_document *doc, pdf_obj *dict) /* Store pattern now, to avoid possible recursion if objects refer back to this one */ pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat)); - pat->ismask = pdf_to_int(pdf_dict_gets(dict, "PaintType")) == 2; - pat->xstep = pdf_to_real(pdf_dict_gets(dict, "XStep")); - pat->ystep = pdf_to_real(pdf_dict_gets(dict, "YStep")); + pat->ismask = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "PaintType")) == 2; + pat->xstep = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "XStep")); + pat->ystep = pdf_to_real(ctx, pdf_dict_gets(ctx, dict, "YStep")); - obj = pdf_dict_gets(dict, "BBox"); + obj = pdf_dict_gets(ctx, dict, "BBox"); pdf_to_rect(ctx, obj, &pat->bbox); - obj = pdf_dict_gets(dict, "Matrix"); + obj = pdf_dict_gets(ctx, dict, "Matrix"); if (obj) pdf_to_matrix(ctx, obj, &pat->matrix); else pat->matrix = fz_identity; - pat->resources = pdf_dict_gets(dict, "Resources"); + pat->resources = pdf_dict_gets(ctx, dict, "Resources"); if (pat->resources) - pdf_keep_obj(pat->resources); + pdf_keep_obj(ctx, pat->resources); fz_try(ctx) { - pat->contents = pdf_keep_obj(dict); + pat->contents = pdf_keep_obj(ctx, dict); } fz_catch(ctx) { pdf_remove_item(ctx, pdf_drop_pattern_imp, dict); pdf_drop_pattern(ctx, pat); - fz_rethrow_message(ctx, "cannot load pattern stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load pattern stream (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } return pat; } diff --git a/source/pdf/pdf-pkcs7.c b/source/pdf/pdf-pkcs7.c index 7af97a6d..c1a97599 100644 --- a/source/pdf/pdf-pkcs7.c +++ b/source/pdf/pdf-pkcs7.c @@ -345,22 +345,20 @@ exit: typedef struct pdf_designated_name_openssl_s { pdf_designated_name base; - fz_context *ctx; char buf[8192]; } pdf_designated_name_openssl; struct pdf_signer_s { - fz_context *ctx; int refs; X509 *x509; EVP_PKEY *pkey; }; -void pdf_drop_designated_name(pdf_designated_name *dn) +void pdf_drop_designated_name(fz_context *ctx, pdf_designated_name *dn) { if (dn) - fz_free(((pdf_designated_name_openssl *)dn)->ctx, dn); + fz_free(ctx, dn); } @@ -436,7 +434,6 @@ pdf_signer *pdf_read_pfx(fz_context *ctx, const char *pfile, const char *pw) fz_try(ctx) { signer = fz_malloc_struct(ctx, pdf_signer); - signer->ctx = ctx; signer->refs = 1; OpenSSL_add_all_algorithms(); @@ -502,22 +499,21 @@ pdf_signer *pdf_read_pfx(fz_context *ctx, const char *pfile, const char *pw) } fz_catch(ctx) { - pdf_drop_signer(signer); + pdf_drop_signer(ctx, signer); fz_rethrow(ctx); } return signer; } -pdf_signer *pdf_keep_signer(pdf_signer *signer) +pdf_signer *pdf_keep_signer(fz_context *ctx, pdf_signer *signer) { if (signer) signer->refs++; - return signer; } -void pdf_drop_signer(pdf_signer *signer) +void pdf_drop_signer(fz_context *ctx, pdf_signer *signer) { if (signer) { @@ -525,18 +521,16 @@ void pdf_drop_signer(pdf_signer *signer) { X509_free(signer->x509); EVP_PKEY_free(signer->pkey); - fz_free(signer->ctx, signer); + fz_free(ctx, signer); } } } -pdf_designated_name *pdf_signer_designated_name(pdf_signer *signer) +pdf_designated_name *pdf_signer_designated_name(fz_context *ctx, pdf_signer *signer) { - fz_context *ctx = signer->ctx; pdf_designated_name_openssl *dn = fz_malloc_struct(ctx, pdf_designated_name_openssl); char *p; - dn->ctx = ctx; X509_NAME_oneline(X509_get_subject_name(signer->x509), dn->buf, sizeof(dn->buf)); p = strstr(dn->buf, "/CN="); if (p) dn->base.cn = p+4; @@ -556,9 +550,8 @@ pdf_designated_name *pdf_signer_designated_name(pdf_signer *signer) return (pdf_designated_name *)dn; } -void pdf_write_digest(pdf_document *doc, char *filename, pdf_obj *byte_range, int digest_offset, int digest_length, pdf_signer *signer) +void pdf_write_digest(fz_context *ctx, pdf_document *doc, char *filename, pdf_obj *byte_range, int digest_offset, int digest_length, pdf_signer *signer) { - fz_context *ctx = doc->ctx; BIO *bdata = NULL; BIO *bsegs = NULL; BIO *bp7in = NULL; @@ -568,7 +561,7 @@ void pdf_write_digest(pdf_document *doc, char *filename, pdf_obj *byte_range, in FILE *f = NULL; int (*brange)[2] = NULL; - int brange_len = pdf_array_len(byte_range)/2; + int brange_len = pdf_array_len(ctx, byte_range)/2; fz_var(bdata); fz_var(bsegs); @@ -586,8 +579,8 @@ void pdf_write_digest(pdf_document *doc, char *filename, pdf_obj *byte_range, in brange = fz_calloc(ctx, brange_len, sizeof(*brange)); for (i = 0; i < brange_len; i++) { - brange[i][0] = pdf_to_int(pdf_array_get(byte_range, 2*i)); - brange[i][1] = pdf_to_int(pdf_array_get(byte_range, 2*i+1)); + brange[i][0] = pdf_to_int(ctx, pdf_array_get(ctx, byte_range, 2*i)); + brange[i][1] = pdf_to_int(ctx, pdf_array_get(ctx, byte_range, 2*i+1)); } bdata = BIO_new(BIO_s_file()); @@ -671,9 +664,8 @@ void pdf_write_digest(pdf_document *doc, char *filename, pdf_obj *byte_range, in } } -int pdf_check_signature(pdf_document *doc, pdf_widget *widget, char *file, char *ebuf, int ebufsize) +int pdf_check_signature(fz_context *ctx, pdf_document *doc, pdf_widget *widget, char *file, char *ebuf, int ebufsize) { - fz_context *ctx = doc->ctx; int (*byte_range)[2] = NULL; int byte_range_len; char *contents = NULL; @@ -696,14 +688,14 @@ int pdf_check_signature(pdf_document *doc, pdf_widget *widget, char *file, char fz_var(res); fz_try(ctx); { - byte_range_len = pdf_signature_widget_byte_range(doc, widget, NULL); + byte_range_len = pdf_signature_widget_byte_range(ctx, doc, widget, NULL); if (byte_range_len) { byte_range = fz_calloc(ctx, byte_range_len, sizeof(*byte_range)); - pdf_signature_widget_byte_range(doc, widget, byte_range); + pdf_signature_widget_byte_range(ctx, doc, widget, byte_range); } - contents_len = pdf_signature_widget_contents(doc, widget, &contents); + contents_len = pdf_signature_widget_contents(ctx, doc, widget, &contents); if (byte_range && contents) { res = verify_sig(contents, contents_len, file, byte_range, byte_range_len, ebuf, ebufsize); @@ -731,9 +723,8 @@ int pdf_check_signature(pdf_document *doc, pdf_widget *widget, char *file, char return res; } -void pdf_sign_signature(pdf_document *doc, pdf_widget *widget, const char *sigfile, const char *password) +void pdf_sign_signature(fz_context *ctx, pdf_document *doc, pdf_widget *widget, const char *sigfile, const char *password) { - fz_context *ctx = doc->ctx; pdf_signer *signer = pdf_read_pfx(ctx, sigfile, password); pdf_designated_name *dn = NULL; fz_buffer *fzbuf = NULL; @@ -744,13 +735,13 @@ void pdf_sign_signature(pdf_document *doc, pdf_widget *widget, const char *sigfi pdf_obj *wobj = ((pdf_annot *)widget)->obj; fz_rect rect = fz_empty_rect; - pdf_signature_set_value(doc, wobj, signer); + pdf_signature_set_value(ctx, doc, wobj, signer); - pdf_to_rect(ctx, pdf_dict_gets(wobj, "Rect"), &rect); + pdf_to_rect(ctx, pdf_dict_gets(ctx, wobj, "Rect"), &rect); /* Create an appearance stream only if the signature is intended to be visible */ if (!fz_is_empty_rect(&rect)) { - dn = pdf_signer_designated_name(signer); + dn = pdf_signer_designated_name(ctx, signer); fzbuf = fz_new_buffer(ctx, 256); if (!dn->cn) fz_throw(ctx, FZ_ERROR_GENERIC, "Certificate has no common name"); @@ -770,13 +761,13 @@ void pdf_sign_signature(pdf_document *doc, pdf_widget *widget, const char *sigfi fz_buffer_printf(ctx, fzbuf, ", c=%s", dn->c); (void)fz_buffer_storage(ctx, fzbuf, (unsigned char **) &dn_str); - pdf_set_signature_appearance(doc, (pdf_annot *)widget, dn->cn, dn_str, NULL); + pdf_set_signature_appearance(ctx, doc, (pdf_annot *)widget, dn->cn, dn_str, NULL); } } fz_always(ctx) { - pdf_drop_signer(signer); - pdf_drop_designated_name(dn); + pdf_drop_signer(ctx, signer); + pdf_drop_designated_name(ctx, dn); fz_drop_buffer(ctx, fzbuf); } fz_catch(ctx) @@ -785,37 +776,37 @@ void pdf_sign_signature(pdf_document *doc, pdf_widget *widget, const char *sigfi } } -int pdf_signatures_supported(void) +int pdf_signatures_supported(fz_context *ctx) { return 1; } #else /* HAVE_OPENSSL */ -int pdf_check_signature(pdf_document *doc, pdf_widget *widget, char *file, char *ebuf, int ebufsize) +int pdf_check_signature(fz_context *ctx, pdf_document *doc, pdf_widget *widget, char *file, char *ebuf, int ebufsize) { fz_strlcpy(ebuf, "This version of MuPDF was built without signature support", ebufsize); return 0; } -void pdf_sign_signature(pdf_document *doc, pdf_widget *widget, const char *sigfile, const char *password) +void pdf_sign_signature(fz_context *ctx, pdf_document *doc, pdf_widget *widget, const char *sigfile, const char *password) { } -pdf_signer *pdf_keep_signer(pdf_signer *signer) +pdf_signer *pdf_keep_signer(fz_context *ctx, pdf_signer *signer) { return NULL; } -void pdf_drop_signer(pdf_signer *signer) +void pdf_drop_signer(fz_context *ctx, pdf_signer *signer) { } -void pdf_write_digest(pdf_document *doc, char *filename, pdf_obj *byte_range, int digest_offset, int digest_length, pdf_signer *signer) +void pdf_write_digest(fz_context *ctx, pdf_document *doc, char *filename, pdf_obj *byte_range, int digest_offset, int digest_length, pdf_signer *signer) { } -int pdf_signatures_supported(void) +int pdf_signatures_supported(fz_context *ctx) { return 0; } diff --git a/source/pdf/pdf-repair.c b/source/pdf/pdf-repair.c index 3cc05fc5..0c1c504c 100644 --- a/source/pdf/pdf-repair.c +++ b/source/pdf/pdf-repair.c @@ -15,12 +15,11 @@ struct entry }; int -pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, pdf_obj **encrypt, pdf_obj **id, pdf_obj **page, int *tmpofs) +pdf_repair_obj(fz_context *ctx, pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, pdf_obj **encrypt, pdf_obj **id, pdf_obj **page, int *tmpofs) { + fz_stream *file = doc->file; pdf_token tok; int stm_len; - fz_stream *file = doc->file; - fz_context *ctx = file->ctx; *stmofsp = 0; if (stmlenp) @@ -32,7 +31,7 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p * '<int> <int> obj'. We expect the next thing we see to be a * pdf object. Regardless of the type of thing we meet next * we only need to fully parse it if it is a dictionary. */ - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok == PDF_TOK_OPEN_DICT) { @@ -41,7 +40,7 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p /* Send NULL xref so we don't try to resolve references */ fz_try(ctx) { - dict = pdf_parse_dict(doc, file, buf); + dict = pdf_parse_dict(ctx, doc, file, buf); } fz_catch(ctx) { @@ -50,45 +49,45 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p if (file->eof) fz_rethrow_message(ctx, "broken object at EOF ignored"); /* Silently swallow the error */ - dict = pdf_new_dict(doc, 2); + dict = pdf_new_dict(ctx, doc, 2); } if (encrypt && id) { - obj = pdf_dict_gets(dict, "Type"); - if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "XRef")) + obj = pdf_dict_gets(ctx, dict, "Type"); + if (pdf_is_name(ctx, obj) && !strcmp(pdf_to_name(ctx, obj), "XRef")) { - obj = pdf_dict_gets(dict, "Encrypt"); + obj = pdf_dict_gets(ctx, dict, "Encrypt"); if (obj) { - pdf_drop_obj(*encrypt); - *encrypt = pdf_keep_obj(obj); + pdf_drop_obj(ctx, *encrypt); + *encrypt = pdf_keep_obj(ctx, obj); } - obj = pdf_dict_gets(dict, "ID"); + obj = pdf_dict_gets(ctx, dict, "ID"); if (obj) { - pdf_drop_obj(*id); - *id = pdf_keep_obj(obj); + pdf_drop_obj(ctx, *id); + *id = pdf_keep_obj(ctx, obj); } } } - obj = pdf_dict_gets(dict, "Length"); - if (!pdf_is_indirect(obj) && pdf_is_int(obj)) - stm_len = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "Length"); + if (!pdf_is_indirect(ctx, obj) && pdf_is_int(ctx, obj)) + stm_len = pdf_to_int(ctx, obj); if (doc->file_reading_linearly && page) { - obj = pdf_dict_gets(dict, "Type"); - if (!strcmp(pdf_to_name(obj), "Page")) + obj = pdf_dict_gets(ctx, dict, "Type"); + if (!strcmp(pdf_to_name(ctx, obj), "Page")) { - pdf_drop_obj(*page); - *page = pdf_keep_obj(dict); + pdf_drop_obj(ctx, *page); + *page = pdf_keep_obj(ctx, dict); } } - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); } while ( tok != PDF_TOK_STREAM && @@ -97,31 +96,31 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p tok != PDF_TOK_EOF && tok != PDF_TOK_INT ) { - *tmpofs = fz_tell(file); + *tmpofs = fz_tell(ctx, file); if (*tmpofs < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot tell in file"); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); } if (tok == PDF_TOK_STREAM) { - int c = fz_read_byte(file); + int c = fz_read_byte(ctx, file); if (c == '\r') { - c = fz_peek_byte(file); + c = fz_peek_byte(ctx, file); if (c == '\n') - fz_read_byte(file); + fz_read_byte(ctx, file); } - *stmofsp = fz_tell(file); + *stmofsp = fz_tell(ctx, file); if (*stmofsp < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot seek in file"); if (stm_len > 0) { - fz_seek(file, *stmofsp + stm_len, 0); + fz_seek(ctx, file, *stmofsp + stm_len, 0); fz_try(ctx) { - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); } fz_catch(ctx) { @@ -130,14 +129,14 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p } if (tok == PDF_TOK_ENDSTREAM) goto atobjend; - fz_seek(file, *stmofsp, 0); + fz_seek(ctx, file, *stmofsp, 0); } - (void)fz_read(file, (unsigned char *) buf->scratch, 9); + (void)fz_read(ctx, file, (unsigned char *) buf->scratch, 9); while (memcmp(buf->scratch, "endstream", 9) != 0) { - c = fz_read_byte(file); + c = fz_read_byte(ctx, file); if (c == EOF) break; memmove(&buf->scratch[0], &buf->scratch[1], 8); @@ -145,35 +144,34 @@ pdf_repair_obj(pdf_document *doc, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, p } if (stmlenp) - *stmlenp = fz_tell(file) - *stmofsp - 9; + *stmlenp = fz_tell(ctx, file) - *stmofsp - 9; atobjend: - *tmpofs = fz_tell(file); + *tmpofs = fz_tell(ctx, file); if (*tmpofs < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot tell in file"); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_ENDOBJ) fz_warn(ctx, "object missing 'endobj' token"); else { /* Read another token as we always return the next one */ - *tmpofs = fz_tell(file); + *tmpofs = fz_tell(ctx, file); if (*tmpofs < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot tell in file"); - tok = pdf_lex(file, buf); + tok = pdf_lex(ctx, file, buf); } } return tok; } static void -pdf_repair_obj_stm(pdf_document *doc, int num, int gen) +pdf_repair_obj_stm(fz_context *ctx, pdf_document *doc, int num, int gen) { pdf_obj *obj; fz_stream *stm = NULL; pdf_token tok; int i, n, count; - fz_context *ctx = doc->ctx; pdf_lexbuf buf; fz_var(stm); @@ -182,19 +180,19 @@ pdf_repair_obj_stm(pdf_document *doc, int num, int gen) fz_try(ctx) { - obj = pdf_load_object(doc, num, gen); + obj = pdf_load_object(ctx, doc, num, gen); - count = pdf_to_int(pdf_dict_gets(obj, "N")); + count = pdf_to_int(ctx, pdf_dict_gets(ctx, obj, "N")); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); - stm = pdf_open_stream(doc, num, gen); + stm = pdf_open_stream(ctx, doc, num, gen); for (i = 0; i < count; i++) { pdf_xref_entry *entry; - tok = pdf_lex(stm, &buf); + tok = pdf_lex(ctx, stm, &buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "corrupt object stream (%d %d R)", num, gen); @@ -204,29 +202,29 @@ pdf_repair_obj_stm(pdf_document *doc, int num, int gen) fz_warn(ctx, "ignoring object with invalid object number (%d %d R)", n, i); continue; } - else if (n >= pdf_xref_len(doc)) + else if (n >= pdf_xref_len(ctx, doc)) { fz_warn(ctx, "ignoring object with invalid object number (%d %d R)", n, i); continue; } - entry = pdf_get_populating_xref_entry(doc, n); + entry = pdf_get_populating_xref_entry(ctx, doc, n); entry->ofs = num; entry->gen = i; entry->stm_ofs = 0; - pdf_drop_obj(entry->obj); + pdf_drop_obj(ctx, entry->obj); entry->obj = NULL; entry->type = 'o'; - tok = pdf_lex(stm, &buf); + tok = pdf_lex(ctx, stm, &buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "corrupt object stream (%d %d R)", num, gen); } } fz_always(ctx) { - fz_drop_stream(stm); - pdf_lexbuf_fin(&buf); + fz_drop_stream(ctx, stm); + pdf_lexbuf_fin(ctx, &buf); } fz_catch(ctx) { @@ -235,7 +233,7 @@ pdf_repair_obj_stm(pdf_document *doc, int num, int gen) } void -pdf_repair_xref(pdf_document *doc) +pdf_repair_xref(fz_context *ctx, pdf_document *doc) { pdf_obj *dict, *obj = NULL; pdf_obj *length; @@ -257,7 +255,6 @@ pdf_repair_xref(pdf_document *doc) pdf_token tok; int next; int i, n, c; - fz_context *ctx = doc->ctx; pdf_lexbuf *buf = &doc->lexbuf.base; fz_var(encrypt); @@ -268,14 +265,14 @@ pdf_repair_xref(pdf_document *doc) fz_var(obj); if (doc->repair_attempted) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "Repair failed already - not trying again"); + fz_throw(ctx, FZ_ERROR_GENERIC, "Repair failed already - not trying again"); doc->repair_attempted = 1; doc->dirty = 1; /* Can't support incremental update after repair */ doc->freeze_updates = 1; - fz_seek(doc->file, 0, 0); + fz_seek(ctx, doc->file, 0, 0); fz_try(ctx) { @@ -285,34 +282,34 @@ pdf_repair_xref(pdf_document *doc) list = fz_malloc_array(ctx, listcap, sizeof(struct entry)); /* look for '%PDF' version marker within first kilobyte of file */ - n = fz_read(doc->file, (unsigned char *)buf->scratch, fz_mini(buf->size, 1024)); + n = fz_read(ctx, doc->file, (unsigned char *)buf->scratch, fz_mini(buf->size, 1024)); - fz_seek(doc->file, 0, 0); + fz_seek(ctx, doc->file, 0, 0); for (i = 0; i < n - 4; i++) { if (memcmp(&buf->scratch[i], "%PDF", 4) == 0) { - fz_seek(doc->file, i + 8, 0); /* skip "%PDF-X.Y" */ + fz_seek(ctx, doc->file, i + 8, 0); /* skip "%PDF-X.Y" */ break; } } /* skip comment line after version marker since some generators * forget to terminate the comment with a newline */ - c = fz_read_byte(doc->file); + c = fz_read_byte(ctx, doc->file); while (c >= 0 && (c == ' ' || c == '%')) - c = fz_read_byte(doc->file); - fz_unread_byte(doc->file); + c = fz_read_byte(ctx, doc->file); + fz_unread_byte(ctx, doc->file); while (1) { - tmpofs = fz_tell(doc->file); + tmpofs = fz_tell(ctx, doc->file); if (tmpofs < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot tell in file"); fz_try(ctx) { - tok = pdf_lex_no_string(doc->file, buf); + tok = pdf_lex_no_string(ctx, doc->file, buf); } fz_catch(ctx) { @@ -346,7 +343,7 @@ pdf_repair_xref(pdf_document *doc) { stm_len = 0; stm_ofs = 0; - tok = pdf_repair_obj(doc, buf, &stm_ofs, &stm_len, &encrypt, &id, NULL, &tmpofs); + tok = pdf_repair_obj(ctx, doc, buf, &stm_ofs, &stm_len, &encrypt, &id, NULL, &tmpofs); } fz_catch(ctx) { @@ -394,7 +391,7 @@ pdf_repair_xref(pdf_document *doc) { fz_try(ctx) { - dict = pdf_parse_dict(doc, doc->file, buf); + dict = pdf_parse_dict(ctx, doc, doc->file, buf); } fz_catch(ctx) { @@ -406,35 +403,35 @@ pdf_repair_xref(pdf_document *doc) continue; } - obj = pdf_dict_gets(dict, "Encrypt"); + obj = pdf_dict_gets(ctx, dict, "Encrypt"); if (obj) { - pdf_drop_obj(encrypt); - encrypt = pdf_keep_obj(obj); + pdf_drop_obj(ctx, encrypt); + encrypt = pdf_keep_obj(ctx, obj); } - obj = pdf_dict_gets(dict, "ID"); - if (obj && (!id || !encrypt || pdf_dict_gets(dict, "Encrypt"))) + obj = pdf_dict_gets(ctx, dict, "ID"); + if (obj && (!id || !encrypt || pdf_dict_gets(ctx, dict, "Encrypt"))) { - pdf_drop_obj(id); - id = pdf_keep_obj(obj); + pdf_drop_obj(ctx, id); + id = pdf_keep_obj(ctx, obj); } - obj = pdf_dict_gets(dict, "Root"); + obj = pdf_dict_gets(ctx, dict, "Root"); if (obj) { - pdf_drop_obj(root); - root = pdf_keep_obj(obj); + pdf_drop_obj(ctx, root); + root = pdf_keep_obj(ctx, obj); } - obj = pdf_dict_gets(dict, "Info"); + obj = pdf_dict_gets(ctx, dict, "Info"); if (obj) { - pdf_drop_obj(info); - info = pdf_keep_obj(obj); + pdf_drop_obj(ctx, info); + info = pdf_keep_obj(ctx, obj); } - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); obj = NULL; } @@ -443,7 +440,7 @@ pdf_repair_xref(pdf_document *doc) else { if (tok == PDF_TOK_ERROR) - fz_read_byte(doc->file); + fz_read_byte(ctx, doc->file); num = 0; gen = 0; } @@ -458,11 +455,11 @@ pdf_repair_xref(pdf_document *doc) */ /* Ensure that the first xref table is a 'solid' one from * 0 to maxnum. */ - pdf_ensure_solid_xref(doc, maxnum); + pdf_ensure_solid_xref(ctx, doc, maxnum); for (i = 0; i < listlen; i++) { - entry = pdf_get_populating_xref_entry(doc, list[i].num); + entry = pdf_get_populating_xref_entry(ctx, doc, list[i].num); entry->type = 'n'; entry->ofs = list[i].ofs; entry->gen = list[i].gen; @@ -472,26 +469,26 @@ pdf_repair_xref(pdf_document *doc) /* correct stream length for unencrypted documents */ if (!encrypt && list[i].stm_len >= 0) { - dict = pdf_load_object(doc, list[i].num, list[i].gen); + dict = pdf_load_object(ctx, doc, list[i].num, list[i].gen); - length = pdf_new_int(doc, list[i].stm_len); - pdf_dict_puts(dict, "Length", length); - pdf_drop_obj(length); + length = pdf_new_int(ctx, doc, list[i].stm_len); + pdf_dict_puts(ctx, dict, "Length", length); + pdf_drop_obj(ctx, length); - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); } } - entry = pdf_get_populating_xref_entry(doc, 0); + entry = pdf_get_populating_xref_entry(ctx, doc, 0); entry->type = 'f'; entry->ofs = 0; entry->gen = 65535; entry->stm_ofs = 0; next = 0; - for (i = pdf_xref_len(doc) - 1; i >= 0; i--) + for (i = pdf_xref_len(ctx, doc) - 1; i >= 0; i--) { - entry = pdf_get_populating_xref_entry(doc, i); + entry = pdf_get_populating_xref_entry(ctx, doc, i); if (entry->type == 'f') { entry->ofs = next; @@ -503,57 +500,57 @@ pdf_repair_xref(pdf_document *doc) /* create a repaired trailer, Root will be added later */ - obj = pdf_new_dict(doc, 5); + obj = pdf_new_dict(ctx, doc, 5); /* During repair there is only a single xref section */ - pdf_set_populating_xref_trailer(doc, obj); - pdf_drop_obj(obj); + pdf_set_populating_xref_trailer(ctx, doc, obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_int(doc, maxnum + 1); - pdf_dict_puts(pdf_trailer(doc), "Size", obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, maxnum + 1); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Size", obj); + pdf_drop_obj(ctx, obj); obj = NULL; if (root) { - pdf_dict_puts(pdf_trailer(doc), "Root", root); - pdf_drop_obj(root); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Root", root); + pdf_drop_obj(ctx, root); root = NULL; } if (info) { - pdf_dict_puts(pdf_trailer(doc), "Info", info); - pdf_drop_obj(info); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Info", info); + pdf_drop_obj(ctx, info); info = NULL; } if (encrypt) { - if (pdf_is_indirect(encrypt)) + if (pdf_is_indirect(ctx, encrypt)) { /* create new reference with non-NULL xref pointer */ - obj = pdf_new_indirect(doc, pdf_to_num(encrypt), pdf_to_gen(encrypt)); - pdf_drop_obj(encrypt); + obj = pdf_new_indirect(ctx, doc, pdf_to_num(ctx, encrypt), pdf_to_gen(ctx, encrypt)); + pdf_drop_obj(ctx, encrypt); encrypt = obj; obj = NULL; } - pdf_dict_puts(pdf_trailer(doc), "Encrypt", encrypt); - pdf_drop_obj(encrypt); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Encrypt", encrypt); + pdf_drop_obj(ctx, encrypt); encrypt = NULL; } if (id) { - if (pdf_is_indirect(id)) + if (pdf_is_indirect(ctx, id)) { /* create new reference with non-NULL xref pointer */ - obj = pdf_new_indirect(doc, pdf_to_num(id), pdf_to_gen(id)); - pdf_drop_obj(id); + obj = pdf_new_indirect(ctx, doc, pdf_to_num(ctx, id), pdf_to_gen(ctx, id)); + pdf_drop_obj(ctx, id); id = obj; obj = NULL; } - pdf_dict_puts(pdf_trailer(doc), "ID", id); - pdf_drop_obj(id); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "ID", id); + pdf_drop_obj(ctx, id); id = NULL; } @@ -561,50 +558,49 @@ pdf_repair_xref(pdf_document *doc) } fz_catch(ctx) { - pdf_drop_obj(encrypt); - pdf_drop_obj(id); - pdf_drop_obj(root); - pdf_drop_obj(obj); - pdf_drop_obj(info); + pdf_drop_obj(ctx, encrypt); + pdf_drop_obj(ctx, id); + pdf_drop_obj(ctx, root); + pdf_drop_obj(ctx, obj); + pdf_drop_obj(ctx, info); fz_free(ctx, list); fz_rethrow(ctx); } } void -pdf_repair_obj_stms(pdf_document *doc) +pdf_repair_obj_stms(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; pdf_obj *dict; int i; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); for (i = 0; i < xref_len; i++) { - pdf_xref_entry *entry = pdf_get_populating_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_populating_xref_entry(ctx, doc, i); if (entry->stm_ofs) { - dict = pdf_load_object(doc, i, 0); + dict = pdf_load_object(ctx, doc, i, 0); fz_try(ctx) { - if (!strcmp(pdf_to_name(pdf_dict_gets(dict, "Type")), "ObjStm")) - pdf_repair_obj_stm(doc, i, 0); + if (!strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "Type")), "ObjStm")) + pdf_repair_obj_stm(ctx, doc, i, 0); } fz_catch(ctx) { fz_warn(ctx, "ignoring broken object stream (%d 0 R)", i); } - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); } } /* Ensure that streamed objects reside inside a known non-streamed object */ for (i = 0; i < xref_len; i++) { - pdf_xref_entry *entry = pdf_get_populating_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_populating_xref_entry(ctx, doc, i); - if (entry->type == 'o' && pdf_get_populating_xref_entry(doc, entry->ofs)->type != 'n') - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "invalid reference to non-object-stream: %d (%d 0 R)", entry->ofs, i); + if (entry->type == 'o' && pdf_get_populating_xref_entry(ctx, doc, entry->ofs)->type != 'n') + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid reference to non-object-stream: %d (%d 0 R)", entry->ofs, i); } } diff --git a/source/pdf/pdf-run.c b/source/pdf/pdf-run.c index d52d8282..e6f3d5b9 100644 --- a/source/pdf/pdf-run.c +++ b/source/pdf/pdf-run.c @@ -1,19 +1,19 @@ #include "pdf-interpret-imp.h" static void -pdf_run_annot_with_usage(pdf_document *doc, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) +pdf_run_annot_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) { fz_matrix local_ctm; pdf_process process; fz_concat(&local_ctm, &page->ctm, ctm); - pdf_process_run(&process, dev, &local_ctm, event, NULL, 0); + pdf_init_process_run(ctx, &process, dev, &local_ctm, event, NULL, 0); - pdf_process_annot(doc, page, annot, &process, cookie); + pdf_process_annot(ctx, doc, page, annot, &process, cookie); } -static void pdf_run_page_contents_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) +static void pdf_run_page_contents_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) { fz_matrix local_ctm; pdf_process process; @@ -23,67 +23,70 @@ static void pdf_run_page_contents_with_usage(pdf_document *doc, pdf_page *page, if (page->transparency) { fz_rect mediabox = page->mediabox; - fz_begin_group(dev, fz_transform_rect(&mediabox, &local_ctm), 1, 0, 0, 1); + fz_begin_group(ctx, dev, fz_transform_rect(&mediabox, &local_ctm), 1, 0, 0, 1); } - pdf_process_run(&process, dev, &local_ctm, event, NULL, 0); + pdf_init_process_run(ctx, &process, dev, &local_ctm, event, NULL, 0); - pdf_process_stream_object(doc, page->contents, &process, page->resources, cookie); + pdf_process_stream_object(ctx, doc, page->contents, &process, page->resources, cookie); if (page->transparency) - fz_end_group(dev); + fz_end_group(ctx, dev); } -void pdf_run_page_contents(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +void pdf_run_page_contents(fz_context *ctx, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; - int nocache = !!(dev->hints & FZ_NO_CACHE); + pdf_document *doc = page->doc; + int nocache; + nocache = !!(dev->hints & FZ_NO_CACHE); if (nocache) - pdf_mark_xref(doc); + pdf_mark_xref(ctx, doc); + fz_try(ctx) { - pdf_run_page_contents_with_usage(doc, page, dev, ctm, "View", cookie); + pdf_run_page_contents_with_usage(ctx, doc, page, dev, ctm, "View", cookie); } fz_always(ctx) { if (nocache) - pdf_clear_xref_to_mark(doc); + pdf_clear_xref_to_mark(ctx, doc); } fz_catch(ctx) { fz_rethrow(ctx); } if (page->incomplete & PDF_PAGE_INCOMPLETE_CONTENTS) - fz_throw(doc->ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); } -void pdf_run_annot(pdf_document *doc, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +void pdf_run_annot(fz_context *ctx, pdf_page *page, pdf_annot *annot, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; - int nocache = !!(dev->hints & FZ_NO_CACHE); + pdf_document *doc = page->doc; + int nocache; + nocache = !!(dev->hints & FZ_NO_CACHE); if (nocache) - pdf_mark_xref(doc); + pdf_mark_xref(ctx, doc); fz_try(ctx) { - pdf_run_annot_with_usage(doc, page, annot, dev, ctm, "View", cookie); + pdf_run_annot_with_usage(ctx, doc, page, annot, dev, ctm, "View", cookie); } fz_always(ctx) { if (nocache) - pdf_clear_xref_to_mark(doc); + pdf_clear_xref_to_mark(ctx, doc); } fz_catch(ctx) { fz_rethrow(ctx); } if (page->incomplete & PDF_PAGE_INCOMPLETE_ANNOTS) - fz_throw(doc->ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); } -static void pdf_run_page_annots_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) +static void pdf_run_page_annots_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) { pdf_annot *annot; @@ -105,52 +108,51 @@ static void pdf_run_page_annots_with_usage(pdf_document *doc, pdf_page *page, fz cookie->progress++; } - pdf_run_annot_with_usage(doc, page, annot, dev, ctm, event, cookie); + pdf_run_annot_with_usage(ctx, doc, page, annot, dev, ctm, event, cookie); } } void -pdf_run_page_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) +pdf_run_page_with_usage(fz_context *ctx, pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, char *event, fz_cookie *cookie) { - fz_context *ctx = doc->ctx; int nocache = !!(dev->hints & FZ_NO_CACHE); if (nocache) - pdf_mark_xref(doc); + pdf_mark_xref(ctx, doc); fz_try(ctx) { - pdf_run_page_contents_with_usage(doc, page, dev, ctm, event, cookie); - pdf_run_page_annots_with_usage(doc, page, dev, ctm, event, cookie); + pdf_run_page_contents_with_usage(ctx, doc, page, dev, ctm, event, cookie); + pdf_run_page_annots_with_usage(ctx, doc, page, dev, ctm, event, cookie); } fz_always(ctx) { if (nocache) - pdf_clear_xref_to_mark(doc); + pdf_clear_xref_to_mark(ctx, doc); } fz_catch(ctx) { fz_rethrow(ctx); } if (page->incomplete) - fz_throw(doc->ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); + fz_throw(ctx, FZ_ERROR_TRYLATER, "incomplete rendering"); } void -pdf_run_page(pdf_document *doc, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +pdf_run_page(fz_context *ctx, pdf_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { - pdf_run_page_with_usage(doc, page, dev, ctm, "View", cookie); + pdf_document *doc = page->doc; + pdf_run_page_with_usage(ctx, doc, page, dev, ctm, "View", cookie); } void -pdf_run_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth) +pdf_run_glyph(fz_context *ctx, pdf_document *doc, pdf_obj *resources, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth) { - fz_context *ctx = doc->ctx; pdf_process process; if (nested_depth > 10) fz_throw(ctx, FZ_ERROR_GENERIC, "Too many nestings of Type3 glyphs"); - pdf_process_run(&process, dev, ctm, "View", gstate, nested_depth+1); + pdf_init_process_run(ctx, &process, dev, ctm, "View", gstate, nested_depth+1); - pdf_process_glyph(doc, resources, contents, &process); + pdf_process_glyph(ctx, doc, resources, contents, &process); } diff --git a/source/pdf/pdf-shade.c b/source/pdf/pdf-shade.c index c5009059..4203d1b0 100644 --- a/source/pdf/pdf-shade.c +++ b/source/pdf/pdf-shade.c @@ -47,28 +47,27 @@ pdf_sample_shade_function(fz_context *ctx, fz_shade *shade, int funcs, fz_functi /* Type 1-3 -- Function-based, linear and radial shadings */ static void -pdf_load_function_based_shading(fz_shade *shade, pdf_document *doc, pdf_obj *dict, fz_function *func) +pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, fz_function *func) { pdf_obj *obj; float x0, y0, x1, y1; float fv[2]; fz_matrix matrix; int xx, yy; - fz_context *ctx = doc->ctx; float *p; x0 = y0 = 0; x1 = y1 = 1; - obj = pdf_dict_gets(dict, "Domain"); + obj = pdf_dict_gets(ctx, dict, "Domain"); if (obj) { - x0 = pdf_to_real(pdf_array_get(obj, 0)); - x1 = pdf_to_real(pdf_array_get(obj, 1)); - y0 = pdf_to_real(pdf_array_get(obj, 2)); - y1 = pdf_to_real(pdf_array_get(obj, 3)); + x0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + x1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); + y0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2)); + y1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3)); } - obj = pdf_dict_gets(dict, "Matrix"); + obj = pdf_dict_gets(ctx, dict, "Matrix"); if (obj) pdf_to_matrix(ctx, obj, &matrix); else @@ -98,34 +97,33 @@ pdf_load_function_based_shading(fz_shade *shade, pdf_document *doc, pdf_obj *dic } static void -pdf_load_linear_shading(fz_shade *shade, pdf_document *doc, pdf_obj *dict, int funcs, fz_function **func) +pdf_load_linear_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { pdf_obj *obj; float d0, d1; int e0, e1; - fz_context *ctx = doc->ctx; - obj = pdf_dict_gets(dict, "Coords"); - shade->u.l_or_r.coords[0][0] = pdf_to_real(pdf_array_get(obj, 0)); - shade->u.l_or_r.coords[0][1] = pdf_to_real(pdf_array_get(obj, 1)); - shade->u.l_or_r.coords[1][0] = pdf_to_real(pdf_array_get(obj, 2)); - shade->u.l_or_r.coords[1][1] = pdf_to_real(pdf_array_get(obj, 3)); + obj = pdf_dict_gets(ctx, dict, "Coords"); + shade->u.l_or_r.coords[0][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + shade->u.l_or_r.coords[0][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); + shade->u.l_or_r.coords[1][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2)); + shade->u.l_or_r.coords[1][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3)); d0 = 0; d1 = 1; - obj = pdf_dict_gets(dict, "Domain"); + obj = pdf_dict_gets(ctx, dict, "Domain"); if (obj) { - d0 = pdf_to_real(pdf_array_get(obj, 0)); - d1 = pdf_to_real(pdf_array_get(obj, 1)); + d0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + d1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); } e0 = e1 = 0; - obj = pdf_dict_gets(dict, "Extend"); + obj = pdf_dict_gets(ctx, dict, "Extend"); if (obj) { - e0 = pdf_to_bool(pdf_array_get(obj, 0)); - e1 = pdf_to_bool(pdf_array_get(obj, 1)); + e0 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 0)); + e1 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 1)); } pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1); @@ -135,36 +133,35 @@ pdf_load_linear_shading(fz_shade *shade, pdf_document *doc, pdf_obj *dict, int f } static void -pdf_load_radial_shading(fz_shade *shade, pdf_document *doc, pdf_obj *dict, int funcs, fz_function **func) +pdf_load_radial_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { pdf_obj *obj; float d0, d1; int e0, e1; - fz_context *ctx = doc->ctx; - obj = pdf_dict_gets(dict, "Coords"); - shade->u.l_or_r.coords[0][0] = pdf_to_real(pdf_array_get(obj, 0)); - shade->u.l_or_r.coords[0][1] = pdf_to_real(pdf_array_get(obj, 1)); - shade->u.l_or_r.coords[0][2] = pdf_to_real(pdf_array_get(obj, 2)); - shade->u.l_or_r.coords[1][0] = pdf_to_real(pdf_array_get(obj, 3)); - shade->u.l_or_r.coords[1][1] = pdf_to_real(pdf_array_get(obj, 4)); - shade->u.l_or_r.coords[1][2] = pdf_to_real(pdf_array_get(obj, 5)); + obj = pdf_dict_gets(ctx, dict, "Coords"); + shade->u.l_or_r.coords[0][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + shade->u.l_or_r.coords[0][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); + shade->u.l_or_r.coords[0][2] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2)); + shade->u.l_or_r.coords[1][0] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3)); + shade->u.l_or_r.coords[1][1] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 4)); + shade->u.l_or_r.coords[1][2] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 5)); d0 = 0; d1 = 1; - obj = pdf_dict_gets(dict, "Domain"); + obj = pdf_dict_gets(ctx, dict, "Domain"); if (obj) { - d0 = pdf_to_real(pdf_array_get(obj, 0)); - d1 = pdf_to_real(pdf_array_get(obj, 1)); + d0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + d1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); } e0 = e1 = 0; - obj = pdf_dict_gets(dict, "Extend"); + obj = pdf_dict_gets(ctx, dict, "Extend"); if (obj) { - e0 = pdf_to_bool(pdf_array_get(obj, 0)); - e1 = pdf_to_bool(pdf_array_get(obj, 1)); + e0 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 0)); + e1 = pdf_to_bool(ctx, pdf_array_get(ctx, obj, 1)); } pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1); @@ -188,9 +185,8 @@ struct mesh_params }; static void -pdf_load_mesh_params(fz_shade *shade, pdf_document *doc, pdf_obj *dict) +pdf_load_mesh_params(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict) { - fz_context *ctx = doc->ctx; pdf_obj *obj; int i, n; @@ -202,23 +198,23 @@ pdf_load_mesh_params(fz_shade *shade, pdf_document *doc, pdf_obj *dict) shade->u.m.c1[i] = 1; } - shade->u.m.vprow = pdf_to_int(pdf_dict_gets(dict, "VerticesPerRow")); - shade->u.m.bpflag = pdf_to_int(pdf_dict_gets(dict, "BitsPerFlag")); - shade->u.m.bpcoord = pdf_to_int(pdf_dict_gets(dict, "BitsPerCoordinate")); - shade->u.m.bpcomp = pdf_to_int(pdf_dict_gets(dict, "BitsPerComponent")); + shade->u.m.vprow = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "VerticesPerRow")); + shade->u.m.bpflag = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "BitsPerFlag")); + shade->u.m.bpcoord = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "BitsPerCoordinate")); + shade->u.m.bpcomp = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "BitsPerComponent")); - obj = pdf_dict_gets(dict, "Decode"); - if (pdf_array_len(obj) >= 6) + obj = pdf_dict_gets(ctx, dict, "Decode"); + if (pdf_array_len(ctx, obj) >= 6) { - n = (pdf_array_len(obj) - 4) / 2; - shade->u.m.x0 = pdf_to_real(pdf_array_get(obj, 0)); - shade->u.m.x1 = pdf_to_real(pdf_array_get(obj, 1)); - shade->u.m.y0 = pdf_to_real(pdf_array_get(obj, 2)); - shade->u.m.y1 = pdf_to_real(pdf_array_get(obj, 3)); + n = (pdf_array_len(ctx, obj) - 4) / 2; + shade->u.m.x0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 0)); + shade->u.m.x1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 1)); + shade->u.m.y0 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 2)); + shade->u.m.y1 = pdf_to_real(ctx, pdf_array_get(ctx, obj, 3)); for (i = 0; i < n; i++) { - shade->u.m.c0[i] = pdf_to_real(pdf_array_get(obj, 4 + i * 2)); - shade->u.m.c1[i] = pdf_to_real(pdf_array_get(obj, 5 + i * 2)); + shade->u.m.c0[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 4 + i * 2)); + shade->u.m.c1[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, 5 + i * 2)); } } @@ -252,67 +248,59 @@ pdf_load_mesh_params(fz_shade *shade, pdf_document *doc, pdf_obj *dict) } static void -pdf_load_type4_shade(fz_shade *shade, pdf_document *doc, pdf_obj *dict, - int funcs, fz_function **func) +pdf_load_type4_shade(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { - fz_context *ctx = doc->ctx; - pdf_load_mesh_params(shade, doc, dict); + pdf_load_mesh_params(ctx, doc, shade, dict); if (funcs > 0) pdf_sample_shade_function(ctx, shade, funcs, func, shade->u.m.c0[0], shade->u.m.c1[0]); - shade->buffer = pdf_load_compressed_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + shade->buffer = pdf_load_compressed_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } static void -pdf_load_type5_shade(fz_shade *shade, pdf_document *doc, pdf_obj *dict, - int funcs, fz_function **func) +pdf_load_type5_shade(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { - fz_context *ctx = doc->ctx; - pdf_load_mesh_params(shade, doc, dict); + pdf_load_mesh_params(ctx, doc, shade, dict); if (funcs > 0) pdf_sample_shade_function(ctx, shade, funcs, func, shade->u.m.c0[0], shade->u.m.c1[0]); - shade->buffer = pdf_load_compressed_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + shade->buffer = pdf_load_compressed_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } /* Type 6 & 7 -- Patch mesh shadings */ static void -pdf_load_type6_shade(fz_shade *shade, pdf_document *doc, pdf_obj *dict, - int funcs, fz_function **func) +pdf_load_type6_shade(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { - fz_context *ctx = doc->ctx; - pdf_load_mesh_params(shade, doc, dict); + pdf_load_mesh_params(ctx, doc, shade, dict); if (funcs > 0) pdf_sample_shade_function(ctx, shade, funcs, func, shade->u.m.c0[0], shade->u.m.c1[0]); - shade->buffer = pdf_load_compressed_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + shade->buffer = pdf_load_compressed_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } static void -pdf_load_type7_shade(fz_shade *shade, pdf_document *doc, pdf_obj *dict, - int funcs, fz_function **func) +pdf_load_type7_shade(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, fz_function **func) { - fz_context *ctx = doc->ctx; - pdf_load_mesh_params(shade, doc, dict); + pdf_load_mesh_params(ctx, doc, shade, dict); if (funcs > 0) pdf_sample_shade_function(ctx, shade, funcs, func, shade->u.m.c0[0], shade->u.m.c1[0]); - shade->buffer = pdf_load_compressed_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + shade->buffer = pdf_load_compressed_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } /* Load all of the shading dictionary parameters, then switch on the shading type. */ static fz_shade * -pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transform) +pdf_load_shading_dict(fz_context *ctx, pdf_document *doc, pdf_obj *dict, const fz_matrix *transform) { fz_shade *shade = NULL; fz_function *func[FZ_MAX_COLORS] = { NULL }; @@ -320,7 +308,6 @@ pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transfo int funcs = 0; int type = 0; int i, in, out; - fz_context *ctx = doc->ctx; fz_var(shade); fz_var(func); @@ -341,28 +328,28 @@ pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transfo funcs = 0; - obj = pdf_dict_gets(dict, "ShadingType"); - type = pdf_to_int(obj); + obj = pdf_dict_gets(ctx, dict, "ShadingType"); + type = pdf_to_int(ctx, obj); - obj = pdf_dict_gets(dict, "ColorSpace"); + obj = pdf_dict_gets(ctx, dict, "ColorSpace"); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "shading colorspace is missing"); - shade->colorspace = pdf_load_colorspace(doc, obj); + shade->colorspace = pdf_load_colorspace(ctx, doc, obj); - obj = pdf_dict_gets(dict, "Background"); + obj = pdf_dict_gets(ctx, dict, "Background"); if (obj) { shade->use_background = 1; for (i = 0; i < shade->colorspace->n; i++) - shade->background[i] = pdf_to_real(pdf_array_get(obj, i)); + shade->background[i] = pdf_to_real(ctx, pdf_array_get(ctx, obj, i)); } - obj = pdf_dict_gets(dict, "BBox"); - if (pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, dict, "BBox"); + if (pdf_is_array(ctx, obj)) pdf_to_rect(ctx, obj, &shade->bbox); - obj = pdf_dict_gets(dict, "Function"); - if (pdf_is_dict(obj)) + obj = pdf_dict_gets(ctx, dict, "Function"); + if (pdf_is_dict(ctx, obj)) { funcs = 1; @@ -372,13 +359,13 @@ pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transfo in = 1; out = shade->colorspace->n; - func[0] = pdf_load_function(doc, obj, in, out); + func[0] = pdf_load_function(ctx, doc, obj, in, out); if (!func[0]) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { - funcs = pdf_array_len(obj); + funcs = pdf_array_len(ctx, obj); if (funcs != 1 && funcs != shade->colorspace->n) { funcs = 0; @@ -398,27 +385,27 @@ pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transfo for (i = 0; i < funcs; i++) { - func[i] = pdf_load_function(doc, pdf_array_get(obj, i), in, out); + func[i] = pdf_load_function(ctx, doc, pdf_array_get(ctx, obj, i), in, out); if (!func[i]) - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } } else if (type < 4) { /* Functions are compulsory for types 1,2,3 */ - fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj)); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot load shading function (%d %d R)", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); } shade->type = type; switch (type) { - case 1: pdf_load_function_based_shading(shade, doc, dict, func[0]); break; - case 2: pdf_load_linear_shading(shade, doc, dict, funcs, func); break; - case 3: pdf_load_radial_shading(shade, doc, dict, funcs, func); break; - case 4: pdf_load_type4_shade(shade, doc, dict, funcs, func); break; - case 5: pdf_load_type5_shade(shade, doc, dict, funcs, func); break; - case 6: pdf_load_type6_shade(shade, doc, dict, funcs, func); break; - case 7: pdf_load_type7_shade(shade, doc, dict, funcs, func); break; + case 1: pdf_load_function_based_shading(ctx, doc, shade, dict, func[0]); break; + case 2: pdf_load_linear_shading(ctx, doc, shade, dict, funcs, func); break; + case 3: pdf_load_radial_shading(ctx, doc, shade, dict, funcs, func); break; + case 4: pdf_load_type4_shade(ctx, doc, shade, dict, funcs, func); break; + case 5: pdf_load_type5_shade(ctx, doc, shade, dict, funcs, func); break; + case 6: pdf_load_type6_shade(ctx, doc, shade, dict, funcs, func); break; + case 7: pdf_load_type7_shade(ctx, doc, shade, dict, funcs, func); break; default: fz_throw(ctx, FZ_ERROR_GENERIC, "unknown shading type: %d", type); } @@ -433,7 +420,7 @@ pdf_load_shading_dict(pdf_document *doc, pdf_obj *dict, const fz_matrix *transfo { fz_drop_shade(ctx, shade); - fz_rethrow_message(ctx, "cannot load shading type %d (%d %d R)", type, pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load shading type %d (%d %d R)", type, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } return shade; } @@ -449,11 +436,10 @@ fz_shade_size(fz_shade *s) } fz_shade * -pdf_load_shading(pdf_document *doc, pdf_obj *dict) +pdf_load_shading(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { fz_matrix mat; pdf_obj *obj; - fz_context *ctx = doc->ctx; fz_shade *shade; if ((shade = pdf_find_item(ctx, fz_drop_shade_imp, dict)) != NULL) @@ -462,34 +448,34 @@ pdf_load_shading(pdf_document *doc, pdf_obj *dict) } /* Type 2 pattern dictionary */ - if (pdf_dict_gets(dict, "PatternType")) + if (pdf_dict_gets(ctx, dict, "PatternType")) { - obj = pdf_dict_gets(dict, "Matrix"); + obj = pdf_dict_gets(ctx, dict, "Matrix"); if (obj) pdf_to_matrix(ctx, obj, &mat); else mat = fz_identity; - obj = pdf_dict_gets(dict, "ExtGState"); + obj = pdf_dict_gets(ctx, dict, "ExtGState"); if (obj) { - if (pdf_dict_gets(obj, "CA") || pdf_dict_gets(obj, "ca")) + if (pdf_dict_gets(ctx, obj, "CA") || pdf_dict_gets(ctx, obj, "ca")) { fz_warn(ctx, "shading with alpha not supported"); } } - obj = pdf_dict_gets(dict, "Shading"); + obj = pdf_dict_gets(ctx, dict, "Shading"); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: missing shading dictionary"); - shade = pdf_load_shading_dict(doc, obj, &mat); + shade = pdf_load_shading_dict(ctx, doc, obj, &mat); } /* Naked shading dictionary */ else { - shade = pdf_load_shading_dict(doc, dict, &fz_identity); + shade = pdf_load_shading_dict(ctx, doc, dict, &fz_identity); } pdf_store_item(ctx, dict, shade, fz_shade_size(shade)); diff --git a/source/pdf/pdf-store.c b/source/pdf/pdf-store.c index 7349e9d4..51255414 100644 --- a/source/pdf/pdf-store.c +++ b/source/pdf/pdf-store.c @@ -1,48 +1,48 @@ #include "mupdf/pdf.h" static int -pdf_make_hash_key(fz_store_hash *hash, void *key_) +pdf_make_hash_key(fz_context *ctx, fz_store_hash *hash, void *key_) { pdf_obj *key = (pdf_obj *)key_; - if (!pdf_is_indirect(key)) + if (!pdf_is_indirect(ctx, key)) return 0; - hash->u.i.i0 = pdf_to_num(key); - hash->u.i.i1 = pdf_to_gen(key); - hash->u.i.ptr = pdf_get_indirect_document(key); + hash->u.i.i0 = pdf_to_num(ctx, key); + hash->u.i.i1 = pdf_to_gen(ctx, key); + hash->u.i.ptr = pdf_get_indirect_document(ctx, key); return 1; } static void * pdf_keep_key(fz_context *ctx, void *key) { - return (void *)pdf_keep_obj((pdf_obj *)key); + return (void *)pdf_keep_obj(ctx, (pdf_obj *)key); } static void pdf_drop_key(fz_context *ctx, void *key) { - pdf_drop_obj((pdf_obj *)key); + pdf_drop_obj(ctx, (pdf_obj *)key); } static int -pdf_cmp_key(void *k0, void *k1) +pdf_cmp_key(fz_context *ctx, void *k0, void *k1) { - return pdf_objcmp((pdf_obj *)k0, (pdf_obj *)k1); + return pdf_objcmp(ctx, (pdf_obj *)k0, (pdf_obj *)k1); } #ifndef NDEBUG static void -pdf_debug_key(FILE *out, void *key_) +pdf_debug_key(fz_context *ctx, FILE *out, void *key_) { pdf_obj *key = (pdf_obj *)key_; - if (pdf_is_indirect(key)) + if (pdf_is_indirect(ctx, key)) { - fprintf(out, "(%d %d R) ", pdf_to_num(key), pdf_to_gen(key)); + fprintf(out, "(%d %d R) ", pdf_to_num(ctx, key), pdf_to_gen(ctx, key)); } else - pdf_fprint_obj(out, key, 0); + pdf_fprint_obj(ctx, out, key, 0); } #endif diff --git a/source/pdf/pdf-stream.c b/source/pdf/pdf-stream.c index 9efd1887..2335e67a 100644 --- a/source/pdf/pdf-stream.c +++ b/source/pdf/pdf-stream.c @@ -4,14 +4,14 @@ * Check if an object is a stream or not. */ int -pdf_is_stream(pdf_document *doc, int num, int gen) +pdf_is_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { pdf_xref_entry *entry; - if (num <= 0 || num >= pdf_xref_len(doc)) + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) return 0; - entry = pdf_cache_object(doc, num, gen); + entry = pdf_cache_object(ctx, doc, num, gen); return entry->stm_ofs != 0 || entry->stm_buf; } @@ -26,18 +26,18 @@ pdf_stream_has_crypt(fz_context *ctx, pdf_obj *stm) pdf_obj *obj; int i; - filters = pdf_dict_getsa(stm, "Filter", "F"); + filters = pdf_dict_getsa(ctx, stm, "Filter", "F"); if (filters) { - if (!strcmp(pdf_to_name(filters), "Crypt")) + if (!strcmp(pdf_to_name(ctx, filters), "Crypt")) return 1; - if (pdf_is_array(filters)) + if (pdf_is_array(ctx, filters)) { - int n = pdf_array_len(filters); + int n = pdf_array_len(ctx, filters); for (i = 0; i < n; i++) { - obj = pdf_array_get(filters, i); - if (!strcmp(pdf_to_name(obj), "Crypt")) + obj = pdf_array_get(ctx, filters, i); + if (!strcmp(pdf_to_name(ctx, obj), "Crypt")) return 1; } } @@ -46,10 +46,9 @@ pdf_stream_has_crypt(fz_context *ctx, pdf_obj *stm) } static fz_jbig2_globals * -pdf_load_jbig2_globals(pdf_document *doc, pdf_obj *dict) +pdf_load_jbig2_globals(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { fz_jbig2_globals *globals; - fz_context *ctx = doc->ctx; fz_buffer *buf = NULL; fz_var(buf); @@ -61,7 +60,7 @@ pdf_load_jbig2_globals(pdf_document *doc, pdf_obj *dict) fz_try(ctx) { - buf = pdf_load_stream(doc, pdf_to_num(dict), pdf_to_gen(dict)); + buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); globals = fz_load_jbig2_globals(ctx, buf->data, buf->len); pdf_store_item(ctx, dict, globals, buf->len); } @@ -81,68 +80,67 @@ pdf_load_jbig2_globals(pdf_document *doc, pdf_obj *dict) * Create a filter given a name and param dictionary. */ static fz_stream * -build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int num, int gen, fz_compression_params *params) +build_filter(fz_context *ctx, fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int num, int gen, fz_compression_params *params) { - fz_context *ctx = chain->ctx; - char *s = pdf_to_name(f); + char *s = pdf_to_name(ctx, f); - int predictor = pdf_to_int(pdf_dict_gets(p, "Predictor")); - pdf_obj *columns_obj = pdf_dict_gets(p, "Columns"); - int columns = pdf_to_int(columns_obj); - int colors = pdf_to_int(pdf_dict_gets(p, "Colors")); - int bpc = pdf_to_int(pdf_dict_gets(p, "BitsPerComponent")); + int predictor = pdf_to_int(ctx, pdf_dict_gets(ctx, p, "Predictor")); + pdf_obj *columns_obj = pdf_dict_gets(ctx, p, "Columns"); + int columns = pdf_to_int(ctx, columns_obj); + int colors = pdf_to_int(ctx, pdf_dict_gets(ctx, p, "Colors")); + int bpc = pdf_to_int(ctx, pdf_dict_gets(ctx, p, "BitsPerComponent")); if (params) params->type = FZ_IMAGE_RAW; if (!strcmp(s, "ASCIIHexDecode") || !strcmp(s, "AHx")) - return fz_open_ahxd(chain); + return fz_open_ahxd(ctx, chain); else if (!strcmp(s, "ASCII85Decode") || !strcmp(s, "A85")) - return fz_open_a85d(chain); + return fz_open_a85d(ctx, chain); else if (!strcmp(s, "CCITTFaxDecode") || !strcmp(s, "CCF")) { - pdf_obj *k = pdf_dict_gets(p, "K"); - pdf_obj *eol = pdf_dict_gets(p, "EndOfLine"); - pdf_obj *eba = pdf_dict_gets(p, "EncodedByteAlign"); - pdf_obj *rows = pdf_dict_gets(p, "Rows"); - pdf_obj *eob = pdf_dict_gets(p, "EndOfBlock"); - pdf_obj *bi1 = pdf_dict_gets(p, "BlackIs1"); + pdf_obj *k = pdf_dict_gets(ctx, p, "K"); + pdf_obj *eol = pdf_dict_gets(ctx, p, "EndOfLine"); + pdf_obj *eba = pdf_dict_gets(ctx, p, "EncodedByteAlign"); + pdf_obj *rows = pdf_dict_gets(ctx, p, "Rows"); + pdf_obj *eob = pdf_dict_gets(ctx, p, "EndOfBlock"); + pdf_obj *bi1 = pdf_dict_gets(ctx, p, "BlackIs1"); if (params) { /* We will shortstop here */ params->type = FZ_IMAGE_FAX; - params->u.fax.k = (k ? pdf_to_int(k) : 0); - params->u.fax.end_of_line = (eol ? pdf_to_bool(eol) : 0); - params->u.fax.encoded_byte_align = (eba ? pdf_to_bool(eba) : 0); + params->u.fax.k = (k ? pdf_to_int(ctx, k) : 0); + params->u.fax.end_of_line = (eol ? pdf_to_bool(ctx, eol) : 0); + params->u.fax.encoded_byte_align = (eba ? pdf_to_bool(ctx, eba) : 0); params->u.fax.columns = (columns_obj ? columns : 1728); - params->u.fax.rows = (rows ? pdf_to_int(rows) : 0); - params->u.fax.end_of_block = (eob ? pdf_to_bool(eob) : 1); - params->u.fax.black_is_1 = (bi1 ? pdf_to_bool(bi1) : 0); + params->u.fax.rows = (rows ? pdf_to_int(ctx, rows) : 0); + params->u.fax.end_of_block = (eob ? pdf_to_bool(ctx, eob) : 1); + params->u.fax.black_is_1 = (bi1 ? pdf_to_bool(ctx, bi1) : 0); return chain; } - return fz_open_faxd(chain, - k ? pdf_to_int(k) : 0, - eol ? pdf_to_bool(eol) : 0, - eba ? pdf_to_bool(eba) : 0, + return fz_open_faxd(ctx, chain, + k ? pdf_to_int(ctx, k) : 0, + eol ? pdf_to_bool(ctx, eol) : 0, + eba ? pdf_to_bool(ctx, eba) : 0, columns_obj ? columns : 1728, - rows ? pdf_to_int(rows) : 0, - eob ? pdf_to_bool(eob) : 1, - bi1 ? pdf_to_bool(bi1) : 0); + rows ? pdf_to_int(ctx, rows) : 0, + eob ? pdf_to_bool(ctx, eob) : 1, + bi1 ? pdf_to_bool(ctx, bi1) : 0); } else if (!strcmp(s, "DCTDecode") || !strcmp(s, "DCT")) { - pdf_obj *ct = pdf_dict_gets(p, "ColorTransform"); + pdf_obj *ct = pdf_dict_gets(ctx, p, "ColorTransform"); if (params) { /* We will shortstop here */ params->type = FZ_IMAGE_JPEG; - params->u.jpeg.color_transform = (ct ? pdf_to_int(ct) : -1); + params->u.jpeg.color_transform = (ct ? pdf_to_int(ctx, ct) : -1); return chain; } - return fz_open_dctd(chain, ct ? pdf_to_int(ct) : -1, 0, NULL); + return fz_open_dctd(ctx, chain, ct ? pdf_to_int(ctx, ct) : -1, 0, NULL); } else if (!strcmp(s, "RunLengthDecode") || !strcmp(s, "RL")) @@ -153,7 +151,7 @@ build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int nu params->type = FZ_IMAGE_RLD; return chain; } - return fz_open_rld(chain); + return fz_open_rld(ctx, chain); } else if (!strcmp(s, "FlateDecode") || !strcmp(s, "Fl")) { @@ -167,15 +165,15 @@ build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int nu params->u.flate.bpc = bpc; return chain; } - chain = fz_open_flated(chain, 15); + chain = fz_open_flated(ctx, chain, 15); if (predictor > 1) - chain = fz_open_predict(chain, predictor, columns, colors, bpc); + chain = fz_open_predict(ctx, chain, predictor, columns, colors, bpc); return chain; } else if (!strcmp(s, "LZWDecode") || !strcmp(s, "LZW")) { - pdf_obj *ec = pdf_dict_gets(p, "EarlyChange"); + pdf_obj *ec = pdf_dict_gets(ctx, p, "EarlyChange"); if (params) { /* We will shortstop here */ @@ -184,23 +182,23 @@ build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int nu params->u.lzw.columns = columns; params->u.lzw.colors = colors; params->u.lzw.bpc = bpc; - params->u.lzw.early_change = (ec ? pdf_to_int(ec) : 1); + params->u.lzw.early_change = (ec ? pdf_to_int(ctx, ec) : 1); return chain; } - chain = fz_open_lzwd(chain, ec ? pdf_to_int(ec) : 1); + chain = fz_open_lzwd(ctx, chain, ec ? pdf_to_int(ctx, ec) : 1); if (predictor > 1) - chain = fz_open_predict(chain, predictor, columns, colors, bpc); + chain = fz_open_predict(ctx, chain, predictor, columns, colors, bpc); return chain; } else if (!strcmp(s, "JBIG2Decode")) { fz_jbig2_globals *globals = NULL; - pdf_obj *obj = pdf_dict_gets(p, "JBIG2Globals"); - if (pdf_is_indirect(obj)) - globals = pdf_load_jbig2_globals(doc, obj); + pdf_obj *obj = pdf_dict_gets(ctx, p, "JBIG2Globals"); + if (pdf_is_indirect(ctx, obj)) + globals = pdf_load_jbig2_globals(ctx, doc, obj); /* fz_open_jbig2d takes possession of globals */ - return fz_open_jbig2d(chain, globals); + return fz_open_jbig2d(ctx, chain, globals); } else if (!strcmp(s, "JPXDecode")) @@ -216,9 +214,9 @@ build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int nu return chain; } - name = pdf_dict_gets(p, "Name"); - if (pdf_is_name(name)) - return pdf_open_crypt_with_filter(chain, doc->crypt, pdf_to_name(name), num, gen); + name = pdf_dict_gets(ctx, p, "Name"); + if (pdf_is_name(ctx, name)) + return pdf_open_crypt_with_filter(ctx, chain, doc->crypt, pdf_to_name(ctx, name), num, gen); return chain; } @@ -233,30 +231,29 @@ build_filter(fz_stream *chain, pdf_document *doc, pdf_obj *f, pdf_obj *p, int nu * Assume ownership of head. */ static fz_stream * -build_filter_chain(fz_stream *chain, pdf_document *doc, pdf_obj *fs, pdf_obj *ps, int num, int gen, fz_compression_params *params) +build_filter_chain(fz_context *ctx, fz_stream *chain, pdf_document *doc, pdf_obj *fs, pdf_obj *ps, int num, int gen, fz_compression_params *params) { pdf_obj *f; pdf_obj *p; int i, n; - fz_context *ctx = chain->ctx; fz_try(ctx) { - n = pdf_array_len(fs); + n = pdf_array_len(ctx, fs); for (i = 0; i < n; i++) { fz_stream *chain2; - f = pdf_array_get(fs, i); - p = pdf_array_get(ps, i); + f = pdf_array_get(ctx, fs, i); + p = pdf_array_get(ctx, ps, i); chain2 = chain; chain = NULL; - chain = build_filter(chain2, doc, f, p, num, gen, (i == n-1 ? params : NULL)); + chain = build_filter(ctx, chain2, doc, f, p, num, gen, (i == n-1 ? params : NULL)); } } fz_catch(ctx) { - fz_drop_stream(chain); + fz_drop_stream(ctx, chain); fz_rethrow(ctx); } @@ -272,28 +269,27 @@ build_filter_chain(fz_stream *chain, pdf_document *doc, pdf_obj *fs, pdf_obj *ps * orig_num and orig_gen are used purely to seed the encryption. */ static fz_stream * -pdf_open_raw_filter(fz_stream *chain, pdf_document *doc, pdf_obj *stmobj, int num, int orig_num, int orig_gen, int offset) +pdf_open_raw_filter(fz_context *ctx, fz_stream *chain, pdf_document *doc, pdf_obj *stmobj, int num, int orig_num, int orig_gen, int offset) { - fz_context *ctx = chain->ctx; int hascrypt; int len; - if (num > 0 && num < pdf_xref_len(doc)) + if (num > 0 && num < pdf_xref_len(ctx, doc)) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, num); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num); if (entry->stm_buf) return fz_open_buffer(ctx, entry->stm_buf); } /* don't close chain when we close this filter */ - fz_keep_stream(chain); + fz_keep_stream(ctx, chain); - len = pdf_to_int(pdf_dict_gets(stmobj, "Length")); - chain = fz_open_null(chain, len, offset); + len = pdf_to_int(ctx, pdf_dict_gets(ctx, stmobj, "Length")); + chain = fz_open_null(ctx, chain, len, offset); hascrypt = pdf_stream_has_crypt(ctx, stmobj); if (doc->crypt && !hascrypt) - chain = pdf_open_crypt(chain, doc->crypt, orig_num, orig_gen); + chain = pdf_open_crypt(ctx, chain, doc->crypt, orig_num, orig_gen); return chain; } @@ -303,37 +299,37 @@ pdf_open_raw_filter(fz_stream *chain, pdf_document *doc, pdf_obj *stmobj, int nu * to stream length and decrypting. */ static fz_stream * -pdf_open_filter(fz_stream *chain, pdf_document *doc, pdf_obj *stmobj, int num, int gen, int offset, fz_compression_params *imparams) +pdf_open_filter(fz_context *ctx, pdf_document *doc, fz_stream *chain, pdf_obj *stmobj, int num, int gen, int offset, fz_compression_params *imparams) { pdf_obj *filters; pdf_obj *params; - filters = pdf_dict_getsa(stmobj, "Filter", "F"); - params = pdf_dict_getsa(stmobj, "DecodeParms", "DP"); + filters = pdf_dict_getsa(ctx, stmobj, "Filter", "F"); + params = pdf_dict_getsa(ctx, stmobj, "DecodeParms", "DP"); - chain = pdf_open_raw_filter(chain, doc, stmobj, num, num, gen, offset); + chain = pdf_open_raw_filter(ctx, chain, doc, stmobj, num, num, gen, offset); fz_var(chain); - fz_try(doc->ctx) + fz_try(ctx) { - if (pdf_is_name(filters)) + if (pdf_is_name(ctx, filters)) { fz_stream *chain2 = chain; chain = NULL; - chain = build_filter(chain2, doc, filters, params, num, gen, imparams); + chain = build_filter(ctx, chain2, doc, filters, params, num, gen, imparams); } - else if (pdf_array_len(filters) > 0) + else if (pdf_array_len(ctx, filters) > 0) { fz_stream *chain2 = chain; chain = NULL; - chain = build_filter_chain(chain2, doc, filters, params, num, gen, imparams); + chain = build_filter_chain(ctx, chain2, doc, filters, params, num, gen, imparams); } } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_drop_stream(chain); - fz_rethrow(doc->ctx); + fz_drop_stream(ctx, chain); + fz_rethrow(ctx); } return chain; @@ -344,31 +340,30 @@ pdf_open_filter(fz_stream *chain, pdf_document *doc, pdf_obj *stmobj, int num, i * constraining to stream length, and without decryption. */ fz_stream * -pdf_open_inline_stream(pdf_document *doc, pdf_obj *stmobj, int length, fz_stream *chain, fz_compression_params *imparams) +pdf_open_inline_stream(fz_context *ctx, pdf_document *doc, pdf_obj *stmobj, int length, fz_stream *chain, fz_compression_params *imparams) { pdf_obj *filters; pdf_obj *params; - filters = pdf_dict_getsa(stmobj, "Filter", "F"); - params = pdf_dict_getsa(stmobj, "DecodeParms", "DP"); + filters = pdf_dict_getsa(ctx, stmobj, "Filter", "F"); + params = pdf_dict_getsa(ctx, stmobj, "DecodeParms", "DP"); /* don't close chain when we close this filter */ - fz_keep_stream(chain); + fz_keep_stream(ctx, chain); - if (pdf_is_name(filters)) - return build_filter(chain, doc, filters, params, 0, 0, imparams); - if (pdf_array_len(filters) > 0) - return build_filter_chain(chain, doc, filters, params, 0, 0, imparams); + if (pdf_is_name(ctx, filters)) + return build_filter(ctx, chain, doc, filters, params, 0, 0, imparams); + if (pdf_array_len(ctx, filters) > 0) + return build_filter_chain(ctx, chain, doc, filters, params, 0, 0, imparams); if (imparams) imparams->type = FZ_IMAGE_RAW; - return fz_open_null(chain, length, fz_tell(chain)); + return fz_open_null(ctx, chain, length, fz_tell(ctx, chain)); } void -pdf_load_compressed_inline_image(pdf_document *doc, pdf_obj *dict, int length, fz_stream *stm, int indexed, fz_image *image) +pdf_load_compressed_inline_image(fz_context *ctx, pdf_document *doc, pdf_obj *dict, int length, fz_stream *stm, int indexed, fz_image *image) { - fz_context *ctx = doc->ctx; fz_compressed_buffer *bc = fz_malloc_struct(ctx, fz_compressed_buffer); fz_try(ctx) @@ -376,8 +371,8 @@ pdf_load_compressed_inline_image(pdf_document *doc, pdf_obj *dict, int length, f int dummy_l2factor = 0; bc->buffer = fz_new_buffer(ctx, 1024); - stm = pdf_open_inline_stream(doc, dict, length, stm, &bc->params); - stm = fz_open_leecher(stm, bc->buffer); + stm = pdf_open_inline_stream(ctx, doc, dict, length, stm, &bc->params); + stm = fz_open_leecher(ctx, stm, bc->buffer); stm = fz_open_image_decomp_stream(ctx, stm, &bc->params, &dummy_l2factor); image->tile = fz_decomp_image_from_stream(ctx, stm, image, indexed, 0, 0); @@ -394,39 +389,39 @@ pdf_load_compressed_inline_image(pdf_document *doc, pdf_obj *dict, int length, f * Open a stream for reading the raw (compressed but decrypted) data. */ fz_stream * -pdf_open_raw_stream(pdf_document *doc, int num, int gen) +pdf_open_raw_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { - return pdf_open_raw_renumbered_stream(doc, num, gen, num, gen); + return pdf_open_raw_renumbered_stream(ctx, doc, num, gen, num, gen); } fz_stream * -pdf_open_raw_renumbered_stream(pdf_document *doc, int num, int gen, int orig_num, int orig_gen) +pdf_open_raw_renumbered_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen) { pdf_xref_entry *x; - if (num <= 0 || num >= pdf_xref_len(doc)) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object id out of range (%d %d R)", num, gen); + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) + fz_throw(ctx, FZ_ERROR_GENERIC, "object id out of range (%d %d R)", num, gen); - x = pdf_cache_object(doc, num, gen); + x = pdf_cache_object(ctx, doc, num, gen); if (x->stm_ofs == 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object is not a stream"); + fz_throw(ctx, FZ_ERROR_GENERIC, "object is not a stream"); - return pdf_open_raw_filter(doc->file, doc, x->obj, num, orig_num, orig_gen, x->stm_ofs); + return pdf_open_raw_filter(ctx, doc->file, doc, x->obj, num, orig_num, orig_gen, x->stm_ofs); } static fz_stream * -pdf_open_image_stream(pdf_document *doc, int num, int gen, int orig_num, int orig_gen, fz_compression_params *params) +pdf_open_image_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen, fz_compression_params *params) { pdf_xref_entry *x; - if (num <= 0 || num >= pdf_xref_len(doc)) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object id out of range (%d %d R)", num, gen); + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) + fz_throw(ctx, FZ_ERROR_GENERIC, "object id out of range (%d %d R)", num, gen); - x = pdf_cache_object(doc, num, gen); + x = pdf_cache_object(ctx, doc, num, gen); if (x->stm_ofs == 0 && x->stm_buf == NULL) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object is not a stream"); + fz_throw(ctx, FZ_ERROR_GENERIC, "object is not a stream"); - return pdf_open_filter(doc->file, doc, x->obj, orig_num, orig_gen, x->stm_ofs, params); + return pdf_open_filter(ctx, doc, doc->file, x->obj, orig_num, orig_gen, x->stm_ofs, params); } /* @@ -435,55 +430,55 @@ pdf_open_image_stream(pdf_document *doc, int num, int gen, int orig_num, int ori * Using doc->file while a stream is open is a Bad idea. */ fz_stream * -pdf_open_stream(pdf_document *doc, int num, int gen) +pdf_open_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { - return pdf_open_image_stream(doc, num, gen, num, gen, NULL); + return pdf_open_image_stream(ctx, doc, num, gen, num, gen, NULL); } fz_stream * -pdf_open_stream_with_offset(pdf_document *doc, int num, int gen, pdf_obj *dict, int stm_ofs) +pdf_open_stream_with_offset(fz_context *ctx, pdf_document *doc, int num, int gen, pdf_obj *dict, int stm_ofs) { if (stm_ofs == 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object is not a stream"); + fz_throw(ctx, FZ_ERROR_GENERIC, "object is not a stream"); - return pdf_open_filter(doc->file, doc, dict, num, gen, stm_ofs, NULL); + return pdf_open_filter(ctx, doc, doc->file, dict, num, gen, stm_ofs, NULL); } /* * Load raw (compressed but decrypted) contents of a stream into buf. */ fz_buffer * -pdf_load_raw_stream(pdf_document *doc, int num, int gen) +pdf_load_raw_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { - return pdf_load_raw_renumbered_stream(doc, num, gen, num, gen); + return pdf_load_raw_renumbered_stream(ctx, doc, num, gen, num, gen); } fz_buffer * -pdf_load_raw_renumbered_stream(pdf_document *doc, int num, int gen, int orig_num, int orig_gen) +pdf_load_raw_renumbered_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen) { fz_stream *stm; pdf_obj *dict; int len; fz_buffer *buf; - if (num > 0 && num < pdf_xref_len(doc)) + if (num > 0 && num < pdf_xref_len(ctx, doc)) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, num); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num); if (entry->stm_buf) - return fz_keep_buffer(doc->ctx, entry->stm_buf); + return fz_keep_buffer(ctx, entry->stm_buf); } - dict = pdf_load_object(doc, num, gen); + dict = pdf_load_object(ctx, doc, num, gen); - len = pdf_to_int(pdf_dict_gets(dict, "Length")); + len = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "Length")); - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); - stm = pdf_open_raw_renumbered_stream(doc, num, gen, orig_num, orig_gen); + stm = pdf_open_raw_renumbered_stream(ctx, doc, num, gen, orig_num, orig_gen); - buf = fz_read_all(stm, len); + buf = fz_read_all(ctx, stm, len); - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); return buf; } @@ -504,9 +499,8 @@ pdf_guess_filter_length(int len, char *filter) } static fz_buffer * -pdf_load_image_stream(pdf_document *doc, int num, int gen, int orig_num, int orig_gen, fz_compression_params *params, int *truncated) +pdf_load_image_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen, fz_compression_params *params, int *truncated) { - fz_context *ctx = doc->ctx; fz_stream *stm = NULL; pdf_obj *dict, *obj; int i, len, n; @@ -514,36 +508,36 @@ pdf_load_image_stream(pdf_document *doc, int num, int gen, int orig_num, int ori fz_var(buf); - if (num > 0 && num < pdf_xref_len(doc)) + if (num > 0 && num < pdf_xref_len(ctx, doc)) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, num); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num); if (entry->stm_buf) - return fz_keep_buffer(doc->ctx, entry->stm_buf); + return fz_keep_buffer(ctx, entry->stm_buf); } - dict = pdf_load_object(doc, num, gen); + dict = pdf_load_object(ctx, doc, num, gen); - len = pdf_to_int(pdf_dict_gets(dict, "Length")); - obj = pdf_dict_gets(dict, "Filter"); - len = pdf_guess_filter_length(len, pdf_to_name(obj)); - n = pdf_array_len(obj); + len = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "Length")); + obj = pdf_dict_gets(ctx, dict, "Filter"); + len = pdf_guess_filter_length(len, pdf_to_name(ctx, obj)); + n = pdf_array_len(ctx, obj); for (i = 0; i < n; i++) - len = pdf_guess_filter_length(len, pdf_to_name(pdf_array_get(obj, i))); + len = pdf_guess_filter_length(len, pdf_to_name(ctx, pdf_array_get(ctx, obj, i))); - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); - stm = pdf_open_image_stream(doc, num, gen, orig_num, orig_gen, params); + stm = pdf_open_image_stream(ctx, doc, num, gen, orig_num, orig_gen, params); fz_try(ctx) { if (truncated) - buf = fz_read_best(stm, len, truncated); + buf = fz_read_best(ctx, stm, len, truncated); else - buf = fz_read_all(stm, len); + buf = fz_read_all(ctx, stm, len); } fz_always(ctx) { - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); } fz_catch(ctx) { @@ -557,26 +551,25 @@ pdf_load_image_stream(pdf_document *doc, int num, int gen, int orig_num, int ori * Load uncompressed contents of a stream into buf. */ fz_buffer * -pdf_load_stream(pdf_document *doc, int num, int gen) +pdf_load_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { - return pdf_load_image_stream(doc, num, gen, num, gen, NULL, NULL); + return pdf_load_image_stream(ctx, doc, num, gen, num, gen, NULL, NULL); } fz_buffer * -pdf_load_renumbered_stream(pdf_document *doc, int num, int gen, int orig_num, int orig_gen, int *truncated) +pdf_load_renumbered_stream(fz_context *ctx, pdf_document *doc, int num, int gen, int orig_num, int orig_gen, int *truncated) { - return pdf_load_image_stream(doc, num, gen, orig_num, orig_gen, NULL, truncated); + return pdf_load_image_stream(ctx, doc, num, gen, orig_num, orig_gen, NULL, truncated); } fz_compressed_buffer * -pdf_load_compressed_stream(pdf_document *doc, int num, int gen) +pdf_load_compressed_stream(fz_context *ctx, pdf_document *doc, int num, int gen) { - fz_context *ctx = doc->ctx; fz_compressed_buffer *bc = fz_malloc_struct(ctx, fz_compressed_buffer); fz_try(ctx) { - bc->buffer = pdf_load_image_stream(doc, num, gen, num, gen, &bc->params, NULL); + bc->buffer = pdf_load_image_stream(ctx, doc, num, gen, num, gen, &bc->params, NULL); } fz_catch(ctx) { @@ -587,22 +580,21 @@ pdf_load_compressed_stream(pdf_document *doc, int num, int gen) } static fz_stream * -pdf_open_object_array(pdf_document *doc, pdf_obj *list) +pdf_open_object_array(fz_context *ctx, pdf_document *doc, pdf_obj *list) { - int i, n; - fz_context *ctx = doc->ctx; fz_stream *stm; + int i, n; - n = pdf_array_len(list); + n = pdf_array_len(ctx, list); stm = fz_open_concat(ctx, n, 1); fz_var(i); /* Workaround Mac compiler bug */ for (i = 0; i < n; i++) { - pdf_obj *obj = pdf_array_get(list, i); + pdf_obj *obj = pdf_array_get(ctx, list, i); fz_try(ctx) { - fz_concat_push(stm, pdf_open_stream(doc, pdf_to_num(obj), pdf_to_gen(obj))); + fz_concat_push(ctx, stm, pdf_open_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj))); } fz_catch(ctx) { @@ -616,18 +608,17 @@ pdf_open_object_array(pdf_document *doc, pdf_obj *list) } fz_stream * -pdf_open_contents_stream(pdf_document *doc, pdf_obj *obj) +pdf_open_contents_stream(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - fz_context *ctx = doc->ctx; int num, gen; - if (pdf_is_array(obj)) - return pdf_open_object_array(doc, obj); + if (pdf_is_array(ctx, obj)) + return pdf_open_object_array(ctx, doc, obj); - num = pdf_to_num(obj); - gen = pdf_to_gen(obj); - if (pdf_is_stream(doc, num, gen)) - return pdf_open_image_stream(doc, num, gen, num, gen, NULL); + num = pdf_to_num(ctx, obj); + gen = pdf_to_gen(ctx, obj); + if (pdf_is_stream(ctx, doc, num, gen)) + return pdf_open_image_stream(ctx, doc, num, gen, num, gen, NULL); fz_warn(ctx, "pdf object stream missing (%d %d R)", num, gen); return NULL; diff --git a/source/pdf/pdf-type3.c b/source/pdf/pdf-type3.c index 3bb01a1c..3da74806 100644 --- a/source/pdf/pdf-type3.c +++ b/source/pdf/pdf-type3.c @@ -1,20 +1,20 @@ #include "mupdf/pdf.h" static void -pdf_run_glyph_func(void *doc, void *rdb, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth) +pdf_run_glyph_func(fz_context *ctx, void *doc, void *rdb, fz_buffer *contents, fz_device *dev, const fz_matrix *ctm, void *gstate, int nested_depth) { - pdf_run_glyph(doc, (pdf_obj *)rdb, contents, dev, ctm, gstate, nested_depth); + pdf_run_glyph(ctx, doc, (pdf_obj *)rdb, contents, dev, ctm, gstate, nested_depth); } static void -pdf_t3_free_resources(void *doc, void *rdb_) +pdf_t3_free_resources(fz_context *ctx, void *doc, void *rdb_) { pdf_obj *rdb = (pdf_obj *)rdb_; - pdf_drop_obj(rdb); + pdf_drop_obj(ctx, rdb); } pdf_font_desc * -pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) +pdf_load_type3_font(fz_context *ctx, pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) { char buf[256]; char *estrings[256]; @@ -27,7 +27,6 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) int i, k, n; fz_rect bbox; fz_matrix matrix; - fz_context *ctx = doc->ctx; fz_var(fontdesc); @@ -38,24 +37,24 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) if (new_max == 0) new_max = 4; - doc->type3_fonts = fz_resize_array(doc->ctx, doc->type3_fonts, new_max, sizeof(*doc->type3_fonts)); + doc->type3_fonts = fz_resize_array(ctx, doc->type3_fonts, new_max, sizeof(*doc->type3_fonts)); doc->max_type3_fonts = new_max; } fz_try(ctx) { - obj = pdf_dict_gets(dict, "Name"); - if (pdf_is_name(obj)) - fz_strlcpy(buf, pdf_to_name(obj), sizeof buf); + obj = pdf_dict_gets(ctx, dict, "Name"); + if (pdf_is_name(ctx, obj)) + fz_strlcpy(buf, pdf_to_name(ctx, obj), sizeof buf); else fz_strlcpy(buf, "Unnamed-T3", sizeof buf); fontdesc = pdf_new_font_desc(ctx); - obj = pdf_dict_gets(dict, "FontMatrix"); + obj = pdf_dict_gets(ctx, dict, "FontMatrix"); pdf_to_matrix(ctx, obj, &matrix); - obj = pdf_dict_gets(dict, "FontBBox"); + obj = pdf_dict_gets(ctx, dict, "FontBBox"); fz_transform_rect(pdf_to_rect(ctx, obj, &bbox), &matrix); fontdesc->font = fz_new_type3_font(ctx, buf, &matrix); @@ -68,35 +67,35 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) for (i = 0; i < 256; i++) estrings[i] = NULL; - encoding = pdf_dict_gets(dict, "Encoding"); + encoding = pdf_dict_gets(ctx, dict, "Encoding"); if (!encoding) { fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Encoding"); } - if (pdf_is_name(encoding)) - pdf_load_encoding(estrings, pdf_to_name(encoding)); + if (pdf_is_name(ctx, encoding)) + pdf_load_encoding(estrings, pdf_to_name(ctx, encoding)); - if (pdf_is_dict(encoding)) + if (pdf_is_dict(ctx, encoding)) { pdf_obj *base, *diff, *item; - base = pdf_dict_gets(encoding, "BaseEncoding"); - if (pdf_is_name(base)) - pdf_load_encoding(estrings, pdf_to_name(base)); + base = pdf_dict_gets(ctx, encoding, "BaseEncoding"); + if (pdf_is_name(ctx, base)) + pdf_load_encoding(estrings, pdf_to_name(ctx, base)); - diff = pdf_dict_gets(encoding, "Differences"); - if (pdf_is_array(diff)) + diff = pdf_dict_gets(ctx, encoding, "Differences"); + if (pdf_is_array(ctx, diff)) { - n = pdf_array_len(diff); + n = pdf_array_len(ctx, diff); k = 0; for (i = 0; i < n; i++) { - item = pdf_array_get(diff, i); - if (pdf_is_int(item)) - k = pdf_to_int(item); - if (pdf_is_name(item) && k >= 0 && k < nelem(estrings)) - estrings[k++] = pdf_to_name(item); + item = pdf_array_get(ctx, diff, i); + if (pdf_is_int(ctx, item)) + k = pdf_to_int(ctx, item); + if (pdf_is_name(ctx, item) && k >= 0 && k < nelem(estrings)) + estrings[k++] = pdf_to_name(ctx, item); } } } @@ -104,19 +103,19 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 1); fontdesc->size += pdf_cmap_size(ctx, fontdesc->encoding); - pdf_load_to_unicode(doc, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode")); + pdf_load_to_unicode(ctx, doc, fontdesc, estrings, NULL, pdf_dict_gets(ctx, dict, "ToUnicode")); /* Widths */ pdf_set_default_hmtx(ctx, fontdesc, 0); - first = pdf_to_int(pdf_dict_gets(dict, "FirstChar")); - last = pdf_to_int(pdf_dict_gets(dict, "LastChar")); + first = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "FirstChar")); + last = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "LastChar")); if (first < 0 || last > 255 || first > last) first = last = 0; - widths = pdf_dict_gets(dict, "Widths"); + widths = pdf_dict_gets(ctx, dict, "Widths"); if (!widths) { fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing Widths"); @@ -124,7 +123,7 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) for (i = first; i <= last; i++) { - float w = pdf_to_real(pdf_array_get(widths, i - first)); + float w = pdf_to_real(ctx, pdf_array_get(ctx, widths, i - first)); w = fontdesc->font->t3matrix.a * w * 1000; fontdesc->font->t3widths[i] = w * 0.001f; pdf_add_hmtx(ctx, fontdesc, i, i, w); @@ -135,11 +134,11 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) /* Resources -- inherit page resources if the font doesn't have its own */ fontdesc->font->t3freeres = pdf_t3_free_resources; - fontdesc->font->t3resources = pdf_dict_gets(dict, "Resources"); + fontdesc->font->t3resources = pdf_dict_gets(ctx, dict, "Resources"); if (!fontdesc->font->t3resources) fontdesc->font->t3resources = rdb; if (fontdesc->font->t3resources) - pdf_keep_obj(fontdesc->font->t3resources); + pdf_keep_obj(ctx, fontdesc->font->t3resources); if (!fontdesc->font->t3resources) fz_warn(ctx, "no resource dictionary for type 3 font!"); @@ -148,7 +147,7 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) /* CharProcs */ - charprocs = pdf_dict_gets(dict, "CharProcs"); + charprocs = pdf_dict_gets(ctx, dict, "CharProcs"); if (!charprocs) { fz_throw(ctx, FZ_ERROR_GENERIC, "syntaxerror: Type3 font missing CharProcs"); @@ -158,10 +157,10 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) { if (estrings[i]) { - obj = pdf_dict_gets(charprocs, estrings[i]); - if (pdf_is_stream(doc, pdf_to_num(obj), pdf_to_gen(obj))) + obj = pdf_dict_gets(ctx, charprocs, estrings[i]); + if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj))) { - fontdesc->font->t3procs[i] = pdf_load_stream(doc, pdf_to_num(obj), pdf_to_gen(obj)); + fontdesc->font->t3procs[i] = pdf_load_stream(ctx, doc, pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); fontdesc->size += fontdesc->font->t3procs[i]->cap; fontdesc->size += 0; // TODO: display list size calculation } @@ -172,7 +171,7 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) { if (fontdesc) pdf_drop_font(ctx, fontdesc); - fz_rethrow_message(ctx, "cannot load type3 font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load type3 font (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } doc->type3_fonts[doc->num_type3_fonts++] = fz_keep_font(ctx, fontdesc->font); @@ -180,10 +179,9 @@ pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict) return fontdesc; } -void pdf_load_type3_glyphs(pdf_document *doc, pdf_font_desc *fontdesc, int nested_depth) +void pdf_load_type3_glyphs(fz_context *ctx, pdf_document *doc, pdf_font_desc *fontdesc, int nested_depth) { int i; - fz_context *ctx = doc->ctx; fz_try(ctx) { diff --git a/source/pdf/pdf-unicode.c b/source/pdf/pdf-unicode.c index d51d580b..7b04c02c 100644 --- a/source/pdf/pdf-unicode.c +++ b/source/pdf/pdf-unicode.c @@ -56,15 +56,14 @@ pdf_remap_cmap(fz_context *ctx, pdf_cmap *gid_from_cpt, pdf_cmap *ucs_from_cpt) } void -pdf_load_to_unicode(pdf_document *doc, pdf_font_desc *font, +pdf_load_to_unicode(fz_context *ctx, pdf_document *doc, pdf_font_desc *font, char **strings, char *collection, pdf_obj *cmapstm) { - fz_context *ctx = doc->ctx; unsigned int cpt; - if (pdf_is_stream(doc, pdf_to_num(cmapstm), pdf_to_gen(cmapstm))) + if (pdf_is_stream(ctx, doc, pdf_to_num(ctx, cmapstm), pdf_to_gen(ctx, cmapstm))) { - pdf_cmap *ucs_from_cpt = pdf_load_embedded_cmap(doc, cmapstm); + pdf_cmap *ucs_from_cpt = pdf_load_embedded_cmap(ctx, doc, cmapstm); font->to_unicode = pdf_remap_cmap(ctx, font->encoding, ucs_from_cpt); pdf_drop_cmap(ctx, ucs_from_cpt); font->size += pdf_cmap_size(ctx, font->to_unicode); diff --git a/source/pdf/pdf-write.c b/source/pdf/pdf-write.c index 32143c10..1016e8af 100644 --- a/source/pdf/pdf-write.c +++ b/source/pdf/pdf-write.c @@ -489,11 +489,11 @@ page_objects_dump(pdf_write_options *opts) } static void -objects_dump(pdf_document *doc, pdf_write_options *opts) +objects_dump(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int i; - for (i=0; i < pdf_xref_len(doc); i++) + for (i=0; i < pdf_xref_len(ctx, doc); i++) { fprintf(stderr, "Object %d use=%x offset=%d\n", i, opts->use_list[i], opts->ofs_list[i]); } @@ -504,13 +504,12 @@ objects_dump(pdf_document *doc, pdf_write_options *opts) * Garbage collect objects not reachable from the trailer. */ -static pdf_obj *sweepref(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) +static pdf_obj *sweepref(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) { - int num = pdf_to_num(obj); - int gen = pdf_to_gen(obj); - fz_context *ctx = doc->ctx; + int num = pdf_to_num(ctx, obj); + int gen = pdf_to_gen(ctx, obj); - if (num <= 0 || num >= pdf_xref_len(doc)) + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) return NULL; if (opts->use_list[num]) return NULL; @@ -520,14 +519,14 @@ static pdf_obj *sweepref(pdf_document *doc, pdf_write_options *opts, pdf_obj *ob /* Bake in /Length in stream objects */ fz_try(ctx) { - if (pdf_is_stream(doc, num, gen)) + if (pdf_is_stream(ctx, doc, num, gen)) { - pdf_obj *len = pdf_dict_gets(obj, "Length"); - if (pdf_is_indirect(len)) + pdf_obj *len = pdf_dict_gets(ctx, obj, "Length"); + if (pdf_is_indirect(ctx, len)) { - opts->use_list[pdf_to_num(len)] = 0; - len = pdf_resolve_indirect(len); - pdf_dict_puts(obj, "Length", len); + opts->use_list[pdf_to_num(ctx, len)] = 0; + len = pdf_resolve_indirect(ctx, len); + pdf_dict_puts(ctx, obj, "Length", len); } } } @@ -537,28 +536,28 @@ static pdf_obj *sweepref(pdf_document *doc, pdf_write_options *opts, pdf_obj *ob /* Leave broken */ } - return pdf_resolve_indirect(obj); + return pdf_resolve_indirect(ctx, obj); } -static void sweepobj(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) +static void sweepobj(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) { int i; - if (pdf_is_indirect(obj)) - obj = sweepref(doc, opts, obj); + if (pdf_is_indirect(ctx, obj)) + obj = sweepref(ctx, doc, opts, obj); - if (pdf_is_dict(obj)) + if (pdf_is_dict(ctx, obj)) { - int n = pdf_dict_len(obj); + int n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) - sweepobj(doc, opts, pdf_dict_get_val(obj, i)); + sweepobj(ctx, doc, opts, pdf_dict_get_val(ctx, obj, i)); } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { - int n = pdf_array_len(obj); + int n = pdf_array_len(ctx, obj); for (i = 0; i < n; i++) - sweepobj(doc, opts, pdf_array_get(obj, i)); + sweepobj(ctx, doc, opts, pdf_array_get(ctx, obj, i)); } } @@ -566,11 +565,10 @@ static void sweepobj(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) * Scan for and remove duplicate objects (slow) */ -static void removeduplicateobjs(pdf_document *doc, pdf_write_options *opts) +static void removeduplicateobjs(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int num, other; - fz_context *ctx = doc->ctx; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); for (num = 1; num < xref_len; num++) { @@ -591,8 +589,8 @@ static void removeduplicateobjs(pdf_document *doc, pdf_write_options *opts) */ fz_try(ctx) { - streama = pdf_is_stream(doc, num, 0); - streamb = pdf_is_stream(doc, other, 0); + streama = pdf_is_stream(ctx, doc, num, 0); + streamb = pdf_is_stream(ctx, doc, other, 0); differ = streama || streamb; if (streama && streamb && opts->do_garbage >= 4) differ = 0; @@ -605,13 +603,13 @@ static void removeduplicateobjs(pdf_document *doc, pdf_write_options *opts) if (differ) continue; - a = pdf_get_xref_entry(doc, num)->obj; - b = pdf_get_xref_entry(doc, other)->obj; + a = pdf_get_xref_entry(ctx, doc, num)->obj; + b = pdf_get_xref_entry(ctx, doc, other)->obj; - a = pdf_resolve_indirect(a); - b = pdf_resolve_indirect(b); + a = pdf_resolve_indirect(ctx, a); + b = pdf_resolve_indirect(ctx, b); - if (pdf_objcmp(a, b)) + if (pdf_objcmp(ctx, a, b)) continue; if (streama && streamb) @@ -628,8 +626,8 @@ static void removeduplicateobjs(pdf_document *doc, pdf_write_options *opts) { unsigned char *dataa, *datab; int lena, lenb; - sa = pdf_load_raw_renumbered_stream(doc, num, 0, num, 0); - sb = pdf_load_raw_renumbered_stream(doc, other, 0, other, 0); + sa = pdf_load_raw_renumbered_stream(ctx, doc, num, 0, num, 0); + sb = pdf_load_raw_renumbered_stream(ctx, doc, other, 0, other, 0); lena = fz_buffer_storage(ctx, sa, &dataa); lenb = fz_buffer_storage(ctx, sb, &datab); if (lena == lenb && memcmp(dataa, datab, lena) == 0) @@ -667,10 +665,10 @@ static void removeduplicateobjs(pdf_document *doc, pdf_write_options *opts) * This code assumes that any opts->renumber_map[n] <= n for all n. */ -static void compactxref(pdf_document *doc, pdf_write_options *opts) +static void compactxref(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int num, newnum; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); /* * Update renumber_map in-place, clustering all used @@ -709,75 +707,74 @@ static void compactxref(pdf_document *doc, pdf_write_options *opts) * removing duplicate objects and compacting the xref. */ -static void renumberobj(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) +static void renumberobj(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *obj) { int i; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); - if (pdf_is_dict(obj)) + if (pdf_is_dict(ctx, obj)) { - int n = pdf_dict_len(obj); + int n = pdf_dict_len(ctx, obj); for (i = 0; i < n; i++) { - pdf_obj *key = pdf_dict_get_key(obj, i); - pdf_obj *val = pdf_dict_get_val(obj, i); - if (pdf_is_indirect(val)) + pdf_obj *key = pdf_dict_get_key(ctx, obj, i); + pdf_obj *val = pdf_dict_get_val(ctx, obj, i); + if (pdf_is_indirect(ctx, val)) { - int o = pdf_to_num(val); + int o = pdf_to_num(ctx, val); if (o >= xref_len || o <= 0 || opts->renumber_map[o] == 0) - val = pdf_new_null(doc); + val = pdf_new_null(ctx, doc); else - val = pdf_new_indirect(doc, opts->renumber_map[o], 0); - pdf_dict_put(obj, key, val); - pdf_drop_obj(val); + val = pdf_new_indirect(ctx, doc, opts->renumber_map[o], 0); + pdf_dict_put(ctx, obj, key, val); + pdf_drop_obj(ctx, val); } else { - renumberobj(doc, opts, val); + renumberobj(ctx, doc, opts, val); } } } - else if (pdf_is_array(obj)) + else if (pdf_is_array(ctx, obj)) { - int n = pdf_array_len(obj); + int n = pdf_array_len(ctx, obj); for (i = 0; i < n; i++) { - pdf_obj *val = pdf_array_get(obj, i); - if (pdf_is_indirect(val)) + pdf_obj *val = pdf_array_get(ctx, obj, i); + if (pdf_is_indirect(ctx, val)) { - int o = pdf_to_num(val); + int o = pdf_to_num(ctx, val); if (o >= xref_len || o <= 0 || opts->renumber_map[o] == 0) - val = pdf_new_null(doc); + val = pdf_new_null(ctx, doc); else - val = pdf_new_indirect(doc, opts->renumber_map[o], 0); - pdf_array_put(obj, i, val); - pdf_drop_obj(val); + val = pdf_new_indirect(ctx, doc, opts->renumber_map[o], 0); + pdf_array_put(ctx, obj, i, val); + pdf_drop_obj(ctx, val); } else { - renumberobj(doc, opts, val); + renumberobj(ctx, doc, opts, val); } } } } -static void renumberobjs(pdf_document *doc, pdf_write_options *opts) +static void renumberobjs(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { pdf_xref_entry *newxref = NULL; int newlen; int num; - fz_context *ctx = doc->ctx; int *new_use_list; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); - new_use_list = fz_calloc(ctx, pdf_xref_len(doc)+3, sizeof(int)); + new_use_list = fz_calloc(ctx, pdf_xref_len(ctx, doc)+3, sizeof(int)); fz_var(newxref); fz_try(ctx) { /* Apply renumber map to indirect references in all objects in xref */ - renumberobj(doc, opts, pdf_trailer(doc)); + renumberobj(ctx, doc, opts, pdf_trailer(ctx, doc)); for (num = 0; num < xref_len; num++) { pdf_obj *obj; @@ -787,23 +784,23 @@ static void renumberobjs(pdf_document *doc, pdf_write_options *opts) if (to == 0) continue; - obj = pdf_get_xref_entry(doc, num)->obj; + obj = pdf_get_xref_entry(ctx, doc, num)->obj; - if (pdf_is_indirect(obj)) + if (pdf_is_indirect(ctx, obj)) { - obj = pdf_new_indirect(doc, to, 0); - pdf_update_object(doc, num, obj); - pdf_drop_obj(obj); + obj = pdf_new_indirect(ctx, doc, to, 0); + pdf_update_object(ctx, doc, num, obj); + pdf_drop_obj(ctx, obj); } else { - renumberobj(doc, opts, obj); + renumberobj(ctx, doc, opts, obj); } } /* Create new table for the reordered, compacted xref */ newxref = fz_malloc_array(ctx, xref_len + 3, sizeof(pdf_xref_entry)); - newxref[0] = *pdf_get_xref_entry(doc, 0); + newxref[0] = *pdf_get_xref_entry(ctx, doc, 0); /* Move used objects into the new compacted xref */ newlen = 0; @@ -814,24 +811,24 @@ static void renumberobjs(pdf_document *doc, pdf_write_options *opts) pdf_xref_entry *e; if (newlen < opts->renumber_map[num]) newlen = opts->renumber_map[num]; - e = pdf_get_xref_entry(doc, num); + e = pdf_get_xref_entry(ctx, doc, num); newxref[opts->renumber_map[num]] = *e; if (e->obj) { - pdf_set_obj_parent(e->obj, opts->renumber_map[num]); + pdf_set_obj_parent(ctx, e->obj, opts->renumber_map[num]); e->obj = NULL; } new_use_list[opts->renumber_map[num]] = opts->use_list[num]; } else { - pdf_xref_entry *e = pdf_get_xref_entry(doc, num); - pdf_drop_obj(e->obj); + pdf_xref_entry *e = pdf_get_xref_entry(ctx, doc, num); + pdf_drop_obj(ctx, e->obj); e->obj = NULL; } } - pdf_replace_xref(doc, newxref, newlen + 1); + pdf_replace_xref(ctx, doc, newxref, newlen + 1); newxref = NULL; } fz_catch(ctx) @@ -865,18 +862,17 @@ static void page_objects_list_renumber(pdf_write_options *opts) } static void -mark_all(pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int flag, int page) +mark_all(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int flag, int page) { - fz_context *ctx = doc->ctx; - if (pdf_mark_obj(val)) + if (pdf_mark_obj(ctx, val)) return; fz_try(ctx) { - if (pdf_is_indirect(val)) + if (pdf_is_indirect(ctx, val)) { - int num = pdf_to_num(val); + int num = pdf_to_num(ctx, val); if (opts->use_list[num] & USE_PAGE_MASK) /* Already used */ opts->use_list[num] |= USE_SHARED; @@ -886,28 +882,28 @@ mark_all(pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int flag, int page_objects_list_insert(ctx, opts, page, num); } - if (pdf_is_dict(val)) + if (pdf_is_dict(ctx, val)) { - int i, n = pdf_dict_len(val); + int i, n = pdf_dict_len(ctx, val); for (i = 0; i < n; i++) { - mark_all(doc, opts, pdf_dict_get_val(val, i), flag, page); + mark_all(ctx, doc, opts, pdf_dict_get_val(ctx, val, i), flag, page); } } - else if (pdf_is_array(val)) + else if (pdf_is_array(ctx, val)) { - int i, n = pdf_array_len(val); + int i, n = pdf_array_len(ctx, val); for (i = 0; i < n; i++) { - mark_all(doc, opts, pdf_array_get(val, i), flag, page); + mark_all(ctx, doc, opts, pdf_array_get(ctx, val, i), flag, page); } } } fz_always(ctx) { - pdf_unmark_obj(val); + pdf_unmark_obj(ctx, val); } fz_catch(ctx) { @@ -916,66 +912,65 @@ mark_all(pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int flag, int } static int -mark_pages(pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int pagenum) +mark_pages(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int pagenum) { - fz_context *ctx = doc->ctx; - if (pdf_mark_obj(val)) + if (pdf_mark_obj(ctx, val)) return pagenum; fz_try(ctx) { - if (pdf_is_dict(val)) + if (pdf_is_dict(ctx, val)) { - if (!strcmp("Page", pdf_to_name(pdf_dict_gets(val, "Type")))) + if (!strcmp("Page", pdf_to_name(ctx, pdf_dict_gets(ctx, val, "Type")))) { - int num = pdf_to_num(val); - pdf_unmark_obj(val); - mark_all(doc, opts, val, pagenum == 0 ? USE_PAGE1 : (pagenum<<USE_PAGE_SHIFT), pagenum); + int num = pdf_to_num(ctx, val); + pdf_unmark_obj(ctx, val); + mark_all(ctx, doc, opts, val, pagenum == 0 ? USE_PAGE1 : (pagenum<<USE_PAGE_SHIFT), pagenum); page_objects_list_set_page_object(ctx, opts, pagenum, num); pagenum++; opts->use_list[num] |= USE_PAGE_OBJECT; } else { - int i, n = pdf_dict_len(val); + int i, n = pdf_dict_len(ctx, val); for (i = 0; i < n; i++) { - pdf_obj *key = pdf_dict_get_key(val, i); - pdf_obj *obj = pdf_dict_get_val(val, i); + pdf_obj *key = pdf_dict_get_key(ctx, val, i); + pdf_obj *obj = pdf_dict_get_val(ctx, val, i); - if (!strcmp("Kids", pdf_to_name(key))) - pagenum = mark_pages(doc, opts, obj, pagenum); + if (!strcmp("Kids", pdf_to_name(ctx, key))) + pagenum = mark_pages(ctx, doc, opts, obj, pagenum); else - mark_all(doc, opts, obj, USE_CATALOGUE, -1); + mark_all(ctx, doc, opts, obj, USE_CATALOGUE, -1); } - if (pdf_is_indirect(val)) + if (pdf_is_indirect(ctx, val)) { - int num = pdf_to_num(val); + int num = pdf_to_num(ctx, val); opts->use_list[num] |= USE_CATALOGUE; } } } - else if (pdf_is_array(val)) + else if (pdf_is_array(ctx, val)) { - int i, n = pdf_array_len(val); + int i, n = pdf_array_len(ctx, val); for (i = 0; i < n; i++) { - pagenum = mark_pages(doc, opts, pdf_array_get(val, i), pagenum); + pagenum = mark_pages(ctx, doc, opts, pdf_array_get(ctx, val, i), pagenum); } - if (pdf_is_indirect(val)) + if (pdf_is_indirect(ctx, val)) { - int num = pdf_to_num(val); + int num = pdf_to_num(ctx, val); opts->use_list[num] |= USE_CATALOGUE; } } } fz_always(ctx) { - pdf_unmark_obj(val); + pdf_unmark_obj(ctx, val); } fz_catch(ctx) { @@ -985,51 +980,50 @@ mark_pages(pdf_document *doc, pdf_write_options *opts, pdf_obj *val, int pagenum } static void -mark_root(pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) +mark_root(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) { - fz_context *ctx = doc->ctx; - int i, n = pdf_dict_len(dict); + int i, n = pdf_dict_len(ctx, dict); - if (pdf_mark_obj(dict)) + if (pdf_mark_obj(ctx, dict)) return; fz_try(ctx) { - if (pdf_is_indirect(dict)) + if (pdf_is_indirect(ctx, dict)) { - int num = pdf_to_num(dict); + int num = pdf_to_num(ctx, dict); opts->use_list[num] |= USE_CATALOGUE; } for (i = 0; i < n; i++) { - char *key = pdf_to_name(pdf_dict_get_key(dict, i)); - pdf_obj *val = pdf_dict_get_val(dict, i); + char *key = pdf_to_name(ctx, pdf_dict_get_key(ctx, dict, i)); + pdf_obj *val = pdf_dict_get_val(ctx, dict, i); if (!strcmp("Pages", key)) - opts->page_count = mark_pages(doc, opts, val, 0); + opts->page_count = mark_pages(ctx, doc, opts, val, 0); else if (!strcmp("Names", key)) - mark_all(doc, opts, val, USE_OTHER_OBJECTS, -1); + mark_all(ctx, doc, opts, val, USE_OTHER_OBJECTS, -1); else if (!strcmp("Dests", key)) - mark_all(doc, opts, val, USE_OTHER_OBJECTS, -1); + mark_all(ctx, doc, opts, val, USE_OTHER_OBJECTS, -1); else if (!strcmp("Outlines", key)) { int section; /* Look at PageMode to decide whether to * USE_OTHER_OBJECTS or USE_PAGE1 here. */ - if (strcmp(pdf_to_name(pdf_dict_gets(dict, "PageMode")), "UseOutlines") == 0) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, dict, "PageMode")), "UseOutlines") == 0) section = USE_PAGE1; else section = USE_OTHER_OBJECTS; - mark_all(doc, opts, val, section, -1); + mark_all(ctx, doc, opts, val, section, -1); } else - mark_all(doc, opts, val, USE_CATALOGUE, -1); + mark_all(ctx, doc, opts, val, USE_CATALOGUE, -1); } } fz_always(ctx) { - pdf_unmark_obj(dict); + pdf_unmark_obj(ctx, dict); } fz_catch(ctx) { @@ -1038,30 +1032,29 @@ mark_root(pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) } static void -mark_trailer(pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) +mark_trailer(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) { - fz_context *ctx = doc->ctx; - int i, n = pdf_dict_len(dict); + int i, n = pdf_dict_len(ctx, dict); - if (pdf_mark_obj(dict)) + if (pdf_mark_obj(ctx, dict)) return; fz_try(ctx) { for (i = 0; i < n; i++) { - char *key = pdf_to_name(pdf_dict_get_key(dict, i)); - pdf_obj *val = pdf_dict_get_val(dict, i); + char *key = pdf_to_name(ctx, pdf_dict_get_key(ctx, dict, i)); + pdf_obj *val = pdf_dict_get_val(ctx, dict, i); if (!strcmp("Root", key)) - mark_root(doc, opts, val); + mark_root(ctx, doc, opts, val); else - mark_all(doc, opts, val, USE_CATALOGUE, -1); + mark_all(ctx, doc, opts, val, USE_CATALOGUE, -1); } } fz_always(ctx) { - pdf_unmark_obj(dict); + pdf_unmark_obj(ctx, dict); } fz_catch(ctx) { @@ -1070,7 +1063,7 @@ mark_trailer(pdf_document *doc, pdf_write_options *opts, pdf_obj *dict) } static void -add_linearization_objs(pdf_document *doc, pdf_write_options *opts) +add_linearization_objs(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { pdf_obj *params_obj = NULL; pdf_obj *params_ref = NULL; @@ -1078,7 +1071,6 @@ add_linearization_objs(pdf_document *doc, pdf_write_options *opts) pdf_obj *hint_ref = NULL; pdf_obj *o = NULL; int params_num, hint_num; - fz_context *ctx = doc->ctx; fz_var(params_obj); fz_var(params_ref); @@ -1089,47 +1081,47 @@ add_linearization_objs(pdf_document *doc, pdf_write_options *opts) fz_try(ctx) { /* Linearization params */ - params_obj = pdf_new_dict(doc, 10); - params_ref = pdf_new_ref(doc, params_obj); - params_num = pdf_to_num(params_ref); + params_obj = pdf_new_dict(ctx, doc, 10); + params_ref = pdf_new_ref(ctx, doc, params_obj); + params_num = pdf_to_num(ctx, params_ref); opts->use_list[params_num] = USE_PARAMS; opts->renumber_map[params_num] = params_num; opts->rev_renumber_map[params_num] = params_num; opts->gen_list[params_num] = 0; opts->rev_gen_list[params_num] = 0; - pdf_dict_puts_drop(params_obj, "Linearized", pdf_new_real(doc, 1.0)); - opts->linear_l = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(params_obj, "L", opts->linear_l); - opts->linear_h0 = pdf_new_int(doc, INT_MIN); - o = pdf_new_array(doc, 2); - pdf_array_push(o, opts->linear_h0); - opts->linear_h1 = pdf_new_int(doc, INT_MIN); - pdf_array_push(o, opts->linear_h1); - pdf_dict_puts_drop(params_obj, "H", o); + pdf_dict_puts_drop(ctx, params_obj, "Linearized", pdf_new_real(ctx, doc, 1.0)); + opts->linear_l = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, params_obj, "L", opts->linear_l); + opts->linear_h0 = pdf_new_int(ctx, doc, INT_MIN); + o = pdf_new_array(ctx, doc, 2); + pdf_array_push(ctx, o, opts->linear_h0); + opts->linear_h1 = pdf_new_int(ctx, doc, INT_MIN); + pdf_array_push(ctx, o, opts->linear_h1); + pdf_dict_puts_drop(ctx, params_obj, "H", o); o = NULL; - opts->linear_o = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(params_obj, "O", opts->linear_o); - opts->linear_e = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(params_obj, "E", opts->linear_e); - opts->linear_n = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(params_obj, "N", opts->linear_n); - opts->linear_t = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(params_obj, "T", opts->linear_t); + opts->linear_o = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, params_obj, "O", opts->linear_o); + opts->linear_e = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, params_obj, "E", opts->linear_e); + opts->linear_n = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, params_obj, "N", opts->linear_n); + opts->linear_t = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, params_obj, "T", opts->linear_t); /* Primary hint stream */ - hint_obj = pdf_new_dict(doc, 10); - hint_ref = pdf_new_ref(doc, hint_obj); - hint_num = pdf_to_num(hint_ref); + hint_obj = pdf_new_dict(ctx, doc, 10); + hint_ref = pdf_new_ref(ctx, doc, hint_obj); + hint_num = pdf_to_num(ctx, hint_ref); opts->use_list[hint_num] = USE_HINTS; opts->renumber_map[hint_num] = hint_num; opts->rev_renumber_map[hint_num] = hint_num; opts->gen_list[hint_num] = 0; opts->rev_gen_list[hint_num] = 0; - pdf_dict_puts_drop(hint_obj, "P", pdf_new_int(doc, 0)); - opts->hints_s = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(hint_obj, "S", opts->hints_s); + pdf_dict_puts_drop(ctx, hint_obj, "P", pdf_new_int(ctx, doc, 0)); + opts->hints_s = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, hint_obj, "S", opts->hints_s); /* FIXME: Do we have thumbnails? Do a T entry */ /* FIXME: Do we have outlines? Do an O entry */ /* FIXME: Do we have article threads? Do an A entry */ @@ -1138,18 +1130,18 @@ add_linearization_objs(pdf_document *doc, pdf_write_options *opts) /* FIXME: Do we have document information? Do an I entry */ /* FIXME: Do we have logical structure heirarchy? Do a C entry */ /* FIXME: Do L, Page Label hint table */ - pdf_dict_puts_drop(hint_obj, "Filter", pdf_new_name(doc, "FlateDecode")); - opts->hints_length = pdf_new_int(doc, INT_MIN); - pdf_dict_puts(hint_obj, "Length", opts->hints_length); - pdf_get_xref_entry(doc, hint_num)->stm_ofs = -1; + pdf_dict_puts_drop(ctx, hint_obj, "Filter", pdf_new_name(ctx, doc, "FlateDecode")); + opts->hints_length = pdf_new_int(ctx, doc, INT_MIN); + pdf_dict_puts(ctx, hint_obj, "Length", opts->hints_length); + pdf_get_xref_entry(ctx, doc, hint_num)->stm_ofs = -1; } fz_always(ctx) { - pdf_drop_obj(params_obj); - pdf_drop_obj(params_ref); - pdf_drop_obj(hint_ref); - pdf_drop_obj(hint_obj); - pdf_drop_obj(o); + pdf_drop_obj(ctx, params_obj); + pdf_drop_obj(ctx, params_ref); + pdf_drop_obj(ctx, hint_ref); + pdf_drop_obj(ctx, hint_obj); + pdf_drop_obj(ctx, o); } fz_catch(ctx) { @@ -1164,39 +1156,39 @@ lpr_inherit_res_contents(fz_context *ctx, pdf_obj *res, pdf_obj *dict, char *tex int i, n; /* If the parent node doesn't have an entry of this type, give up. */ - o = pdf_dict_gets(dict, text); + o = pdf_dict_gets(ctx, dict, text); if (!o) return; /* If the resources dict we are building doesn't have an entry of this * type yet, then just copy it (ensuring it's not a reference) */ - r = pdf_dict_gets(res, text); + r = pdf_dict_gets(ctx, res, text); if (r == NULL) { - o = pdf_resolve_indirect(o); - if (pdf_is_dict(o)) - o = pdf_copy_dict(o); - else if (pdf_is_array(o)) - o = pdf_copy_array(o); + o = pdf_resolve_indirect(ctx, o); + if (pdf_is_dict(ctx, o)) + o = pdf_copy_dict(ctx, o); + else if (pdf_is_array(ctx, o)) + o = pdf_copy_array(ctx, o); else o = NULL; if (o) - pdf_dict_puts(res, text, o); + pdf_dict_puts(ctx, res, text, o); return; } /* Otherwise we need to merge o into r */ - if (pdf_is_dict(o)) + if (pdf_is_dict(ctx, o)) { - n = pdf_dict_len(o); + n = pdf_dict_len(ctx, o); for (i = 0; i < n; i++) { - pdf_obj *key = pdf_dict_get_key(o, i); - pdf_obj *val = pdf_dict_get_val(o, i); + pdf_obj *key = pdf_dict_get_key(ctx, o, i); + pdf_obj *val = pdf_dict_get_val(ctx, o, i); - if (pdf_dict_gets(res, pdf_to_name(key))) + if (pdf_dict_gets(ctx, res, pdf_to_name(ctx, key))) continue; - pdf_dict_puts(res, pdf_to_name(key), val); + pdf_dict_puts(ctx, res, pdf_to_name(ctx, key), val); } } } @@ -1208,12 +1200,12 @@ lpr_inherit_res(fz_context *ctx, pdf_obj *node, int depth, pdf_obj *dict) { pdf_obj *o; - node = pdf_dict_gets(node, "Parent"); + node = pdf_dict_gets(ctx, node, "Parent"); depth--; if (!node || depth < 0) break; - o = pdf_dict_gets(node, "Resources"); + o = pdf_dict_gets(ctx, node, "Resources"); if (o) { lpr_inherit_res_contents(ctx, dict, o, "ExtGState"); @@ -1233,11 +1225,11 @@ lpr_inherit(fz_context *ctx, pdf_obj *node, char *text, int depth) { do { - pdf_obj *o = pdf_dict_gets(node, text); + pdf_obj *o = pdf_dict_gets(ctx, node, text); if (o) - return pdf_resolve_indirect(o); - node = pdf_dict_gets(node, "Parent"); + return pdf_resolve_indirect(ctx, o); + node = pdf_dict_gets(ctx, node, "Parent"); depth--; } while (depth >= 0 && node); @@ -1246,103 +1238,101 @@ lpr_inherit(fz_context *ctx, pdf_obj *node, char *text, int depth) } static int -lpr(pdf_document *doc, pdf_obj *node, int depth, int page) +lpr(fz_context *ctx, pdf_document *doc, pdf_obj *node, int depth, int page) { pdf_obj *kids; pdf_obj *o = NULL; int i, n; - fz_context *ctx = doc->ctx; - if (pdf_mark_obj(node)) + if (pdf_mark_obj(ctx, node)) return page; fz_var(o); fz_try(ctx) { - if (!strcmp("Page", pdf_to_name(pdf_dict_gets(node, "Type")))) + if (!strcmp("Page", pdf_to_name(ctx, pdf_dict_gets(ctx, node, "Type")))) { pdf_obj *r; /* r is deliberately not cleaned up */ /* Copy resources down to the child */ - o = pdf_keep_obj(pdf_dict_gets(node, "Resources")); + o = pdf_keep_obj(ctx, pdf_dict_gets(ctx, node, "Resources")); if (!o) { - o = pdf_keep_obj(pdf_new_dict(doc, 2)); - pdf_dict_puts(node, "Resources", o); + o = pdf_keep_obj(ctx, pdf_new_dict(ctx, doc, 2)); + pdf_dict_puts(ctx, node, "Resources", o); } lpr_inherit_res(ctx, node, depth, o); r = lpr_inherit(ctx, node, "MediaBox", depth); if (r) - pdf_dict_puts(node, "MediaBox", r); + pdf_dict_puts(ctx, node, "MediaBox", r); r = lpr_inherit(ctx, node, "CropBox", depth); if (r) - pdf_dict_puts(node, "CropBox", r); + pdf_dict_puts(ctx, node, "CropBox", r); r = lpr_inherit(ctx, node, "BleedBox", depth); if (r) - pdf_dict_puts(node, "BleedBox", r); + pdf_dict_puts(ctx, node, "BleedBox", r); r = lpr_inherit(ctx, node, "TrimBox", depth); if (r) - pdf_dict_puts(node, "TrimBox", r); + pdf_dict_puts(ctx, node, "TrimBox", r); r = lpr_inherit(ctx, node, "ArtBox", depth); if (r) - pdf_dict_puts(node, "ArtBox", r); + pdf_dict_puts(ctx, node, "ArtBox", r); r = lpr_inherit(ctx, node, "Rotate", depth); if (r) - pdf_dict_puts(node, "Rotate", r); + pdf_dict_puts(ctx, node, "Rotate", r); page++; } else { - kids = pdf_dict_gets(node, "Kids"); - n = pdf_array_len(kids); + kids = pdf_dict_gets(ctx, node, "Kids"); + n = pdf_array_len(ctx, kids); for(i = 0; i < n; i++) { - page = lpr(doc, pdf_array_get(kids, i), depth+1, page); + page = lpr(ctx, doc, pdf_array_get(ctx, kids, i), depth+1, page); } - pdf_dict_dels(node, "Resources"); - pdf_dict_dels(node, "MediaBox"); - pdf_dict_dels(node, "CropBox"); - pdf_dict_dels(node, "BleedBox"); - pdf_dict_dels(node, "TrimBox"); - pdf_dict_dels(node, "ArtBox"); - pdf_dict_dels(node, "Rotate"); + pdf_dict_dels(ctx, node, "Resources"); + pdf_dict_dels(ctx, node, "MediaBox"); + pdf_dict_dels(ctx, node, "CropBox"); + pdf_dict_dels(ctx, node, "BleedBox"); + pdf_dict_dels(ctx, node, "TrimBox"); + pdf_dict_dels(ctx, node, "ArtBox"); + pdf_dict_dels(ctx, node, "Rotate"); } } fz_always(ctx) { - pdf_drop_obj(o); + pdf_drop_obj(ctx, o); } fz_catch(ctx) { fz_rethrow(ctx); } - pdf_unmark_obj(node); + pdf_unmark_obj(ctx, node); return page; } void -pdf_localise_page_resources(pdf_document *doc) +pdf_localise_page_resources(fz_context *ctx, pdf_document *doc) { if (doc->resources_localised) return; - lpr(doc, pdf_dict_getp(pdf_trailer(doc), "Root/Pages"), 0, 0); + lpr(ctx, doc, pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/Pages"), 0, 0); doc->resources_localised = 1; } static void -linearize(pdf_document *doc, pdf_write_options *opts) +linearize(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int i; - int n = pdf_xref_len(doc) + 2; + int n = pdf_xref_len(ctx, doc) + 2; int *reorder; int *rev_renumber_map; int *rev_gen_list; - fz_context *ctx = doc->ctx; opts->page_object_lists = page_objects_list_create(ctx); @@ -1350,18 +1340,18 @@ linearize(pdf_document *doc, pdf_write_options *opts) /* FIXME: We could 'thin' the resources according to what is actually * required for each page, but this would require us to run the page * content streams. */ - pdf_localise_page_resources(doc); + pdf_localise_page_resources(ctx, doc); /* Walk the objects for each page, marking which ones are used, where */ memset(opts->use_list, 0, n * sizeof(int)); - mark_trailer(doc, opts, pdf_trailer(doc)); + mark_trailer(ctx, doc, opts, pdf_trailer(ctx, doc)); /* Add new objects required for linearization */ - add_linearization_objs(doc, opts); + add_linearization_objs(ctx, doc, opts); #ifdef DEBUG_WRITING fprintf(stderr, "Usage calculated:\n"); - for (i=0; i < pdf_xref_len(doc); i++) + for (i=0; i < pdf_xref_len(ctx, doc); i++) { fprintf(stderr, "%d: use=%d\n", i, opts->use_list[i]); } @@ -1381,7 +1371,7 @@ linearize(pdf_document *doc, pdf_write_options *opts) #ifdef DEBUG_WRITING fprintf(stderr, "Reordered:\n"); - for (i=1; i < pdf_xref_len(doc); i++) + for (i=1; i < pdf_xref_len(ctx, doc); i++) { fprintf(stderr, "%d: use=%d\n", i, opts->use_list[reorder[i]]); } @@ -1406,55 +1396,55 @@ linearize(pdf_document *doc, pdf_write_options *opts) /* Apply the renumber_map */ page_objects_list_renumber(opts); - renumberobjs(doc, opts); + renumberobjs(ctx, doc, opts); page_objects_list_sort_and_dedupe(ctx, opts->page_object_lists); } static void -update_linearization_params(pdf_document *doc, pdf_write_options *opts) +update_linearization_params(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int offset; - pdf_set_int(opts->linear_l, opts->file_len); + pdf_set_int(ctx, opts->linear_l, opts->file_len); /* Primary hint stream offset (of object, not stream!) */ - pdf_set_int(opts->linear_h0, opts->ofs_list[pdf_xref_len(doc)-1]); + pdf_set_int(ctx, opts->linear_h0, opts->ofs_list[pdf_xref_len(ctx, doc)-1]); /* Primary hint stream length (of object, not stream!) */ offset = (opts->start == 1 ? opts->main_xref_offset : opts->ofs_list[1] + opts->hintstream_len); - pdf_set_int(opts->linear_h1, offset - opts->ofs_list[pdf_xref_len(doc)-1]); + pdf_set_int(ctx, opts->linear_h1, offset - opts->ofs_list[pdf_xref_len(ctx, doc)-1]); /* Object number of first pages page object (the first object of page 0) */ - pdf_set_int(opts->linear_o, opts->page_object_lists->page[0]->object[0]); + pdf_set_int(ctx, opts->linear_o, opts->page_object_lists->page[0]->object[0]); /* Offset of end of first page (first page is followed by primary * hint stream (object n-1) then remaining pages (object 1...). The * primary hint stream counts as part of the first pages data, I think. */ offset = (opts->start == 1 ? opts->main_xref_offset : opts->ofs_list[1] + opts->hintstream_len); - pdf_set_int(opts->linear_e, offset); + pdf_set_int(ctx, opts->linear_e, offset); /* Number of pages in document */ - pdf_set_int(opts->linear_n, opts->page_count); + pdf_set_int(ctx, opts->linear_n, opts->page_count); /* Offset of first entry in main xref table */ - pdf_set_int(opts->linear_t, opts->first_xref_entry_offset + opts->hintstream_len); + pdf_set_int(ctx, opts->linear_t, opts->first_xref_entry_offset + opts->hintstream_len); /* Offset of shared objects hint table in the primary hint stream */ - pdf_set_int(opts->hints_s, opts->hints_shared_offset); + pdf_set_int(ctx, opts->hints_s, opts->hints_shared_offset); /* Primary hint stream length */ - pdf_set_int(opts->hints_length, opts->hintstream_len); + pdf_set_int(ctx, opts->hints_length, opts->hintstream_len); } /* * Make sure we have loaded objects from object streams. */ -static void preloadobjstms(pdf_document *doc) +static void preloadobjstms(fz_context *ctx, pdf_document *doc) { pdf_obj *obj; int num; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); for (num = 0; num < xref_len; num++) { - if (pdf_get_xref_entry(doc, num)->type == 'o') + if (pdf_get_xref_entry(ctx, doc, num)->type == 'o') { - obj = pdf_load_object(doc, num, 0); - pdf_drop_obj(obj); + obj = pdf_load_object(ctx, doc, num, 0); + pdf_drop_obj(ctx, obj); } } } @@ -1505,103 +1495,101 @@ static fz_buffer *hexbuf(fz_context *ctx, unsigned char *p, int n) return buf; } -static void addhexfilter(pdf_document *doc, pdf_obj *dict) +static void addhexfilter(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { pdf_obj *f, *dp, *newf, *newdp; pdf_obj *ahx, *nullobj; - ahx = pdf_new_name(doc, "ASCIIHexDecode"); - nullobj = pdf_new_null(doc); + ahx = pdf_new_name(ctx, doc, "ASCIIHexDecode"); + nullobj = pdf_new_null(ctx, doc); newf = newdp = NULL; - f = pdf_dict_gets(dict, "Filter"); - dp = pdf_dict_gets(dict, "DecodeParms"); + f = pdf_dict_gets(ctx, dict, "Filter"); + dp = pdf_dict_gets(ctx, dict, "DecodeParms"); - if (pdf_is_name(f)) + if (pdf_is_name(ctx, f)) { - newf = pdf_new_array(doc, 2); - pdf_array_push(newf, ahx); - pdf_array_push(newf, f); + newf = pdf_new_array(ctx, doc, 2); + pdf_array_push(ctx, newf, ahx); + pdf_array_push(ctx, newf, f); f = newf; - if (pdf_is_dict(dp)) + if (pdf_is_dict(ctx, dp)) { - newdp = pdf_new_array(doc, 2); - pdf_array_push(newdp, nullobj); - pdf_array_push(newdp, dp); + newdp = pdf_new_array(ctx, doc, 2); + pdf_array_push(ctx, newdp, nullobj); + pdf_array_push(ctx, newdp, dp); dp = newdp; } } - else if (pdf_is_array(f)) + else if (pdf_is_array(ctx, f)) { - pdf_array_insert(f, ahx, 0); - if (pdf_is_array(dp)) - pdf_array_insert(dp, nullobj, 0); + pdf_array_insert(ctx, f, ahx, 0); + if (pdf_is_array(ctx, dp)) + pdf_array_insert(ctx, dp, nullobj, 0); } else f = ahx; - pdf_dict_puts(dict, "Filter", f); + pdf_dict_puts(ctx, dict, "Filter", f); if (dp) - pdf_dict_puts(dict, "DecodeParms", dp); + pdf_dict_puts(ctx, dict, "DecodeParms", dp); - pdf_drop_obj(ahx); - pdf_drop_obj(nullobj); - pdf_drop_obj(newf); - pdf_drop_obj(newdp); + pdf_drop_obj(ctx, ahx); + pdf_drop_obj(ctx, nullobj); + pdf_drop_obj(ctx, newf); + pdf_drop_obj(ctx, newdp); } -static void copystream(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj_orig, int num, int gen) +static void copystream(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *obj_orig, int num, int gen) { fz_buffer *buf, *tmp; pdf_obj *newlen; pdf_obj *obj; - fz_context *ctx = doc->ctx; int orig_num = opts->rev_renumber_map[num]; int orig_gen = opts->rev_gen_list[num]; - buf = pdf_load_raw_renumbered_stream(doc, num, gen, orig_num, orig_gen); + buf = pdf_load_raw_renumbered_stream(ctx, doc, num, gen, orig_num, orig_gen); - obj = pdf_copy_dict(obj_orig); + obj = pdf_copy_dict(ctx, obj_orig); if (opts->do_ascii && isbinarystream(buf)) { tmp = hexbuf(ctx, buf->data, buf->len); fz_drop_buffer(ctx, buf); buf = tmp; - addhexfilter(doc, obj); + addhexfilter(ctx, doc, obj); - newlen = pdf_new_int(doc, buf->len); - pdf_dict_puts(obj, "Length", newlen); - pdf_drop_obj(newlen); + newlen = pdf_new_int(ctx, doc, buf->len); + pdf_dict_puts(ctx, obj, "Length", newlen); + pdf_drop_obj(ctx, newlen); } fprintf(opts->out, "%d %d obj\n", num, gen); - pdf_fprint_obj(opts->out, obj, opts->do_expand == 0); + pdf_fprint_obj(ctx, opts->out, obj, opts->do_expand == 0); fprintf(opts->out, "stream\n"); fwrite(buf->data, 1, buf->len, opts->out); fprintf(opts->out, "endstream\nendobj\n\n"); fz_drop_buffer(ctx, buf); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } -static void expandstream(pdf_document *doc, pdf_write_options *opts, pdf_obj *obj_orig, int num, int gen) +static void expandstream(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *obj_orig, int num, int gen) { fz_buffer *buf, *tmp; pdf_obj *newlen; pdf_obj *obj; - fz_context *ctx = doc->ctx; int orig_num = opts->rev_renumber_map[num]; int orig_gen = opts->rev_gen_list[num]; int truncated = 0; - buf = pdf_load_renumbered_stream(doc, num, gen, orig_num, orig_gen, (opts->continue_on_error ? &truncated : NULL)); + buf = pdf_load_renumbered_stream(ctx, doc, num, gen, orig_num, orig_gen, (opts->continue_on_error ? &truncated : NULL)); if (truncated && opts->errors) (*opts->errors)++; - obj = pdf_copy_dict(obj_orig); - pdf_dict_dels(obj, "Filter"); - pdf_dict_dels(obj, "DecodeParms"); + obj = pdf_copy_dict(ctx, obj_orig); + pdf_dict_dels(ctx, obj, "Filter"); + pdf_dict_dels(ctx, obj, "DecodeParms"); if (opts->do_ascii && isbinarystream(buf)) { @@ -1609,21 +1597,21 @@ static void expandstream(pdf_document *doc, pdf_write_options *opts, pdf_obj *ob fz_drop_buffer(ctx, buf); buf = tmp; - addhexfilter(doc, obj); + addhexfilter(ctx, doc, obj); } - newlen = pdf_new_int(doc, buf->len); - pdf_dict_puts(obj, "Length", newlen); - pdf_drop_obj(newlen); + newlen = pdf_new_int(ctx, doc, buf->len); + pdf_dict_puts(ctx, obj, "Length", newlen); + pdf_drop_obj(ctx, newlen); fprintf(opts->out, "%d %d obj\n", num, gen); - pdf_fprint_obj(opts->out, obj, opts->do_expand == 0); + pdf_fprint_obj(ctx, opts->out, obj, opts->do_expand == 0); fprintf(opts->out, "stream\n"); fwrite(buf->data, 1, buf->len, opts->out); fprintf(opts->out, "endstream\nendobj\n\n"); fz_drop_buffer(ctx, buf); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } static int is_image_filter(char *s) @@ -1637,33 +1625,32 @@ static int is_image_filter(char *s) return 0; } -static int filter_implies_image(pdf_document *doc, pdf_obj *o) +static int filter_implies_image(fz_context *ctx, pdf_document *doc, pdf_obj *o) { if (!o) return 0; - if (pdf_is_name(o)) - return is_image_filter(pdf_to_name(o)); - if (pdf_is_array(o)) + if (pdf_is_name(ctx, o)) + return is_image_filter(pdf_to_name(ctx, o)); + if (pdf_is_array(ctx, o)) { int i, len; - len = pdf_array_len(o); + len = pdf_array_len(ctx, o); for (i = 0; i < len; i++) - if (is_image_filter(pdf_to_name(pdf_array_get(o, i)))) + if (is_image_filter(pdf_to_name(ctx, pdf_array_get(ctx, o, i)))) return 1; } return 0; } -static void writeobject(pdf_document *doc, pdf_write_options *opts, int num, int gen, int skip_xrefs) +static void writeobject(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, int num, int gen, int skip_xrefs) { pdf_xref_entry *entry; pdf_obj *obj; pdf_obj *type; - fz_context *ctx = doc->ctx; fz_try(ctx) { - obj = pdf_load_object(doc, num, gen); + obj = pdf_load_object(ctx, doc, num, gen); } fz_catch(ctx) { @@ -1681,34 +1668,34 @@ static void writeobject(pdf_document *doc, pdf_write_options *opts, int num, int } /* skip ObjStm and XRef objects */ - if (pdf_is_dict(obj)) + if (pdf_is_dict(ctx, obj)) { - type = pdf_dict_gets(obj, "Type"); - if (pdf_is_name(type) && !strcmp(pdf_to_name(type), "ObjStm")) + type = pdf_dict_gets(ctx, obj, "Type"); + if (pdf_is_name(ctx, type) && !strcmp(pdf_to_name(ctx, type), "ObjStm")) { opts->use_list[num] = 0; - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); return; } - if (skip_xrefs && pdf_is_name(type) && !strcmp(pdf_to_name(type), "XRef")) + if (skip_xrefs && pdf_is_name(ctx, type) && !strcmp(pdf_to_name(ctx, type), "XRef")) { opts->use_list[num] = 0; - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); return; } } - entry = pdf_get_xref_entry(doc, num); - if (!pdf_is_stream(doc, num, gen)) + entry = pdf_get_xref_entry(ctx, doc, num); + if (!pdf_is_stream(ctx, doc, num, gen)) { fprintf(opts->out, "%d %d obj\n", num, gen); - pdf_fprint_obj(opts->out, obj, opts->do_expand == 0); + pdf_fprint_obj(ctx, opts->out, obj, opts->do_expand == 0); fprintf(opts->out, "endobj\n\n"); } else if (entry->stm_ofs < 0 && entry->stm_buf == NULL) { fprintf(opts->out, "%d %d obj\n", num, gen); - pdf_fprint_obj(opts->out, obj, opts->do_expand == 0); + pdf_fprint_obj(ctx, opts->out, obj, opts->do_expand == 0); fprintf(opts->out, "stream\nendstream\nendobj\n\n"); } else @@ -1718,34 +1705,34 @@ static void writeobject(pdf_document *doc, pdf_write_options *opts, int num, int { pdf_obj *o; - if ((o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "XObject")) && - (o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "Image"))) + if ((o = pdf_dict_gets(ctx, obj, "Type"), !strcmp(pdf_to_name(ctx, o), "XObject")) && + (o = pdf_dict_gets(ctx, obj, "Subtype"), !strcmp(pdf_to_name(ctx, o), "Image"))) dontexpand = !(opts->do_expand & fz_expand_images); - if (o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "Font")) + if (o = pdf_dict_gets(ctx, obj, "Type"), !strcmp(pdf_to_name(ctx, o), "Font")) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "FontDescriptor")) + if (o = pdf_dict_gets(ctx, obj, "Type"), !strcmp(pdf_to_name(ctx, o), "FontDescriptor")) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (pdf_dict_gets(obj, "Length1") != NULL) + if (pdf_dict_gets(ctx, obj, "Length1") != NULL) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (pdf_dict_gets(obj, "Length2") != NULL) + if (pdf_dict_gets(ctx, obj, "Length2") != NULL) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (pdf_dict_gets(obj, "Length3") != NULL) + if (pdf_dict_gets(ctx, obj, "Length3") != NULL) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "Type1C")) + if (o = pdf_dict_gets(ctx, obj, "Subtype"), !strcmp(pdf_to_name(ctx, o), "Type1C")) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "CIDFontType0C")) + if (o = pdf_dict_gets(ctx, obj, "Subtype"), !strcmp(pdf_to_name(ctx, o), "CIDFontType0C")) dontexpand = !(opts->do_expand & fz_expand_fonts); - if (o = pdf_dict_gets(obj, "Filter"), filter_implies_image(doc, o)) + if (o = pdf_dict_gets(ctx, obj, "Filter"), filter_implies_image(ctx, doc, o)) dontexpand = !(opts->do_expand & fz_expand_images); - if (pdf_dict_gets(obj, "Width") != NULL && pdf_dict_gets(obj, "Height") != NULL) + if (pdf_dict_gets(ctx, obj, "Width") != NULL && pdf_dict_gets(ctx, obj, "Height") != NULL) dontexpand = !(opts->do_expand & fz_expand_images); } fz_try(ctx) { if (opts->do_expand && !dontexpand && !pdf_is_jpx_image(ctx, obj)) - expandstream(doc, opts, obj, num, gen); + expandstream(ctx, doc, opts, obj, num, gen); else - copystream(doc, opts, obj, num, gen); + copystream(ctx, doc, opts, obj, num, gen); } fz_catch(ctx) { @@ -1759,13 +1746,13 @@ static void writeobject(pdf_document *doc, pdf_write_options *opts, int num, int } else { - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); fz_rethrow(ctx); } } } - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } static void writexrefsubsect(pdf_write_options *opts, int from, int to) @@ -1782,12 +1769,11 @@ static void writexrefsubsect(pdf_write_options *opts, int from, int to) } } -static void writexref(pdf_document *doc, pdf_write_options *opts, int from, int to, int first, int main_xref_offset, int startxref) +static void writexref(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, int from, int to, int first, int main_xref_offset, int startxref) { pdf_obj *trailer = NULL; pdf_obj *obj; pdf_obj *nobj = NULL; - fz_context *ctx = doc->ctx; fprintf(opts->out, "xref\n"); opts->first_xref_entry_offset = ftell(opts->out); @@ -1799,11 +1785,11 @@ static void writexref(pdf_document *doc, pdf_write_options *opts, int from, int while (subfrom < to) { - while (subfrom < to && !pdf_xref_is_incremental(doc, subfrom)) + while (subfrom < to && !pdf_xref_is_incremental(ctx, doc, subfrom)) subfrom++; subto = subfrom; - while (subto < to && pdf_xref_is_incremental(doc, subto)) + while (subto < to && pdf_xref_is_incremental(ctx, doc, subto)) subto++; if (subfrom < subto) @@ -1826,46 +1812,46 @@ static void writexref(pdf_document *doc, pdf_write_options *opts, int from, int { if (opts->do_incremental) { - trailer = pdf_keep_obj(pdf_trailer(doc)); - pdf_dict_puts_drop(trailer, "Size", pdf_new_int(doc, pdf_xref_len(doc))); - pdf_dict_puts_drop(trailer, "Prev", pdf_new_int(doc, doc->startxref)); + trailer = pdf_keep_obj(ctx, pdf_trailer(ctx, doc)); + pdf_dict_puts_drop(ctx, trailer, "Size", pdf_new_int(ctx, doc, pdf_xref_len(ctx, doc))); + pdf_dict_puts_drop(ctx, trailer, "Prev", pdf_new_int(ctx, doc, doc->startxref)); doc->startxref = startxref; } else { - trailer = pdf_new_dict(doc, 5); + trailer = pdf_new_dict(ctx, doc, 5); - nobj = pdf_new_int(doc, to); - pdf_dict_puts(trailer, "Size", nobj); - pdf_drop_obj(nobj); + nobj = pdf_new_int(ctx, doc, to); + pdf_dict_puts(ctx, trailer, "Size", nobj); + pdf_drop_obj(ctx, nobj); nobj = NULL; if (first) { - obj = pdf_dict_gets(pdf_trailer(doc), "Info"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Info"); if (obj) - pdf_dict_puts(trailer, "Info", obj); + pdf_dict_puts(ctx, trailer, "Info", obj); - obj = pdf_dict_gets(pdf_trailer(doc), "Root"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); if (obj) - pdf_dict_puts(trailer, "Root", obj); + pdf_dict_puts(ctx, trailer, "Root", obj); - obj = pdf_dict_gets(pdf_trailer(doc), "ID"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "ID"); if (obj) - pdf_dict_puts(trailer, "ID", obj); + pdf_dict_puts(ctx, trailer, "ID", obj); } if (main_xref_offset != 0) { - nobj = pdf_new_int(doc, main_xref_offset); - pdf_dict_puts(trailer, "Prev", nobj); - pdf_drop_obj(nobj); + nobj = pdf_new_int(ctx, doc, main_xref_offset); + pdf_dict_puts(ctx, trailer, "Prev", nobj); + pdf_drop_obj(ctx, nobj); nobj = NULL; } } } fz_always(ctx) { - pdf_drop_obj(nobj); + pdf_drop_obj(ctx, nobj); } fz_catch(ctx) { @@ -1873,36 +1859,35 @@ static void writexref(pdf_document *doc, pdf_write_options *opts, int from, int } fprintf(opts->out, "trailer\n"); - pdf_fprint_obj(opts->out, trailer, opts->do_expand == 0); + pdf_fprint_obj(ctx, opts->out, trailer, opts->do_expand == 0); fprintf(opts->out, "\n"); - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); fprintf(opts->out, "startxref\n%d\n%%%%EOF\n", startxref); doc->has_xref_streams = 0; } -static void writexrefstreamsubsect(pdf_document *doc, pdf_write_options *opts, pdf_obj *index, fz_buffer *fzbuf, int from, int to) +static void writexrefstreamsubsect(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, pdf_obj *index, fz_buffer *fzbuf, int from, int to) { int num; - pdf_array_push_drop(index, pdf_new_int(doc, from)); - pdf_array_push_drop(index, pdf_new_int(doc, to - from)); + pdf_array_push_drop(ctx, index, pdf_new_int(ctx, doc, from)); + pdf_array_push_drop(ctx, index, pdf_new_int(ctx, doc, to - from)); for (num = from; num < to; num++) { - fz_write_buffer_byte(doc->ctx, fzbuf, opts->use_list[num] ? 1 : 0); - fz_write_buffer_byte(doc->ctx, fzbuf, opts->ofs_list[num]>>24); - fz_write_buffer_byte(doc->ctx, fzbuf, opts->ofs_list[num]>>16); - fz_write_buffer_byte(doc->ctx, fzbuf, opts->ofs_list[num]>>8); - fz_write_buffer_byte(doc->ctx, fzbuf, opts->ofs_list[num]); - fz_write_buffer_byte(doc->ctx, fzbuf, opts->gen_list[num]); + fz_write_buffer_byte(ctx, fzbuf, opts->use_list[num] ? 1 : 0); + fz_write_buffer_byte(ctx, fzbuf, opts->ofs_list[num]>>24); + fz_write_buffer_byte(ctx, fzbuf, opts->ofs_list[num]>>16); + fz_write_buffer_byte(ctx, fzbuf, opts->ofs_list[num]>>8); + fz_write_buffer_byte(ctx, fzbuf, opts->ofs_list[num]); + fz_write_buffer_byte(ctx, fzbuf, opts->gen_list[num]); } } -static void writexrefstream(pdf_document *doc, pdf_write_options *opts, int from, int to, int first, int main_xref_offset, int startxref) +static void writexrefstream(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, int from, int to, int first, int main_xref_offset, int startxref) { - fz_context *ctx = doc->ctx; int num; pdf_obj *dict = NULL; pdf_obj *obj; @@ -1915,9 +1900,9 @@ static void writexrefstream(pdf_document *doc, pdf_write_options *opts, int from fz_var(fzbuf); fz_try(ctx) { - num = pdf_create_object(doc); - dict = pdf_new_dict(doc, 6); - pdf_update_object(doc, num, dict); + num = pdf_create_object(ctx, doc); + dict = pdf_new_dict(ctx, doc, 6); + pdf_update_object(ctx, doc, num, dict); opts->first_xref_entry_offset = ftell(opts->out); @@ -1925,49 +1910,49 @@ static void writexrefstream(pdf_document *doc, pdf_write_options *opts, int from if (first) { - obj = pdf_dict_gets(pdf_trailer(doc), "Info"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Info"); if (obj) - pdf_dict_puts(dict, "Info", obj); + pdf_dict_puts(ctx, dict, "Info", obj); - obj = pdf_dict_gets(pdf_trailer(doc), "Root"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); if (obj) - pdf_dict_puts(dict, "Root", obj); + pdf_dict_puts(ctx, dict, "Root", obj); - obj = pdf_dict_gets(pdf_trailer(doc), "ID"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "ID"); if (obj) - pdf_dict_puts(dict, "ID", obj); + pdf_dict_puts(ctx, dict, "ID", obj); if (opts->do_incremental) { - obj = pdf_dict_gets(pdf_trailer(doc), "Encrypt"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Encrypt"); if (obj) - pdf_dict_puts(dict, "Encrypt", obj); + pdf_dict_puts(ctx, dict, "Encrypt", obj); } } - pdf_dict_puts_drop(dict, "Size", pdf_new_int(doc, to)); + pdf_dict_puts_drop(ctx, dict, "Size", pdf_new_int(ctx, doc, to)); if (opts->do_incremental) { - pdf_dict_puts_drop(dict, "Prev", pdf_new_int(doc, doc->startxref)); + pdf_dict_puts_drop(ctx, dict, "Prev", pdf_new_int(ctx, doc, doc->startxref)); doc->startxref = startxref; } else { if (main_xref_offset != 0) - pdf_dict_puts_drop(dict, "Prev", pdf_new_int(doc, main_xref_offset)); + pdf_dict_puts_drop(ctx, dict, "Prev", pdf_new_int(ctx, doc, main_xref_offset)); } - pdf_dict_puts_drop(dict, "Type", pdf_new_name(doc, "XRef")); + pdf_dict_puts_drop(ctx, dict, "Type", pdf_new_name(ctx, doc, "XRef")); - w = pdf_new_array(doc, 3); - pdf_dict_puts(dict, "W", w); - pdf_array_push_drop(w, pdf_new_int(doc, 1)); - pdf_array_push_drop(w, pdf_new_int(doc, 4)); - pdf_array_push_drop(w, pdf_new_int(doc, 1)); + w = pdf_new_array(ctx, doc, 3); + pdf_dict_puts(ctx, dict, "W", w); + pdf_array_push_drop(ctx, w, pdf_new_int(ctx, doc, 1)); + pdf_array_push_drop(ctx, w, pdf_new_int(ctx, doc, 4)); + pdf_array_push_drop(ctx, w, pdf_new_int(ctx, doc, 1)); - index = pdf_new_array(doc, 2); - pdf_dict_puts_drop(dict, "Index", index); + index = pdf_new_array(ctx, doc, 2); + pdf_dict_puts_drop(ctx, dict, "Index", index); opts->ofs_list[num] = opts->first_xref_entry_offset; @@ -1980,34 +1965,34 @@ static void writexrefstream(pdf_document *doc, pdf_write_options *opts, int from while (subfrom < to) { - while (subfrom < to && !pdf_xref_is_incremental(doc, subfrom)) + while (subfrom < to && !pdf_xref_is_incremental(ctx, doc, subfrom)) subfrom++; subto = subfrom; - while (subto < to && pdf_xref_is_incremental(doc, subto)) + while (subto < to && pdf_xref_is_incremental(ctx, doc, subto)) subto++; if (subfrom < subto) - writexrefstreamsubsect(doc, opts, index, fzbuf, subfrom, subto); + writexrefstreamsubsect(ctx, doc, opts, index, fzbuf, subfrom, subto); subfrom = subto; } } else { - writexrefstreamsubsect(doc, opts, index, fzbuf, from, to); + writexrefstreamsubsect(ctx, doc, opts, index, fzbuf, from, to); } - pdf_update_stream(doc, num, fzbuf); - pdf_dict_puts_drop(dict, "Length", pdf_new_int(doc, fz_buffer_storage(ctx, fzbuf, NULL))); + pdf_update_stream(ctx, doc, num, fzbuf); + pdf_dict_puts_drop(ctx, dict, "Length", pdf_new_int(ctx, doc, fz_buffer_storage(ctx, fzbuf, NULL))); - writeobject(doc, opts, num, 0, 0); + writeobject(ctx, doc, opts, num, 0, 0); fprintf(opts->out, "startxref\n%d\n%%%%EOF\n", startxref); } fz_always(ctx) { - pdf_drop_obj(dict); - pdf_drop_obj(w); + pdf_drop_obj(ctx, dict); + pdf_drop_obj(ctx, w); fz_drop_buffer(ctx, fzbuf); } fz_catch(ctx) @@ -2030,9 +2015,9 @@ padto(FILE *file, int target) } static void -dowriteobject(pdf_document *doc, pdf_write_options *opts, int num, int pass) +dowriteobject(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, int num, int pass) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, num); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, num); if (entry->type == 'f') opts->gen_list[num] = entry->gen; if (entry->type == 'n') @@ -2056,18 +2041,18 @@ dowriteobject(pdf_document *doc, pdf_write_options *opts, int num, int pass) if (pass > 0) padto(opts->out, opts->ofs_list[num]); opts->ofs_list[num] = ftell(opts->out); - if (!opts->do_incremental || pdf_xref_is_incremental(doc, num)) - writeobject(doc, opts, num, opts->gen_list[num], 1); + if (!opts->do_incremental || pdf_xref_is_incremental(ctx, doc, num)) + writeobject(ctx, doc, opts, num, opts->gen_list[num], 1); } else opts->use_list[num] = 0; } static void -writeobjects(pdf_document *doc, pdf_write_options *opts, int pass) +writeobjects(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, int pass) { int num; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); if (!opts->do_incremental) { @@ -2075,7 +2060,7 @@ writeobjects(pdf_document *doc, pdf_write_options *opts, int pass) fprintf(opts->out, "%%\316\274\341\277\246\n\n"); } - dowriteobject(doc, opts, opts->start, pass); + dowriteobject(ctx, doc, opts, opts->start, pass); if (opts->do_linear) { @@ -2084,11 +2069,11 @@ writeobjects(pdf_document *doc, pdf_write_options *opts, int pass) opts->first_xref_offset = ftell(opts->out); else padto(opts->out, opts->first_xref_offset); - writexref(doc, opts, opts->start, pdf_xref_len(doc), 1, opts->main_xref_offset, 0); + writexref(ctx, doc, opts, opts->start, pdf_xref_len(ctx, doc), 1, opts->main_xref_offset, 0); } for (num = opts->start+1; num < xref_len; num++) - dowriteobject(doc, opts, num, pass); + dowriteobject(ctx, doc, opts, num, pass); if (opts->do_linear && pass == 1) { int offset = (opts->start == 1 ? opts->main_xref_offset : opts->ofs_list[1] + opts->hintstream_len); @@ -2098,7 +2083,7 @@ writeobjects(pdf_document *doc, pdf_write_options *opts, int pass) { if (pass == 1) opts->ofs_list[num] += opts->hintstream_len; - dowriteobject(doc, opts, num, pass); + dowriteobject(ctx, doc, opts, num, pass); } } @@ -2120,9 +2105,8 @@ my_log2(int x) } static void -make_page_offset_hints(pdf_document *doc, pdf_write_options *opts, fz_buffer *buf) +make_page_offset_hints(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, fz_buffer *buf) { - fz_context *ctx = doc->ctx; int i, j; int min_objs_per_page, max_objs_per_page; int min_page_length, max_page_length; @@ -2133,9 +2117,9 @@ make_page_offset_hints(pdf_document *doc, pdf_write_options *opts, fz_buffer *bu page_objects **pop = &opts->page_object_lists->page[0]; int page_len_bits, shared_object_bits, shared_object_id_bits; int shared_length_bits; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); - min_shared_object = pdf_xref_len(doc); + min_shared_object = pdf_xref_len(ctx, doc); max_shared_object = 1; min_shared_length = opts->file_len; max_shared_length = 0; @@ -2391,15 +2375,14 @@ make_page_offset_hints(pdf_document *doc, pdf_write_options *opts, fz_buffer *bu } static void -make_hint_stream(pdf_document *doc, pdf_write_options *opts) +make_hint_stream(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { - fz_context *ctx = doc->ctx; fz_buffer *buf = fz_new_buffer(ctx, 100); fz_try(ctx) { - make_page_offset_hints(doc, opts, buf); - pdf_update_stream(doc, pdf_xref_len(doc)-1, buf); + make_page_offset_hints(ctx, doc, opts, buf); + pdf_update_stream(ctx, doc, pdf_xref_len(ctx, doc)-1, buf); opts->hintstream_len = buf->len; fz_drop_buffer(ctx, buf); } @@ -2411,18 +2394,18 @@ make_hint_stream(pdf_document *doc, pdf_write_options *opts) } #ifdef DEBUG_WRITING -static void dump_object_details(pdf_document *doc, pdf_write_options *opts) +static void dump_object_details(fz_context *ctx, pdf_document *doc, pdf_write_options *opts) { int i; - for (i = 0; i < pdf_xref_len(doc); i++) + for (i = 0; i < pdf_xref_len(ctx, doc); i++) { fprintf(stderr, "%d@%d: use=%d\n", i, opts->ofs_list[i], opts->use_list[i]); } } #endif -static void presize_unsaved_signature_byteranges(pdf_document *doc) +static void presize_unsaved_signature_byteranges(fz_context *ctx, pdf_document *doc) { if (doc->unsaved_sigs) { @@ -2441,20 +2424,19 @@ static void presize_unsaved_signature_byteranges(pdf_document *doc) * the end and between each consecutive pair of signatures, * hence n + 1 */ int i; - pdf_obj *byte_range = pdf_dict_getp(usig->field, "V/ByteRange"); + pdf_obj *byte_range = pdf_dict_getp(ctx, usig->field, "V/ByteRange"); for (i = 0; i < n+1; i++) { - pdf_array_push_drop(byte_range, pdf_new_int(doc, INT_MAX)); - pdf_array_push_drop(byte_range, pdf_new_int(doc, INT_MAX)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, INT_MAX)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, INT_MAX)); } } } } -static void complete_signatures(pdf_document *doc, pdf_write_options *opts, char *filename) +static void complete_signatures(fz_context *ctx, pdf_document *doc, pdf_write_options *opts, char *filename) { - fz_context *ctx = doc->ctx; pdf_unsaved_sig *usig; FILE *f; char buf[5120]; @@ -2477,7 +2459,7 @@ static void complete_signatures(pdf_document *doc, pdf_write_options *opts, char for (usig = doc->unsaved_sigs; usig; usig = usig->next) { char *bstr, *cstr, *fstr; - int pnum = pdf_obj_parent_num(pdf_dict_getp(usig->field, "V/ByteRange")); + int pnum = pdf_obj_parent_num(ctx, pdf_dict_getp(ctx, usig->field, "V/ByteRange")); fseek(f, opts->ofs_list[pnum], SEEK_SET); (void)fread(buf, 1, sizeof(buf), f); buf[sizeof(buf)-1] = 0; @@ -2497,25 +2479,25 @@ static void complete_signatures(pdf_document *doc, pdf_write_options *opts, char /* Recreate ByteRange with correct values. Initially store the * recreated object in the first of the unsaved signatures */ - byte_range = pdf_new_array(doc, 4); - pdf_dict_putp_drop(doc->unsaved_sigs->field, "V/ByteRange", byte_range); + byte_range = pdf_new_array(ctx, doc, 4); + pdf_dict_putp_drop(ctx, doc->unsaved_sigs->field, "V/ByteRange", byte_range); last_end = 0; for (usig = doc->unsaved_sigs; usig; usig = usig->next) { - pdf_array_push_drop(byte_range, pdf_new_int(doc, last_end)); - pdf_array_push_drop(byte_range, pdf_new_int(doc, usig->contents_start - last_end)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, last_end)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, usig->contents_start - last_end)); last_end = usig->contents_end; } - pdf_array_push_drop(byte_range, pdf_new_int(doc, last_end)); - pdf_array_push_drop(byte_range, pdf_new_int(doc, flen - last_end)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, last_end)); + pdf_array_push_drop(ctx, byte_range, pdf_new_int(ctx, doc, flen - last_end)); /* Copy the new ByteRange to the other unsaved signatures */ for (usig = doc->unsaved_sigs->next; usig; usig = usig->next) - pdf_dict_putp_drop(usig->field, "V/ByteRange", pdf_copy_array(byte_range)); + pdf_dict_putp_drop(ctx, usig->field, "V/ByteRange", pdf_copy_array(ctx, byte_range)); /* Write the byte range into buf, padding with spaces*/ - i = pdf_sprint_obj(buf, sizeof(buf), byte_range, 1); + i = pdf_sprint_obj(ctx, buf, sizeof(buf), byte_range, 1); memset(buf+i, ' ', sizeof(buf)-i); /* Write the byte range to the file */ @@ -2529,60 +2511,59 @@ static void complete_signatures(pdf_document *doc, pdf_write_options *opts, char /* Write the digests into the file */ for (usig = doc->unsaved_sigs; usig; usig = usig->next) - pdf_write_digest(doc, filename, byte_range, usig->contents_start, usig->contents_end - usig->contents_start, usig->signer); + pdf_write_digest(ctx, doc, filename, byte_range, usig->contents_start, usig->contents_end - usig->contents_start, usig->signer); /* delete the unsaved_sigs records */ while ((usig = doc->unsaved_sigs) != NULL) { doc->unsaved_sigs = usig->next; - pdf_drop_obj(usig->field); - pdf_drop_signer(usig->signer); + pdf_drop_obj(ctx, usig->field); + pdf_drop_signer(ctx, usig->signer); fz_free(ctx, usig); } } } -static void sanitise(pdf_document *doc) +static void sanitise(fz_context *ctx, pdf_document *doc) { - int n = pdf_count_pages(doc); + int n = pdf_count_pages(ctx, doc); int i; for (i = 0; i < n; i++) { - pdf_page *page = pdf_load_page(doc, i); + pdf_page *page = pdf_load_page(ctx, doc, i); - pdf_clean_page_contents(doc, page, NULL); + pdf_clean_page_contents(ctx, doc, page, NULL); - pdf_drop_page(doc, page); + fz_drop_page(ctx, &page->super); } } -void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_opts) +void pdf_write_document(fz_context *ctx, pdf_document *doc, char *filename, fz_write_options *fz_opts) { + fz_write_options opts_defaults = { 0 }; + pdf_write_options opts = { 0 }; + int lastfree; int num; - pdf_write_options opts = { 0 }; - fz_context *ctx; int xref_len; - fz_write_options fz_opts_defaults = { 0 }; if (!doc) return; if (!fz_opts) - fz_opts = &fz_opts_defaults; + fz_opts = &opts_defaults; doc->freeze_updates = 1; - ctx = doc->ctx; /* Sanitise the operator streams */ if (fz_opts->do_clean) - sanitise(doc); + sanitise(ctx, doc); - pdf_finish_edit(doc); - presize_unsaved_signature_byteranges(doc); + pdf_finish_edit(ctx, doc); + presize_unsaved_signature_byteranges(ctx, doc); - xref_len = pdf_xref_len(doc); + xref_len = pdf_xref_len(ctx, doc); if (fz_opts->do_incremental) { @@ -2614,12 +2595,12 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ /* We deliberately make these arrays long enough to cope with * 1 to n access rather than 0..n-1, and add space for 2 new * extra entries that may be required for linearization. */ - opts.use_list = fz_malloc_array(ctx, pdf_xref_len(doc) + 3, sizeof(int)); - opts.ofs_list = fz_malloc_array(ctx, pdf_xref_len(doc) + 3, sizeof(int)); - opts.gen_list = fz_calloc(ctx, pdf_xref_len(doc) + 3, sizeof(int)); - opts.renumber_map = fz_malloc_array(ctx, pdf_xref_len(doc) + 3, sizeof(int)); - opts.rev_renumber_map = fz_malloc_array(ctx, pdf_xref_len(doc) + 3, sizeof(int)); - opts.rev_gen_list = fz_malloc_array(ctx, pdf_xref_len(doc) + 3, sizeof(int)); + opts.use_list = fz_malloc_array(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); + opts.ofs_list = fz_malloc_array(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); + opts.gen_list = fz_calloc(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); + opts.renumber_map = fz_malloc_array(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); + opts.rev_renumber_map = fz_malloc_array(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); + opts.rev_gen_list = fz_malloc_array(ctx, pdf_xref_len(ctx, doc) + 3, sizeof(int)); opts.continue_on_error = fz_opts->continue_on_error; opts.errors = fz_opts->errors; @@ -2629,7 +2610,7 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ opts.ofs_list[num] = 0; opts.renumber_map[num] = num; opts.rev_renumber_map[num] = num; - opts.rev_gen_list[num] = pdf_get_xref_entry(doc, num)->gen; + opts.rev_gen_list[num] = pdf_get_xref_entry(ctx, doc, num)->gen; } if (opts.do_incremental && opts.do_garbage) @@ -2640,28 +2621,28 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ /* Make sure any objects hidden in compressed streams have been loaded */ if (!opts.do_incremental) { - pdf_ensure_solid_xref(doc, xref_len); - preloadobjstms(doc); + pdf_ensure_solid_xref(ctx, doc, xref_len); + preloadobjstms(ctx, doc); } /* Sweep & mark objects from the trailer */ if (opts.do_garbage >= 1) - sweepobj(doc, &opts, pdf_trailer(doc)); + sweepobj(ctx, doc, &opts, pdf_trailer(ctx, doc)); else for (num = 0; num < xref_len; num++) opts.use_list[num] = 1; /* Coalesce and renumber duplicate objects */ if (opts.do_garbage >= 3) - removeduplicateobjs(doc, &opts); + removeduplicateobjs(ctx, doc, &opts); /* Compact xref by renumbering and removing unused objects */ if (opts.do_garbage >= 2 || opts.do_linear) - compactxref(doc, &opts); + compactxref(ctx, doc, &opts); /* Make renumbering affect all indirect references and update xref */ if (opts.do_garbage >= 2 || opts.do_linear) - renumberobjs(doc, &opts); + renumberobjs(ctx, doc, &opts); /* Truncate the xref after compacting and renumbering */ if (opts.do_garbage >= 2 && !opts.do_incremental) @@ -2670,20 +2651,20 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ if (opts.do_linear) { - linearize(doc, &opts); + linearize(ctx, doc, &opts); } - writeobjects(doc, &opts, 0); + writeobjects(ctx, doc, &opts, 0); #ifdef DEBUG_WRITING - dump_object_details(doc, &opts); + dump_object_details(ctx, doc, &opts); #endif if (opts.do_incremental) { for (num = 0; num < xref_len; num++) { - if (!opts.use_list[num] && pdf_xref_is_incremental(doc, num)) + if (!opts.use_list[num] && pdf_xref_is_incremental(ctx, doc, num)) { /* Make unreusable. FIXME: would be better to link to existing free list */ opts.gen_list[num] = 65535; @@ -2709,31 +2690,31 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ if (opts.do_linear) { opts.main_xref_offset = ftell(opts.out); - writexref(doc, &opts, 0, opts.start, 0, 0, opts.first_xref_offset); + writexref(ctx, doc, &opts, 0, opts.start, 0, 0, opts.first_xref_offset); opts.file_len = ftell(opts.out); - make_hint_stream(doc, &opts); + make_hint_stream(ctx, doc, &opts); opts.file_len += opts.hintstream_len; opts.main_xref_offset += opts.hintstream_len; - update_linearization_params(doc, &opts); + update_linearization_params(ctx, doc, &opts); fseek(opts.out, 0, 0); - writeobjects(doc, &opts, 1); + writeobjects(ctx, doc, &opts, 1); padto(opts.out, opts.main_xref_offset); - writexref(doc, &opts, 0, opts.start, 0, 0, opts.first_xref_offset); + writexref(ctx, doc, &opts, 0, opts.start, 0, 0, opts.first_xref_offset); } else { opts.first_xref_offset = ftell(opts.out); if (opts.do_incremental && doc->has_xref_streams) - writexrefstream(doc, &opts, 0, xref_len, 1, 0, opts.first_xref_offset); + writexrefstream(ctx, doc, &opts, 0, xref_len, 1, 0, opts.first_xref_offset); else - writexref(doc, &opts, 0, xref_len, 1, 0, opts.first_xref_offset); + writexref(ctx, doc, &opts, 0, xref_len, 1, 0, opts.first_xref_offset); } fclose(opts.out); opts.out = NULL; - complete_signatures(doc, &opts, filename); + complete_signatures(ctx, doc, &opts, filename); doc->dirty = 0; } @@ -2741,7 +2722,7 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ { #ifdef DEBUG_LINEARIZATION page_objects_dump(&opts); - objects_dump(doc, &opts); + objects_dump(ctx, doc, &opts); #endif fz_free(ctx, opts.use_list); fz_free(ctx, opts.ofs_list); @@ -2749,15 +2730,15 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ fz_free(ctx, opts.renumber_map); fz_free(ctx, opts.rev_renumber_map); fz_free(ctx, opts.rev_gen_list); - pdf_drop_obj(opts.linear_l); - pdf_drop_obj(opts.linear_h0); - pdf_drop_obj(opts.linear_h1); - pdf_drop_obj(opts.linear_o); - pdf_drop_obj(opts.linear_e); - pdf_drop_obj(opts.linear_n); - pdf_drop_obj(opts.linear_t); - pdf_drop_obj(opts.hints_s); - pdf_drop_obj(opts.hints_length); + pdf_drop_obj(ctx, opts.linear_l); + pdf_drop_obj(ctx, opts.linear_h0); + pdf_drop_obj(ctx, opts.linear_h1); + pdf_drop_obj(ctx, opts.linear_o); + pdf_drop_obj(ctx, opts.linear_e); + pdf_drop_obj(ctx, opts.linear_n); + pdf_drop_obj(ctx, opts.linear_t); + pdf_drop_obj(ctx, opts.hints_s); + pdf_drop_obj(ctx, opts.hints_length); page_objects_list_destroy(ctx, opts.page_object_lists); if (opts.out) fclose(opts.out); @@ -2773,12 +2754,11 @@ void pdf_write_document(pdf_document *doc, char *filename, fz_write_options *fz_ #if 0 -// TODO: pdf_rebalance_page_tree(doc); +// TODO: pdf_rebalance_page_tree(ctx, doc); static pdf_obj * -make_page_tree_node(pdf_document *doc, int l, int r, pdf_obj *parent_ref, int root) +make_page_tree_node(fz_context *ctx, pdf_document *doc, int l, int r, pdf_obj *parent_ref, int root) { - fz_context *ctx = doc->ctx; int count_per_kid, spaces; pdf_obj *a = NULL; pdf_obj *me = NULL; @@ -2796,52 +2776,52 @@ make_page_tree_node(pdf_document *doc, int l, int r, pdf_obj *parent_ref, int ro fz_try(ctx) { - me = pdf_new_dict(doc, 2); - pdf_dict_puts_drop(me, "Type", pdf_new_name(doc, "Pages")); - pdf_dict_puts_drop(me, "Count", pdf_new_int(doc, r-l)); + me = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts_drop(ctx, me, "Type", pdf_new_name(ctx, doc, "Pages")); + pdf_dict_puts_drop(ctx, me, "Count", pdf_new_int(ctx, doc, r-l)); if (!root) - pdf_dict_puts(me, "Parent", parent_ref); - a = pdf_new_array(doc, KIDS_PER_LEVEL); - me_ref = pdf_new_ref(doc, me); + pdf_dict_puts(ctx, me, "Parent", parent_ref); + a = pdf_new_array(ctx, doc, KIDS_PER_LEVEL); + me_ref = pdf_new_ref(ctx, doc, me); for (spaces = KIDS_PER_LEVEL; l < r; spaces--) { if (spaces >= r-l) { - o = pdf_keep_obj(doc->page_refs[l++]); - pdf_dict_puts(o, "Parent", me_ref); + o = pdf_keep_obj(ctx, doc->page_refs[l++]); + pdf_dict_puts(ctx, o, "Parent", me_ref); } else { int j = l+count_per_kid; if (j > r) j = r; - o = make_page_tree_node(doc, l, j, me_ref, 0); + o = make_page_tree_node(ctx, doc, l, j, me_ref, 0); l = j; } - pdf_array_push(a, o); - pdf_drop_obj(o); + pdf_array_push(ctx, a, o); + pdf_drop_obj(ctx, o); o = NULL; } - pdf_dict_puts_drop(me, "Kids", a); + pdf_dict_puts_drop(ctx, me, "Kids", a); a = NULL; } fz_always(ctx) { - pdf_drop_obj(me); + pdf_drop_obj(ctx, me); } fz_catch(ctx) { - pdf_drop_obj(a); - pdf_drop_obj(o); - pdf_drop_obj(me); + pdf_drop_obj(ctx, a); + pdf_drop_obj(ctx, o); + pdf_drop_obj(ctx, me); fz_rethrow_message(ctx, "Failed to synthesize new page tree"); } return me_ref; } static void -pdf_rebalance_page_tree(pdf_document *doc) +pdf_rebalance_page_tree(fz_context *ctx, pdf_document *doc) { pdf_obj *catalog; pdf_obj *pages; @@ -2849,9 +2829,9 @@ pdf_rebalance_page_tree(pdf_document *doc) if (!doc || !doc->needs_page_tree_rebuild) return; - catalog = pdf_dict_gets(pdf_trailer(doc), "Root"); - pages = make_page_tree_node(doc, 0, doc->page_len, catalog, 1); - pdf_dict_puts_drop(catalog, "Pages", pages); + catalog = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pages = make_page_tree_node(ctx, doc, 0, doc->page_len, catalog, 1); + pdf_dict_puts_drop(ctx, catalog, "Pages", pages); doc->needs_page_tree_rebuild = 0; } @@ -2859,13 +2839,13 @@ pdf_rebalance_page_tree(pdf_document *doc) #endif static void -pdf_rebalance_page_tree(pdf_document *doc) +pdf_rebalance_page_tree(fz_context *ctx, pdf_document *doc) { } -void pdf_finish_edit(pdf_document *doc) +void pdf_finish_edit(fz_context *ctx, pdf_document *doc) { if (!doc) return; - pdf_rebalance_page_tree(doc); + pdf_rebalance_page_tree(ctx, doc); } diff --git a/source/pdf/pdf-xobject.c b/source/pdf/pdf-xobject.c index c350eb0a..e169a27a 100644 --- a/source/pdf/pdf-xobject.c +++ b/source/pdf/pdf-xobject.c @@ -19,9 +19,9 @@ pdf_drop_xobject_imp(fz_context *ctx, fz_storable *xobj_) if (xobj->colorspace) fz_drop_colorspace(ctx, xobj->colorspace); - pdf_drop_obj(xobj->resources); - pdf_drop_obj(xobj->contents); - pdf_drop_obj(xobj->me); + pdf_drop_obj(ctx, xobj->resources); + pdf_drop_obj(ctx, xobj->contents); + pdf_drop_obj(ctx, xobj->me); fz_free(ctx, xobj); } @@ -34,11 +34,10 @@ pdf_xobject_size(pdf_xobject *xobj) } pdf_xobject * -pdf_load_xobject(pdf_document *doc, pdf_obj *dict) +pdf_load_xobject(fz_context *ctx, pdf_document *doc, pdf_obj *dict) { pdf_xobject *form; pdf_obj *obj; - fz_context *ctx = doc->ctx; if ((form = pdf_find_item(ctx, pdf_drop_xobject_imp, dict)) != NULL) { @@ -58,10 +57,10 @@ pdf_load_xobject(pdf_document *doc, pdf_obj *dict) fz_try(ctx) { - obj = pdf_dict_gets(dict, "BBox"); + obj = pdf_dict_gets(ctx, dict, "BBox"); pdf_to_rect(ctx, obj, &form->bbox); - obj = pdf_dict_gets(dict, "Matrix"); + obj = pdf_dict_gets(ctx, dict, "Matrix"); if (obj) pdf_to_matrix(ctx, obj, &form->matrix); else @@ -71,24 +70,24 @@ pdf_load_xobject(pdf_document *doc, pdf_obj *dict) form->knockout = 0; form->transparency = 0; - obj = pdf_dict_gets(dict, "Group"); + obj = pdf_dict_gets(ctx, dict, "Group"); if (obj) { pdf_obj *attrs = obj; - form->isolated = pdf_to_bool(pdf_dict_gets(attrs, "I")); - form->knockout = pdf_to_bool(pdf_dict_gets(attrs, "K")); + form->isolated = pdf_to_bool(ctx, pdf_dict_gets(ctx, attrs, "I")); + form->knockout = pdf_to_bool(ctx, pdf_dict_gets(ctx, attrs, "K")); - obj = pdf_dict_gets(attrs, "S"); - if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Transparency")) + obj = pdf_dict_gets(ctx, attrs, "S"); + if (pdf_is_name(ctx, obj) && !strcmp(pdf_to_name(ctx, obj), "Transparency")) form->transparency = 1; - obj = pdf_dict_gets(attrs, "CS"); + obj = pdf_dict_gets(ctx, attrs, "CS"); if (obj) { fz_try(ctx) { - form->colorspace = pdf_load_colorspace(doc, obj); + form->colorspace = pdf_load_colorspace(ctx, doc, obj); } fz_catch(ctx) { @@ -97,25 +96,25 @@ pdf_load_xobject(pdf_document *doc, pdf_obj *dict) } } - form->resources = pdf_dict_gets(dict, "Resources"); + form->resources = pdf_dict_gets(ctx, dict, "Resources"); if (form->resources) - pdf_keep_obj(form->resources); + pdf_keep_obj(ctx, form->resources); - form->contents = pdf_keep_obj(dict); + form->contents = pdf_keep_obj(ctx, dict); } fz_catch(ctx) { pdf_remove_item(ctx, pdf_drop_xobject_imp, dict); pdf_drop_xobject(ctx, form); - fz_rethrow_message(ctx, "cannot load xobject content stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict)); + fz_rethrow_message(ctx, "cannot load xobject content stream (%d %d R)", pdf_to_num(ctx, dict), pdf_to_gen(ctx, dict)); } - form->me = pdf_keep_obj(dict); + form->me = pdf_keep_obj(ctx, dict); return form; } pdf_obj * -pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) +pdf_new_xobject(fz_context *ctx, pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) { int idict_num; pdf_obj *idict = NULL; @@ -124,7 +123,6 @@ pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) pdf_obj *obj = NULL; pdf_obj *res = NULL; pdf_obj *procset = NULL; - fz_context *ctx = doc->ctx; fz_var(idict); fz_var(dict); @@ -134,51 +132,51 @@ pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) fz_var(procset); fz_try(ctx) { - dict = pdf_new_dict(doc, 0); + dict = pdf_new_dict(ctx, doc, 0); - obj = pdf_new_rect(doc, bbox); - pdf_dict_puts(dict, "BBox", obj); - pdf_drop_obj(obj); + obj = pdf_new_rect(ctx, doc, bbox); + pdf_dict_puts(ctx, dict, "BBox", obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_int(doc, 1); - pdf_dict_puts(dict, "FormType", obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, 1); + pdf_dict_puts(ctx, dict, "FormType", obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_int(doc, 0); - pdf_dict_puts(dict, "Length", obj); - pdf_drop_obj(obj); + obj = pdf_new_int(ctx, doc, 0); + pdf_dict_puts(ctx, dict, "Length", obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_matrix(doc, mat); - pdf_dict_puts(dict, "Matrix", obj); - pdf_drop_obj(obj); + obj = pdf_new_matrix(ctx, doc, mat); + pdf_dict_puts(ctx, dict, "Matrix", obj); + pdf_drop_obj(ctx, obj); obj = NULL; - res = pdf_new_dict(doc, 0); - procset = pdf_new_array(doc, 2); - obj = pdf_new_name(doc, "PDF"); - pdf_array_push(procset, obj); - pdf_drop_obj(obj); + res = pdf_new_dict(ctx, doc, 0); + procset = pdf_new_array(ctx, doc, 2); + obj = pdf_new_name(ctx, doc, "PDF"); + pdf_array_push(ctx, procset, obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_name(doc, "Text"); - pdf_array_push(procset, obj); - pdf_drop_obj(obj); + obj = pdf_new_name(ctx, doc, "Text"); + pdf_array_push(ctx, procset, obj); + pdf_drop_obj(ctx, obj); obj = NULL; - pdf_dict_puts(res, "ProcSet", procset); - pdf_drop_obj(procset); + pdf_dict_puts(ctx, res, "ProcSet", procset); + pdf_drop_obj(ctx, procset); procset = NULL; - pdf_dict_puts(dict, "Resources", res); + pdf_dict_puts(ctx, dict, "Resources", res); - obj = pdf_new_name(doc, "Form"); - pdf_dict_puts(dict, "Subtype", obj); - pdf_drop_obj(obj); + obj = pdf_new_name(ctx, doc, "Form"); + pdf_dict_puts(ctx, dict, "Subtype", obj); + pdf_drop_obj(ctx, obj); obj = NULL; - obj = pdf_new_name(doc, "XObject"); - pdf_dict_puts(dict, "Type", obj); - pdf_drop_obj(obj); + obj = pdf_new_name(ctx, doc, "XObject"); + pdf_dict_puts(ctx, dict, "Type", obj); + pdf_drop_obj(ctx, obj); obj = NULL; form = fz_malloc_struct(ctx, pdf_xobject); @@ -200,27 +198,27 @@ pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) form->resources = res; res = NULL; - idict_num = pdf_create_object(doc); - pdf_update_object(doc, idict_num, dict); - idict = pdf_new_indirect(doc, idict_num, 0); - pdf_drop_obj(dict); + idict_num = pdf_create_object(ctx, doc); + pdf_update_object(ctx, doc, idict_num, dict); + idict = pdf_new_indirect(ctx, doc, idict_num, 0); + pdf_drop_obj(ctx, dict); dict = NULL; pdf_store_item(ctx, idict, form, pdf_xobject_size(form)); - form->contents = pdf_keep_obj(idict); - form->me = pdf_keep_obj(idict); + form->contents = pdf_keep_obj(ctx, idict); + form->me = pdf_keep_obj(ctx, idict); pdf_drop_xobject(ctx, form); form = NULL; } fz_catch(ctx) { - pdf_drop_obj(procset); - pdf_drop_obj(res); - pdf_drop_obj(obj); - pdf_drop_obj(dict); - pdf_drop_obj(idict); + pdf_drop_obj(ctx, procset); + pdf_drop_obj(ctx, res); + pdf_drop_obj(ctx, obj); + pdf_drop_obj(ctx, dict); + pdf_drop_obj(ctx, idict); pdf_drop_xobject(ctx, form); fz_rethrow_message(ctx, "failed to create xobject)"); } @@ -228,10 +226,10 @@ pdf_new_xobject(pdf_document *doc, const fz_rect *bbox, const fz_matrix *mat) return idict; } -void pdf_update_xobject_contents(pdf_document *doc, pdf_xobject *form, fz_buffer *buffer) +void pdf_update_xobject_contents(fz_context *ctx, pdf_document *doc, pdf_xobject *form, fz_buffer *buffer) { - pdf_dict_dels(form->contents, "Filter"); - pdf_dict_puts_drop(form->contents, "Length", pdf_new_int(doc, buffer->len)); - pdf_update_stream(doc, pdf_to_num(form->contents), buffer); + pdf_dict_dels(ctx, form->contents, "Filter"); + pdf_dict_puts_drop(ctx, form->contents, "Length", pdf_new_int(ctx, doc, buffer->len)); + pdf_update_stream(ctx, doc, pdf_to_num(ctx, form->contents), buffer); form->iteration ++; } diff --git a/source/pdf/pdf-xref-aux.c b/source/pdf/pdf-xref-aux.c index aac323de..d257fa60 100644 --- a/source/pdf/pdf-xref-aux.c +++ b/source/pdf/pdf-xref-aux.c @@ -12,8 +12,7 @@ pdf_document * pdf_open_document_with_stream(fz_context *ctx, fz_stream *file) { pdf_document *doc = pdf_open_document_no_run_with_stream(ctx, file); - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)pdf_run_page_contents; - doc->super.run_annot = (fz_document_run_annot_fn *)pdf_run_annot; + doc->super.load_page = (fz_document_load_page_fn*)pdf_load_page; doc->update_appearance = pdf_update_appearance; return doc; } @@ -22,8 +21,7 @@ pdf_document * pdf_open_document(fz_context *ctx, const char *filename) { pdf_document *doc = pdf_open_document_no_run(ctx, filename); - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)pdf_run_page_contents; - doc->super.run_annot = (fz_document_run_annot_fn *)pdf_run_annot; + doc->super.load_page = (fz_document_load_page_fn*)pdf_load_page; doc->update_appearance = pdf_update_appearance; return doc; } diff --git a/source/pdf/pdf-xref.c b/source/pdf/pdf-xref.c index ef82cc2f..586aab2d 100644 --- a/source/pdf/pdf-xref.c +++ b/source/pdf/pdf-xref.c @@ -20,9 +20,8 @@ static inline int iswhite(int ch) * xref tables */ -static void pdf_drop_xref_sections(pdf_document *doc) +static void pdf_drop_xref_sections(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; int x, e; for (x = 0; x < doc->num_xref_sections; x++) @@ -39,7 +38,7 @@ static void pdf_drop_xref_sections(pdf_document *doc) if (entry->obj) { - pdf_drop_obj(entry->obj); + pdf_drop_obj(ctx, entry->obj); fz_drop_buffer(ctx, entry->stm_buf); } } @@ -48,8 +47,8 @@ static void pdf_drop_xref_sections(pdf_document *doc) sub = next_sub; } - pdf_drop_obj(xref->pre_repair_trailer); - pdf_drop_obj(xref->trailer); + pdf_drop_obj(ctx, xref->pre_repair_trailer); + pdf_drop_obj(ctx, xref->trailer); } fz_free(ctx, doc->xref_sections); @@ -100,10 +99,10 @@ static void pdf_resize_xref(fz_context *ctx, pdf_document *doc, int newlen) extend_xref_index(ctx, doc, newlen); } -static void pdf_populate_next_xref_level(pdf_document *doc) +static void pdf_populate_next_xref_level(fz_context *ctx, pdf_document *doc) { pdf_xref *xref; - doc->xref_sections = fz_resize_array(doc->ctx, doc->xref_sections, doc->num_xref_sections + 1, sizeof(pdf_xref)); + doc->xref_sections = fz_resize_array(ctx, doc->xref_sections, doc->num_xref_sections + 1, sizeof(pdf_xref)); doc->num_xref_sections++; xref = &doc->xref_sections[doc->num_xref_sections - 1]; @@ -113,7 +112,7 @@ static void pdf_populate_next_xref_level(pdf_document *doc) xref->pre_repair_trailer = NULL; } -pdf_obj *pdf_trailer(pdf_document *doc) +pdf_obj *pdf_trailer(fz_context *ctx, pdf_document *doc) { /* Return the document's final trailer */ pdf_xref *xref = &doc->xref_sections[0]; @@ -121,19 +120,19 @@ pdf_obj *pdf_trailer(pdf_document *doc) return xref->trailer; } -void pdf_set_populating_xref_trailer(pdf_document *doc, pdf_obj *trailer) +void pdf_set_populating_xref_trailer(fz_context *ctx, pdf_document *doc, pdf_obj *trailer) { /* Update the trailer of the xref section being populated */ pdf_xref *xref = &doc->xref_sections[doc->num_xref_sections - 1]; if (xref->trailer) { - pdf_drop_obj(xref->pre_repair_trailer); + pdf_drop_obj(ctx, xref->pre_repair_trailer); xref->pre_repair_trailer = xref->trailer; } - xref->trailer = pdf_keep_obj(trailer); + xref->trailer = pdf_keep_obj(ctx, trailer); } -int pdf_xref_len(pdf_document *doc) +int pdf_xref_len(fz_context *ctx, pdf_document *doc) { return doc->max_xref_len; } @@ -141,9 +140,8 @@ int pdf_xref_len(pdf_document *doc) /* Ensure that the given xref has a single subsection * that covers the entire range. */ static void -ensure_solid_xref(pdf_document *doc, int num, int which) +ensure_solid_xref(fz_context *ctx, pdf_document *doc, int num, int which) { - fz_context *ctx = doc->ctx; pdf_xref *xref = &doc->xref_sections[which]; pdf_xref_subsec *sub = xref->subsec; pdf_xref_subsec *new_sub; @@ -191,7 +189,7 @@ ensure_solid_xref(pdf_document *doc, int num, int which) } /* Used while reading the individual xref sections from a file */ -pdf_xref_entry *pdf_get_populating_xref_entry(pdf_document *doc, int num) +pdf_xref_entry *pdf_get_populating_xref_entry(fz_context *ctx, pdf_document *doc, int num) { /* Return an entry within the xref currently being populated */ pdf_xref *xref; @@ -199,13 +197,13 @@ pdf_xref_entry *pdf_get_populating_xref_entry(pdf_document *doc, int num) if (doc->num_xref_sections == 0) { - doc->xref_sections = fz_calloc(doc->ctx, 1, sizeof(pdf_xref)); + doc->xref_sections = fz_calloc(ctx, 1, sizeof(pdf_xref)); doc->num_xref_sections = 1; } /* Prevent accidental heap underflow */ if (num < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "object number must not be negative (%d)", num); + fz_throw(ctx, FZ_ERROR_GENERIC, "object number must not be negative (%d)", num); /* Return the pointer to the entry in the last section. */ xref = &doc->xref_sections[doc->num_xref_sections-1]; @@ -217,7 +215,7 @@ pdf_xref_entry *pdf_get_populating_xref_entry(pdf_document *doc, int num) } /* We've been asked for an object that's not in a subsec. */ - ensure_solid_xref(doc, num+1, doc->num_xref_sections-1); + ensure_solid_xref(ctx, doc, num+1, doc->num_xref_sections-1); xref = &doc->xref_sections[doc->num_xref_sections-1]; sub = xref->subsec; @@ -228,9 +226,8 @@ pdf_xref_entry *pdf_get_populating_xref_entry(pdf_document *doc, int num) /* This will never throw anything, or return NULL if it is * only asked to return objects in range within a 'solid' * xref. */ -pdf_xref_entry *pdf_get_xref_entry(pdf_document *doc, int i) +pdf_xref_entry *pdf_get_xref_entry(fz_context *ctx, pdf_document *doc, int i) { - fz_context *ctx = doc->ctx; pdf_xref *xref; pdf_xref_subsec *sub; int j; @@ -284,7 +281,7 @@ pdf_xref_entry *pdf_get_xref_entry(pdf_document *doc, int i) * can return a pointer. This is the only case where this function * might throw an exception, and it will never happen when we are * working within a 'solid' xref. */ - ensure_solid_xref(doc, i+1, 0); + ensure_solid_xref(ctx, doc, i+1, 0); xref = &doc->xref_sections[0]; sub = xref->subsec; return &sub->table[i - sub->start]; @@ -295,9 +292,8 @@ pdf_xref_entry *pdf_get_xref_entry(pdf_document *doc, int i) updated versions of indirect objects. This is a new xref section consisting of a single xref subsection. */ -static void ensure_incremental_xref(pdf_document *doc) +static void ensure_incremental_xref(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; if (!doc->xref_altered) { @@ -312,7 +308,7 @@ static void ensure_incremental_xref(pdf_document *doc) fz_try(ctx) { sub = fz_malloc_struct(ctx, pdf_xref_subsec); - trailer = pdf_copy_dict(xref->trailer); + trailer = pdf_copy_dict(ctx, xref->trailer); doc->xref_sections = fz_resize_array(ctx, doc->xref_sections, doc->num_xref_sections + 1, sizeof(pdf_xref)); xref = &doc->xref_sections[0]; pxref = &doc->xref_sections[1]; @@ -331,7 +327,7 @@ static void ensure_incremental_xref(pdf_document *doc) fz_catch(ctx) { fz_free(ctx, new_table); - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); fz_rethrow(ctx); } @@ -344,14 +340,13 @@ static void ensure_incremental_xref(pdf_document *doc) } /* Used when altering a document */ -static pdf_xref_entry *pdf_get_incremental_xref_entry(pdf_document *doc, int i) +static pdf_xref_entry *pdf_get_incremental_xref_entry(fz_context *ctx, pdf_document *doc, int i) { - fz_context *ctx = doc->ctx; pdf_xref *xref; pdf_xref_subsec *sub; /* Make a new final xref section if we haven't already */ - ensure_incremental_xref(doc); + ensure_incremental_xref(ctx, doc); xref = &doc->xref_sections[0]; if (i >= xref->num_objects) @@ -364,7 +359,7 @@ static pdf_xref_entry *pdf_get_incremental_xref_entry(pdf_document *doc, int i) return &sub->table[i - sub->start]; } -int pdf_xref_is_incremental(pdf_document *doc, int num) +int pdf_xref_is_incremental(fz_context *ctx, pdf_document *doc, int num) { pdf_xref *xref = &doc->xref_sections[0]; pdf_xref_subsec *sub = xref->subsec; @@ -376,23 +371,23 @@ int pdf_xref_is_incremental(pdf_document *doc, int num) /* Ensure that the current populating xref has a single subsection * that covers the entire range. */ -void pdf_ensure_solid_xref(pdf_document *doc, int num) +void pdf_ensure_solid_xref(fz_context *ctx, pdf_document *doc, int num) { if (doc->num_xref_sections == 0) - pdf_populate_next_xref_level(doc); + pdf_populate_next_xref_level(ctx, doc); - ensure_solid_xref(doc, num, doc->num_xref_sections-1); + ensure_solid_xref(ctx, doc, num, doc->num_xref_sections-1); } /* Ensure that an object has been cloned into the incremental xref section */ -void pdf_xref_ensure_incremental_object(pdf_document *doc, int num) +void pdf_xref_ensure_incremental_object(fz_context *ctx, pdf_document *doc, int num) { pdf_xref_entry *new_entry, *old_entry; pdf_xref_subsec *sub = NULL; int i; /* Make sure we have created an xref section for incremental updates */ - ensure_incremental_xref(doc); + ensure_incremental_xref(ctx, doc); /* Search for the section that contains this object */ for (i = doc->xref_index[num]; i < doc->num_xref_sections; i++) @@ -418,18 +413,17 @@ void pdf_xref_ensure_incremental_object(pdf_document *doc, int num) /* Move the object to the incremental section */ doc->xref_index[num] = 0; old_entry = &sub->table[num - sub->start]; - new_entry = pdf_get_incremental_xref_entry(doc, num); + new_entry = pdf_get_incremental_xref_entry(ctx, doc, num); *new_entry = *old_entry; old_entry->obj = NULL; old_entry->stm_buf = NULL; } -void pdf_replace_xref(pdf_document *doc, pdf_xref_entry *entries, int n) +void pdf_replace_xref(fz_context *ctx, pdf_document *doc, pdf_xref_entry *entries, int n) { - fz_context *ctx = doc->ctx; pdf_xref *xref = NULL; pdf_xref_subsec *sub; - pdf_obj *trailer = pdf_keep_obj(pdf_trailer(doc)); + pdf_obj *trailer = pdf_keep_obj(ctx, pdf_trailer(ctx, doc)); fz_var(xref); fz_try(ctx) @@ -439,7 +433,7 @@ void pdf_replace_xref(pdf_document *doc, pdf_xref_entry *entries, int n) sub = fz_malloc_struct(ctx, pdf_xref_subsec); /* The new table completely replaces the previous separate sections */ - pdf_drop_xref_sections(doc); + pdf_drop_xref_sections(ctx, doc); sub->table = entries; sub->start = 0; @@ -458,7 +452,7 @@ void pdf_replace_xref(pdf_document *doc, pdf_xref_entry *entries, int n) fz_catch(ctx) { fz_free(ctx, xref); - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); fz_rethrow(ctx); } } @@ -468,33 +462,33 @@ void pdf_replace_xref(pdf_document *doc, pdf_xref_entry *entries, int n) */ static void -pdf_load_version(pdf_document *doc) +pdf_load_version(fz_context *ctx, pdf_document *doc) { char buf[20]; - fz_seek(doc->file, 0, SEEK_SET); - fz_read_line(doc->file, buf, sizeof buf); + fz_seek(ctx, doc->file, 0, SEEK_SET); + fz_read_line(ctx, doc->file, buf, sizeof buf); if (memcmp(buf, "%PDF-", 5) != 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot recognize version marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot recognize version marker"); doc->version = 10 * (fz_atof(buf+5) + 0.05); } static void -pdf_read_start_xref(pdf_document *doc) +pdf_read_start_xref(fz_context *ctx, pdf_document *doc) { unsigned char buf[1024]; int t, n; int i; - fz_seek(doc->file, 0, SEEK_END); + fz_seek(ctx, doc->file, 0, SEEK_END); - doc->file_size = fz_tell(doc->file); + doc->file_size = fz_tell(ctx, doc->file); t = fz_maxi(0, doc->file_size - (int)sizeof buf); - fz_seek(doc->file, t, SEEK_SET); + fz_seek(ctx, doc->file, t, SEEK_SET); - n = fz_read(doc->file, buf, sizeof buf); + n = fz_read(ctx, doc->file, buf, sizeof buf); for (i = n - 9; i >= 0; i--) { @@ -512,7 +506,7 @@ pdf_read_start_xref(pdf_document *doc) } } - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find startxref"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find startxref"); } /* @@ -520,7 +514,7 @@ pdf_read_start_xref(pdf_document *doc) */ static int -pdf_xref_size_from_old_trailer(pdf_document *doc, pdf_lexbuf *buf) +pdf_xref_size_from_old_trailer(fz_context *ctx, pdf_document *doc, pdf_lexbuf *buf) { int len; char *s; @@ -534,82 +528,81 @@ pdf_xref_size_from_old_trailer(pdf_document *doc, pdf_lexbuf *buf) fz_var(trailer); /* Record the current file read offset so that we can reinstate it */ - ofs = fz_tell(doc->file); + ofs = fz_tell(ctx, doc->file); - fz_read_line(doc->file, buf->scratch, buf->size); + fz_read_line(ctx, doc->file, buf->scratch, buf->size); if (strncmp(buf->scratch, "xref", 4) != 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find xref marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find xref marker"); while (1) { - c = fz_peek_byte(doc->file); + c = fz_peek_byte(ctx, doc->file); if (!(c >= '0' && c <= '9')) break; - fz_read_line(doc->file, buf->scratch, buf->size); + fz_read_line(ctx, doc->file, buf->scratch, buf->size); s = buf->scratch; fz_strsep(&s, " "); /* ignore ofs */ if (!s) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "invalid range marker in xref"); + fz_throw(ctx, FZ_ERROR_GENERIC, "invalid range marker in xref"); len = fz_atoi(fz_strsep(&s, " ")); if (len < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "xref range marker must be positive"); + fz_throw(ctx, FZ_ERROR_GENERIC, "xref range marker must be positive"); /* broken pdfs where the section is not on a separate line */ if (s && *s != '\0') - fz_seek(doc->file, -(2 + (int)strlen(s)), SEEK_CUR); + fz_seek(ctx, doc->file, -(2 + (int)strlen(s)), SEEK_CUR); - t = fz_tell(doc->file); + t = fz_tell(ctx, doc->file); if (t < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot tell in file"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot tell in file"); if (len > (INT_MAX - t) / 20) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "xref has too many entries"); + fz_throw(ctx, FZ_ERROR_GENERIC, "xref has too many entries"); - fz_seek(doc->file, t + 20 * len, SEEK_SET); + fz_seek(ctx, doc->file, t + 20 * len, SEEK_SET); } - fz_try(doc->ctx) + fz_try(ctx) { - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, doc->file, buf); if (tok != PDF_TOK_TRAILER) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected trailer marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected trailer marker"); - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, doc->file, buf); if (tok != PDF_TOK_OPEN_DICT) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected trailer dictionary"); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected trailer dictionary"); - trailer = pdf_parse_dict(doc, doc->file, buf); + trailer = pdf_parse_dict(ctx, doc, doc->file, buf); - size = pdf_to_int(pdf_dict_gets(trailer, "Size")); + size = pdf_to_int(ctx, pdf_dict_gets(ctx, trailer, "Size")); if (!size) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "trailer missing Size entry"); + fz_throw(ctx, FZ_ERROR_GENERIC, "trailer missing Size entry"); } - fz_always(doc->ctx) + fz_always(ctx) { - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_message(doc->ctx, "cannot parse trailer"); + fz_rethrow_message(ctx, "cannot parse trailer"); } - fz_seek(doc->file, ofs, SEEK_SET); + fz_seek(ctx, doc->file, ofs, SEEK_SET); return size; } pdf_obj * -pdf_new_ref(pdf_document *doc, pdf_obj *obj) +pdf_new_ref(fz_context *ctx, pdf_document *doc, pdf_obj *obj) { - int num = pdf_create_object(doc); - pdf_update_object(doc, num, obj); - return pdf_new_indirect(doc, num, 0); + int num = pdf_create_object(ctx, doc); + pdf_update_object(ctx, doc, num, obj); + return pdf_new_indirect(ctx, doc, num, 0); } static pdf_xref_entry * -pdf_xref_find_subsection(pdf_document *doc, int ofs, int len) +pdf_xref_find_subsection(fz_context *ctx, pdf_document *doc, int ofs, int len) { - fz_context *ctx = doc->ctx; pdf_xref *xref = &doc->xref_sections[doc->num_xref_sections-1]; pdf_xref_subsec *sub; int new_max; @@ -658,7 +651,7 @@ pdf_xref_find_subsection(pdf_document *doc, int ofs, int len) else { /* Case 3 */ - ensure_solid_xref(doc, new_max, doc->num_xref_sections-1); + ensure_solid_xref(ctx, doc, new_max, doc->num_xref_sections-1); xref = &doc->xref_sections[doc->num_xref_sections-1]; sub = xref->subsec; } @@ -666,8 +659,10 @@ pdf_xref_find_subsection(pdf_document *doc, int ofs, int len) } static pdf_obj * -pdf_read_old_xref(pdf_document *doc, pdf_lexbuf *buf) +pdf_read_old_xref(fz_context *ctx, pdf_document *doc, pdf_lexbuf *buf) { + fz_stream *file = doc->file; + int ofs, len; char *s; int n; @@ -675,20 +670,20 @@ pdf_read_old_xref(pdf_document *doc, pdf_lexbuf *buf) int i; int c; pdf_obj *trailer; - int xref_len = pdf_xref_size_from_old_trailer(doc, buf); + int xref_len = pdf_xref_size_from_old_trailer(ctx, doc, buf); pdf_xref_entry *table; - fz_read_line(doc->file, buf->scratch, buf->size); + fz_read_line(ctx, file, buf->scratch, buf->size); if (strncmp(buf->scratch, "xref", 4) != 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find xref marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find xref marker"); while (1) { - c = fz_peek_byte(doc->file); + c = fz_peek_byte(ctx, file); if (!(c >= '0' && c <= '9')) break; - fz_read_line(doc->file, buf->scratch, buf->size); + fz_read_line(ctx, file, buf->scratch, buf->size); s = buf->scratch; ofs = fz_atoi(fz_strsep(&s, " ")); len = fz_atoi(fz_strsep(&s, " ")); @@ -696,27 +691,27 @@ pdf_read_old_xref(pdf_document *doc, pdf_lexbuf *buf) /* broken pdfs where the section is not on a separate line */ if (s && *s != '\0') { - fz_warn(doc->ctx, "broken xref section. proceeding anyway."); - fz_seek(doc->file, -(2 + (int)strlen(s)), SEEK_CUR); + fz_warn(ctx, "broken xref section. proceeding anyway."); + fz_seek(ctx, file, -(2 + (int)strlen(s)), SEEK_CUR); } if (ofs < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "out of range object num in xref: %d", ofs); + fz_throw(ctx, FZ_ERROR_GENERIC, "out of range object num in xref: %d", ofs); /* broken pdfs where size in trailer undershoots entries in xref sections */ if (ofs + len > xref_len) { - fz_warn(doc->ctx, "broken xref section, proceeding anyway."); + fz_warn(ctx, "broken xref section, proceeding anyway."); } - table = pdf_xref_find_subsection(doc, ofs, len); + table = pdf_xref_find_subsection(ctx, doc, ofs, len); for (i = ofs; i < ofs + len; i++) { pdf_xref_entry *entry = &table[i-ofs]; - n = fz_read(doc->file, (unsigned char *) buf->scratch, 20); + n = fz_read(ctx, file, (unsigned char *) buf->scratch, 20); if (n != 20) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "unexpected EOF in xref table"); + fz_throw(ctx, FZ_ERROR_GENERIC, "unexpected EOF in xref table"); if (!entry->type) { s = buf->scratch; @@ -729,42 +724,42 @@ pdf_read_old_xref(pdf_document *doc, pdf_lexbuf *buf) entry->gen = atoi(s + 11); entry->type = s[17]; if (s[17] != 'f' && s[17] != 'n' && s[17] != 'o') - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "unexpected xref type: %#x (%d %d R)", s[17], i, entry->gen); + fz_throw(ctx, FZ_ERROR_GENERIC, "unexpected xref type: %#x (%d %d R)", s[17], i, entry->gen); } } } - fz_try(doc->ctx) + fz_try(ctx) { - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_TRAILER) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected trailer marker"); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected trailer marker"); - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, file, buf); if (tok != PDF_TOK_OPEN_DICT) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected trailer dictionary"); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected trailer dictionary"); - trailer = pdf_parse_dict(doc, doc->file, buf); + trailer = pdf_parse_dict(ctx, doc, file, buf); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_message(doc->ctx, "cannot parse trailer"); + fz_rethrow_message(ctx, "cannot parse trailer"); } return trailer; } static void -pdf_read_new_xref_section(pdf_document *doc, fz_stream *stm, int i0, int i1, int w0, int w1, int w2) +pdf_read_new_xref_section(fz_context *ctx, pdf_document *doc, fz_stream *stm, int i0, int i1, int w0, int w1, int w2) { - int i, n; pdf_xref_entry *table; + int i, n; if (i0 < 0 || i1 < 0) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "negative xref stream entry index"); - //if (i0 + i1 > pdf_xref_len(doc)) - // fz_throw(doc->ctx, FZ_ERROR_GENERIC, "xref stream has too many entries"); + fz_throw(ctx, FZ_ERROR_GENERIC, "negative xref stream entry index"); + //if (i0 + i1 > pdf_xref_len(ctx, doc)) + // fz_throw(ctx, FZ_ERROR_GENERIC, "xref stream has too many entries"); - table = pdf_xref_find_subsection(doc, i0, i1); + table = pdf_xref_find_subsection(ctx, doc, i0, i1); for (i = i0; i < i0 + i1; i++) { pdf_xref_entry *entry = &table[i-i0]; @@ -772,15 +767,15 @@ pdf_read_new_xref_section(pdf_document *doc, fz_stream *stm, int i0, int i1, int int b = 0; int c = 0; - if (fz_is_eof(stm)) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "truncated xref stream"); + if (fz_is_eof(ctx, stm)) + fz_throw(ctx, FZ_ERROR_GENERIC, "truncated xref stream"); for (n = 0; n < w0; n++) - a = (a << 8) + fz_read_byte(stm); + a = (a << 8) + fz_read_byte(ctx, stm); for (n = 0; n < w1; n++) - b = (b << 8) + fz_read_byte(stm); + b = (b << 8) + fz_read_byte(ctx, stm); for (n = 0; n < w2; n++) - c = (c << 8) + fz_read_byte(stm); + c = (c << 8) + fz_read_byte(ctx, stm); if (!entry->type) { @@ -796,7 +791,7 @@ pdf_read_new_xref_section(pdf_document *doc, fz_stream *stm, int i0, int i1, int /* Entered with file locked, remains locked throughout. */ static pdf_obj * -pdf_read_new_xref(pdf_document *doc, pdf_lexbuf *buf) +pdf_read_new_xref(fz_context *ctx, pdf_document *doc, pdf_lexbuf *buf) { fz_stream *stm = NULL; pdf_obj *trailer = NULL; @@ -805,19 +800,18 @@ pdf_read_new_xref(pdf_document *doc, pdf_lexbuf *buf) int num, gen, ofs, stm_ofs; int size, w0, w1, w2; int t; - fz_context *ctx = doc->ctx; fz_var(trailer); fz_var(stm); fz_try(ctx) { - ofs = fz_tell(doc->file); - trailer = pdf_parse_ind_obj(doc, doc->file, buf, &num, &gen, &stm_ofs, NULL); + ofs = fz_tell(ctx, doc->file); + trailer = pdf_parse_ind_obj(ctx, doc, doc->file, buf, &num, &gen, &stm_ofs, NULL); } fz_catch(ctx) { - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); fz_rethrow_message(ctx, "cannot parse compressed xref stream object"); } @@ -825,18 +819,18 @@ pdf_read_new_xref(pdf_document *doc, pdf_lexbuf *buf) { pdf_xref_entry *entry; - obj = pdf_dict_gets(trailer, "Size"); + obj = pdf_dict_gets(ctx, trailer, "Size"); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "xref stream missing Size entry (%d %d R)", num, gen); - size = pdf_to_int(obj); + size = pdf_to_int(ctx, obj); - obj = pdf_dict_gets(trailer, "W"); + obj = pdf_dict_gets(ctx, trailer, "W"); if (!obj) fz_throw(ctx, FZ_ERROR_GENERIC, "xref stream missing W entry (%d %d R)", num, gen); - w0 = pdf_to_int(pdf_array_get(obj, 0)); - w1 = pdf_to_int(pdf_array_get(obj, 1)); - w2 = pdf_to_int(pdf_array_get(obj, 2)); + w0 = pdf_to_int(ctx, pdf_array_get(ctx, obj, 0)); + w1 = pdf_to_int(ctx, pdf_array_get(ctx, obj, 1)); + w2 = pdf_to_int(ctx, pdf_array_get(ctx, obj, 2)); if (w0 < 0) fz_warn(ctx, "xref stream objects have corrupt type"); @@ -849,39 +843,39 @@ pdf_read_new_xref(pdf_document *doc, pdf_lexbuf *buf) w1 = w1 < 0 ? 0 : w1; w2 = w2 < 0 ? 0 : w2; - index = pdf_dict_gets(trailer, "Index"); + index = pdf_dict_gets(ctx, trailer, "Index"); - stm = pdf_open_stream_with_offset(doc, num, gen, trailer, stm_ofs); + stm = pdf_open_stream_with_offset(ctx, doc, num, gen, trailer, stm_ofs); if (!index) { - pdf_read_new_xref_section(doc, stm, 0, size, w0, w1, w2); + pdf_read_new_xref_section(ctx, doc, stm, 0, size, w0, w1, w2); } else { - int n = pdf_array_len(index); + int n = pdf_array_len(ctx, index); for (t = 0; t < n; t += 2) { - int i0 = pdf_to_int(pdf_array_get(index, t + 0)); - int i1 = pdf_to_int(pdf_array_get(index, t + 1)); - pdf_read_new_xref_section(doc, stm, i0, i1, w0, w1, w2); + int i0 = pdf_to_int(ctx, pdf_array_get(ctx, index, t + 0)); + int i1 = pdf_to_int(ctx, pdf_array_get(ctx, index, t + 1)); + pdf_read_new_xref_section(ctx, doc, stm, i0, i1, w0, w1, w2); } } - entry = pdf_get_populating_xref_entry(doc, num); + entry = pdf_get_populating_xref_entry(ctx, doc, num); entry->ofs = ofs; entry->gen = gen; entry->stm_ofs = stm_ofs; - pdf_drop_obj(entry->obj); - entry->obj = pdf_keep_obj(trailer); + pdf_drop_obj(ctx, entry->obj); + entry->obj = pdf_keep_obj(ctx, trailer); entry->type = 'n'; } fz_always(ctx) { - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); } fz_catch(ctx) { - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); fz_rethrow(ctx); } @@ -889,24 +883,23 @@ pdf_read_new_xref(pdf_document *doc, pdf_lexbuf *buf) } static pdf_obj * -pdf_read_xref(pdf_document *doc, int ofs, pdf_lexbuf *buf) +pdf_read_xref(fz_context *ctx, pdf_document *doc, int ofs, pdf_lexbuf *buf) { - int c; - fz_context *ctx = doc->ctx; pdf_obj *trailer; + int c; - fz_seek(doc->file, ofs, SEEK_SET); + fz_seek(ctx, doc->file, ofs, SEEK_SET); - while (iswhite(fz_peek_byte(doc->file))) - fz_read_byte(doc->file); + while (iswhite(fz_peek_byte(ctx, doc->file))) + fz_read_byte(ctx, doc->file); fz_try(ctx) { - c = fz_peek_byte(doc->file); + c = fz_peek_byte(ctx, doc->file); if (c == 'x') - trailer = pdf_read_old_xref(doc, buf); + trailer = pdf_read_old_xref(ctx, doc, buf); else if (c >= '0' && c <= '9') - trailer = pdf_read_new_xref(doc, buf); + trailer = pdf_read_new_xref(ctx, doc, buf); else fz_throw(ctx, FZ_ERROR_GENERIC, "cannot recognize xref format"); } @@ -927,10 +920,9 @@ struct ofs_list_s }; static int -read_xref_section(pdf_document *doc, int ofs, pdf_lexbuf *buf, ofs_list *offsets) +read_xref_section(fz_context *ctx, pdf_document *doc, int ofs, pdf_lexbuf *buf, ofs_list *offsets) { pdf_obj *trailer = NULL; - fz_context *ctx = doc->ctx; int xrefstmofs = 0; int prevofs = 0; @@ -957,13 +949,13 @@ read_xref_section(pdf_document *doc, int ofs, pdf_lexbuf *buf, ofs_list *offsets } offsets->list[offsets->len++] = ofs; - trailer = pdf_read_xref(doc, ofs, buf); + trailer = pdf_read_xref(ctx, doc, ofs, buf); - pdf_set_populating_xref_trailer(doc, trailer); + pdf_set_populating_xref_trailer(ctx, doc, trailer); /* FIXME: do we overwrite free entries properly? */ /* FIXME: Does this work properly with progression? */ - xrefstmofs = pdf_to_int(pdf_dict_gets(trailer, "XRefStm")); + xrefstmofs = pdf_to_int(ctx, pdf_dict_gets(ctx, trailer, "XRefStm")); if (xrefstmofs) { if (xrefstmofs < 0) @@ -974,16 +966,16 @@ read_xref_section(pdf_document *doc, int ofs, pdf_lexbuf *buf, ofs_list *offsets follow any Prev tag therein, as specified on Page 108 of the PDF reference 1.7 */ - pdf_drop_obj(pdf_read_xref(doc, xrefstmofs, buf)); + pdf_drop_obj(ctx, pdf_read_xref(ctx, doc, xrefstmofs, buf)); } - prevofs = pdf_to_int(pdf_dict_gets(trailer, "Prev")); + prevofs = pdf_to_int(ctx, pdf_dict_gets(ctx, trailer, "Prev")); if (prevofs < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "negative xref stream offset for previous xref stream"); } fz_always(ctx) { - pdf_drop_obj(trailer); + pdf_drop_obj(ctx, trailer); } fz_catch(ctx) { @@ -994,9 +986,8 @@ read_xref_section(pdf_document *doc, int ofs, pdf_lexbuf *buf, ofs_list *offsets } static void -pdf_read_xref_sections(pdf_document *doc, int ofs, pdf_lexbuf *buf, int read_previous) +pdf_read_xref_sections(fz_context *ctx, pdf_document *doc, int ofs, pdf_lexbuf *buf, int read_previous) { - fz_context *ctx = doc->ctx; ofs_list list; list.len = 0; @@ -1006,8 +997,8 @@ pdf_read_xref_sections(pdf_document *doc, int ofs, pdf_lexbuf *buf, int read_pre { while(ofs) { - pdf_populate_next_xref_level(doc); - ofs = read_xref_section(doc, ofs, buf, &list); + pdf_populate_next_xref_level(ctx, doc); + ofs = read_xref_section(ctx, doc, ofs, buf, &list); if (!read_previous) break; } @@ -1023,7 +1014,7 @@ pdf_read_xref_sections(pdf_document *doc, int ofs, pdf_lexbuf *buf, int read_pre } static void -pdf_prime_xref_index(pdf_document *doc) +pdf_prime_xref_index(fz_context *ctx, pdf_document *doc) { int i, j; int *idx = doc->xref_index; @@ -1055,23 +1046,22 @@ pdf_prime_xref_index(pdf_document *doc) */ static void -pdf_load_xref(pdf_document *doc, pdf_lexbuf *buf) +pdf_load_xref(fz_context *ctx, pdf_document *doc, pdf_lexbuf *buf) { int i; int xref_len; pdf_xref_entry *entry; - fz_context *ctx = doc->ctx; - pdf_read_start_xref(doc); + pdf_read_start_xref(ctx, doc); - pdf_read_xref_sections(doc, doc->startxref, buf, 1); + pdf_read_xref_sections(ctx, doc, doc->startxref, buf, 1); - if (pdf_xref_len(doc) == 0) + if (pdf_xref_len(ctx, doc) == 0) fz_throw(ctx, FZ_ERROR_GENERIC, "found xref was empty"); - pdf_prime_xref_index(doc); + pdf_prime_xref_index(ctx, doc); - entry = pdf_get_xref_entry(doc, 0); + entry = pdf_get_xref_entry(ctx, doc, 0); /* broken pdfs where first object is missing */ if (!entry->type) { @@ -1083,10 +1073,10 @@ pdf_load_xref(pdf_document *doc, pdf_lexbuf *buf) fz_throw(ctx, FZ_ERROR_GENERIC, "first object in xref is not free"); /* broken pdfs where object offsets are out of range */ - xref_len = pdf_xref_len(doc); + xref_len = pdf_xref_len(ctx, doc); for (i = 0; i < xref_len; i++) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, i); if (entry->type == 'n') { /* Special case code: "0000000000 * n" means free, @@ -1097,19 +1087,18 @@ pdf_load_xref(pdf_document *doc, pdf_lexbuf *buf) fz_throw(ctx, FZ_ERROR_GENERIC, "object offset out of range: %d (%d 0 R)", entry->ofs, i); } if (entry->type == 'o') - if (entry->ofs <= 0 || entry->ofs >= xref_len || pdf_get_xref_entry(doc, entry->ofs)->type != 'n') + if (entry->ofs <= 0 || entry->ofs >= xref_len || pdf_get_xref_entry(ctx, doc, entry->ofs)->type != 'n') fz_throw(ctx, FZ_ERROR_GENERIC, "invalid reference to an objstm that does not exist: %d (%d 0 R)", entry->ofs, i); } } static void -pdf_load_linear(pdf_document *doc) +pdf_load_linear(fz_context *ctx, pdf_document *doc) { pdf_obj *dict = NULL; pdf_obj *hint = NULL; pdf_obj *o; int num, gen, stmofs, lin, len; - fz_context *ctx = doc->ctx; fz_var(dict); fz_var(hint); @@ -1118,39 +1107,39 @@ pdf_load_linear(pdf_document *doc) { pdf_xref_entry *entry; - dict = pdf_parse_ind_obj(doc, doc->file, &doc->lexbuf.base, &num, &gen, &stmofs, NULL); - if (!pdf_is_dict(dict)) + dict = pdf_parse_ind_obj(ctx, doc, doc->file, &doc->lexbuf.base, &num, &gen, &stmofs, NULL); + if (!pdf_is_dict(ctx, dict)) fz_throw(ctx, FZ_ERROR_GENERIC, "Failed to read linearized dictionary"); - o = pdf_dict_gets(dict, "Linearized"); + o = pdf_dict_gets(ctx, dict, "Linearized"); if (o == NULL) fz_throw(ctx, FZ_ERROR_GENERIC, "Failed to read linearized dictionary"); - lin = pdf_to_int(o); + lin = pdf_to_int(ctx, o); if (lin != 1) fz_throw(ctx, FZ_ERROR_GENERIC, "Unexpected version of Linearized tag (%d)", lin); - len = pdf_to_int(pdf_dict_gets(dict, "L")); + len = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "L")); if (len != doc->file_length) fz_throw(ctx, FZ_ERROR_GENERIC, "File has been updated since linearization"); - pdf_read_xref_sections(doc, fz_tell(doc->file), &doc->lexbuf.base, 0); + pdf_read_xref_sections(ctx, doc, fz_tell(ctx, doc->file), &doc->lexbuf.base, 0); - doc->page_count = pdf_to_int(pdf_dict_gets(dict, "N")); + doc->page_count = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "N")); doc->linear_page_refs = fz_resize_array(ctx, doc->linear_page_refs, doc->page_count, sizeof(pdf_obj *)); memset(doc->linear_page_refs, 0, doc->page_count * sizeof(pdf_obj*)); doc->linear_obj = dict; - doc->linear_pos = fz_tell(doc->file); - doc->linear_page1_obj_num = pdf_to_int(pdf_dict_gets(dict, "O")); - doc->linear_page_refs[0] = pdf_new_indirect(doc, doc->linear_page1_obj_num, 0); + doc->linear_pos = fz_tell(ctx, doc->file); + doc->linear_page1_obj_num = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "O")); + doc->linear_page_refs[0] = pdf_new_indirect(ctx, doc, doc->linear_page1_obj_num, 0); doc->linear_page_num = 0; - hint = pdf_dict_gets(dict, "H"); - doc->hint_object_offset = pdf_to_int(pdf_array_get(hint, 0)); - doc->hint_object_length = pdf_to_int(pdf_array_get(hint, 1)); + hint = pdf_dict_gets(ctx, dict, "H"); + doc->hint_object_offset = pdf_to_int(ctx, pdf_array_get(ctx, hint, 0)); + doc->hint_object_length = pdf_to_int(ctx, pdf_array_get(ctx, hint, 1)); - entry = pdf_get_populating_xref_entry(doc, 0); + entry = pdf_get_populating_xref_entry(ctx, doc, 0); entry->type = 'f'; } fz_catch(ctx) { - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); /* Drop back to non linearized reading mode */ doc->file_reading_linearly = 0; @@ -1158,41 +1147,41 @@ pdf_load_linear(pdf_document *doc) } void -pdf_ocg_set_config(pdf_document *doc, int config) +pdf_ocg_set_config(fz_context *ctx, pdf_document *doc, int config) { int i, j, len, len2; pdf_ocg_descriptor *desc = doc->ocg; pdf_obj *obj, *cobj; char *name; - obj = pdf_dict_gets(pdf_dict_gets(pdf_trailer(doc), "Root"), "OCProperties"); + obj = pdf_dict_gets(ctx, pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"), "OCProperties"); if (!obj) { if (config == 0) return; else - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "Unknown OCG config (None known!)"); + fz_throw(ctx, FZ_ERROR_GENERIC, "Unknown OCG config (None known!)"); } if (config == 0) { - cobj = pdf_dict_gets(obj, "D"); + cobj = pdf_dict_gets(ctx, obj, "D"); if (!cobj) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "No default OCG config"); + fz_throw(ctx, FZ_ERROR_GENERIC, "No default OCG config"); } else { - cobj = pdf_array_get(pdf_dict_gets(obj, "Configs"), config); + cobj = pdf_array_get(ctx, pdf_dict_gets(ctx, obj, "Configs"), config); if (!cobj) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "Illegal OCG config"); + fz_throw(ctx, FZ_ERROR_GENERIC, "Illegal OCG config"); } - pdf_drop_obj(desc->intent); - desc->intent = pdf_dict_gets(cobj, "Intent"); + pdf_drop_obj(ctx, desc->intent); + desc->intent = pdf_dict_gets(ctx, cobj, "Intent"); if (desc->intent) - pdf_keep_obj(desc->intent); + pdf_keep_obj(ctx, desc->intent); len = desc->len; - name = pdf_to_name(pdf_dict_gets(cobj, "BaseState")); + name = pdf_to_name(ctx, pdf_dict_gets(ctx, cobj, "BaseState")); if (strcmp(name, "Unchanged") == 0) { /* Do nothing */ @@ -1212,13 +1201,13 @@ pdf_ocg_set_config(pdf_document *doc, int config) } } - obj = pdf_dict_gets(cobj, "ON"); - len2 = pdf_array_len(obj); + obj = pdf_dict_gets(ctx, cobj, "ON"); + len2 = pdf_array_len(ctx, obj); for (i = 0; i < len2; i++) { - pdf_obj *o = pdf_array_get(obj, i); - int n = pdf_to_num(o); - int g = pdf_to_gen(o); + pdf_obj *o = pdf_array_get(ctx, obj, i); + int n = pdf_to_num(ctx, o); + int g = pdf_to_gen(ctx, o); for (j=0; j < len; j++) { if (desc->ocgs[j].num == n && desc->ocgs[j].gen == g) @@ -1229,13 +1218,13 @@ pdf_ocg_set_config(pdf_document *doc, int config) } } - obj = pdf_dict_gets(cobj, "OFF"); - len2 = pdf_array_len(obj); + obj = pdf_dict_gets(ctx, cobj, "OFF"); + len2 = pdf_array_len(ctx, obj); for (i = 0; i < len2; i++) { - pdf_obj *o = pdf_array_get(obj, i); - int n = pdf_to_num(o); - int g = pdf_to_gen(o); + pdf_obj *o = pdf_array_get(ctx, obj, i); + int n = pdf_to_num(ctx, o); + int g = pdf_to_gen(ctx, o); for (j=0; j < len; j++) { if (desc->ocgs[j].num == n && desc->ocgs[j].gen == g) @@ -1262,23 +1251,22 @@ pdf_ocg_set_config(pdf_document *doc, int config) } static void -pdf_read_ocg(pdf_document *doc) +pdf_read_ocg(fz_context *ctx, pdf_document *doc) { pdf_obj *obj, *ocg; int len, i; pdf_ocg_descriptor *desc; - fz_context *ctx = doc->ctx; fz_var(desc); - obj = pdf_dict_gets(pdf_dict_gets(pdf_trailer(doc), "Root"), "OCProperties"); + obj = pdf_dict_gets(ctx, pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"), "OCProperties"); if (!obj) return; - ocg = pdf_dict_gets(obj, "OCGs"); - if (!ocg || !pdf_is_array(ocg)) + ocg = pdf_dict_gets(ctx, obj, "OCGs"); + if (!ocg || !pdf_is_array(ctx, ocg)) /* Not ever supposed to happen, but live with it. */ return; - len = pdf_array_len(ocg); + len = pdf_array_len(ctx, ocg); fz_try(ctx) { desc = fz_calloc(ctx, 1, sizeof(*desc)); @@ -1287,9 +1275,9 @@ pdf_read_ocg(pdf_document *doc) desc->intent = NULL; for (i=0; i < len; i++) { - pdf_obj *o = pdf_array_get(ocg, i); - desc->ocgs[i].num = pdf_to_num(o); - desc->ocgs[i].gen = pdf_to_gen(o); + pdf_obj *o = pdf_array_get(ctx, ocg, i); + desc->ocgs[i].num = pdf_to_num(ctx, o); + desc->ocgs[i].gen = pdf_to_gen(ctx, o); desc->ocgs[i].state = 1; } doc->ocg = desc; @@ -1302,7 +1290,7 @@ pdf_read_ocg(pdf_document *doc) fz_rethrow(ctx); } - pdf_ocg_set_config(doc, 0); + pdf_ocg_set_config(ctx, doc, 0); } static void @@ -1311,7 +1299,7 @@ pdf_drop_ocg(fz_context *ctx, pdf_ocg_descriptor *desc) if (!desc) return; - pdf_drop_obj(desc->intent); + pdf_drop_obj(ctx, desc->intent); fz_free(ctx, desc->ocgs); fz_free(ctx, desc); } @@ -1322,9 +1310,8 @@ pdf_drop_ocg(fz_context *ctx, pdf_ocg_descriptor *desc) */ static void -pdf_init_document(pdf_document *doc) +pdf_init_document(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; pdf_obj *encrypt, *id; pdf_obj *dict = NULL; pdf_obj *obj; @@ -1336,30 +1323,30 @@ pdf_init_document(pdf_document *doc) fz_try(ctx) { - pdf_load_version(doc); + pdf_load_version(ctx, doc); - doc->file_length = fz_stream_meta(doc->file, FZ_STREAM_META_LENGTH, 0, NULL); + doc->file_length = fz_stream_meta(ctx, doc->file, FZ_STREAM_META_LENGTH, 0, NULL); if (doc->file_length < 0) doc->file_length = 0; /* Check to see if we should work in progressive mode */ - if (fz_stream_meta(doc->file, FZ_STREAM_META_PROGRESSIVE, 0, NULL) > 0) + if (fz_stream_meta(ctx, doc->file, FZ_STREAM_META_PROGRESSIVE, 0, NULL) > 0) doc->file_reading_linearly = 1; /* Try to load the linearized file if we are in progressive * mode. */ if (doc->file_reading_linearly) - pdf_load_linear(doc); + pdf_load_linear(ctx, doc); /* If we aren't in progressive mode (or the linear load failed * and has set us back to non-progressive mode), load normally. */ if (!doc->file_reading_linearly) - pdf_load_xref(doc, &doc->lexbuf.base); + pdf_load_xref(ctx, doc, &doc->lexbuf.base); } fz_catch(ctx) { - pdf_drop_xref_sections(doc); + pdf_drop_xref_sections(ctx, doc); fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); fz_warn(ctx, "trying to repair broken xref"); repaired = 1; @@ -1373,35 +1360,35 @@ pdf_init_document(pdf_document *doc) { /* pdf_repair_xref may access xref_index, so reset it properly */ memset(doc->xref_index, 0, sizeof(int) * doc->max_xref_len); - pdf_repair_xref(doc); - pdf_prime_xref_index(doc); + pdf_repair_xref(ctx, doc); + pdf_prime_xref_index(ctx, doc); } - encrypt = pdf_dict_gets(pdf_trailer(doc), "Encrypt"); - id = pdf_dict_gets(pdf_trailer(doc), "ID"); - if (pdf_is_dict(encrypt)) + encrypt = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Encrypt"); + id = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "ID"); + if (pdf_is_dict(ctx, encrypt)) doc->crypt = pdf_new_crypt(ctx, encrypt, id); /* Allow lazy clients to read encrypted files with a blank password */ - pdf_authenticate_password(doc, ""); + pdf_authenticate_password(ctx, doc, ""); if (repaired) { - int xref_len = pdf_xref_len(doc); - pdf_repair_obj_stms(doc); + int xref_len = pdf_xref_len(ctx, doc); + pdf_repair_obj_stms(ctx, doc); - hasroot = (pdf_dict_gets(pdf_trailer(doc), "Root") != NULL); - hasinfo = (pdf_dict_gets(pdf_trailer(doc), "Info") != NULL); + hasroot = (pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root") != NULL); + hasinfo = (pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Info") != NULL); for (i = 1; i < xref_len; i++) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, i); if (entry->type == 0 || entry->type == 'f') continue; fz_try(ctx) { - dict = pdf_load_object(doc, i, 0); + dict = pdf_load_object(ctx, doc, i, 0); } fz_catch(ctx) { @@ -1412,46 +1399,46 @@ pdf_init_document(pdf_document *doc) if (!hasroot) { - obj = pdf_dict_gets(dict, "Type"); - if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Catalog")) + obj = pdf_dict_gets(ctx, dict, "Type"); + if (pdf_is_name(ctx, obj) && !strcmp(pdf_to_name(ctx, obj), "Catalog")) { - nobj = pdf_new_indirect(doc, i, 0); - pdf_dict_puts(pdf_trailer(doc), "Root", nobj); - pdf_drop_obj(nobj); + nobj = pdf_new_indirect(ctx, doc, i, 0); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Root", nobj); + pdf_drop_obj(ctx, nobj); nobj = NULL; } } if (!hasinfo) { - if (pdf_dict_gets(dict, "Creator") || pdf_dict_gets(dict, "Producer")) + if (pdf_dict_gets(ctx, dict, "Creator") || pdf_dict_gets(ctx, dict, "Producer")) { - nobj = pdf_new_indirect(doc, i, 0); - pdf_dict_puts(pdf_trailer(doc), "Info", nobj); - pdf_drop_obj(nobj); + nobj = pdf_new_indirect(ctx, doc, i, 0); + pdf_dict_puts(ctx, pdf_trailer(ctx, doc), "Info", nobj); + pdf_drop_obj(ctx, nobj); nobj = NULL; } } - pdf_drop_obj(dict); + pdf_drop_obj(ctx, dict); dict = NULL; } /* ensure that strings are not used in their repaired, non-decrypted form */ if (doc->crypt) - pdf_clear_xref(doc); + pdf_clear_xref(ctx, doc); } } fz_catch(ctx) { - pdf_drop_obj(dict); - pdf_drop_obj(nobj); + pdf_drop_obj(ctx, dict); + pdf_drop_obj(ctx, nobj); fz_rethrow_message(ctx, "cannot open document"); } fz_try(ctx) { - pdf_read_ocg(doc); + pdf_read_ocg(ctx, doc); } fz_catch(ctx) { @@ -1461,8 +1448,8 @@ pdf_init_document(pdf_document *doc) fz_try(ctx) { char *version_str; - obj = pdf_dict_getp(pdf_trailer(doc), "Root/Version"); - version_str = pdf_to_name(obj); + obj = pdf_dict_getp(ctx, pdf_trailer(ctx, doc), "Root/Version"); + version_str = pdf_to_name(ctx, obj); if (*version_str) { int version = 10 * (fz_atof(version_str) + 0.05); @@ -1474,15 +1461,13 @@ pdf_init_document(pdf_document *doc) } void -pdf_close_document(pdf_document *doc) +pdf_close_document(fz_context *ctx, pdf_document *doc) { - fz_context *ctx; pdf_unsaved_sig *usig; int i; if (!doc) return; - ctx = doc->ctx; /* Type3 glyphs in the glyph cache can contain pdf_obj pointers * that we are about to destroy. Simplest solution is to bin the @@ -1492,22 +1477,22 @@ pdf_close_document(pdf_document *doc) if (doc->js) doc->drop_js(doc->js); - pdf_drop_xref_sections(doc); + pdf_drop_xref_sections(ctx, doc); fz_free(ctx, doc->xref_index); if (doc->focus_obj) - pdf_drop_obj(doc->focus_obj); + pdf_drop_obj(ctx, doc->focus_obj); if (doc->file) - fz_drop_stream(doc->file); + fz_drop_stream(ctx, doc->file); if (doc->crypt) pdf_drop_crypt(ctx, doc->crypt); - pdf_drop_obj(doc->linear_obj); + pdf_drop_obj(ctx, doc->linear_obj); if (doc->linear_page_refs) { for (i=0; i < doc->page_count; i++) { - pdf_drop_obj(doc->linear_page_refs[i]); + pdf_drop_obj(ctx, doc->linear_page_refs[i]); } fz_free(ctx, doc->linear_page_refs); } @@ -1519,8 +1504,8 @@ pdf_close_document(pdf_document *doc) while ((usig = doc->unsaved_sigs) != NULL) { doc->unsaved_sigs = usig->next; - pdf_drop_obj(usig->field); - pdf_drop_signer(usig->signer); + pdf_drop_obj(ctx, usig->field); + pdf_drop_signer(ctx, usig->signer); fz_free(ctx, usig); } @@ -1535,20 +1520,20 @@ pdf_close_document(pdf_document *doc) fz_empty_store(ctx); - pdf_lexbuf_fin(&doc->lexbuf.base); + pdf_lexbuf_fin(ctx, &doc->lexbuf.base); fz_free(ctx, doc); } void -pdf_print_xref(pdf_document *doc) +pdf_print_xref(fz_context *ctx, pdf_document *doc) { int i; - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); printf("xref\n0 %d\n", xref_len); for (i = 0; i < xref_len; i++) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, i); printf("%05d: %010d %05d %c (stm_ofs=%d; stm_buf=%p)\n", i, entry->ofs, entry->gen, @@ -1563,7 +1548,7 @@ pdf_print_xref(pdf_document *doc) */ static pdf_xref_entry * -pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int target) +pdf_load_obj_stm(fz_context *ctx, pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int target) { fz_stream *stm = NULL; pdf_obj *objstm = NULL; @@ -1575,7 +1560,6 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe int count; int i; pdf_token tok; - fz_context *ctx = doc->ctx; pdf_xref_entry *ret_entry = NULL; fz_var(numbuf); @@ -1585,10 +1569,10 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe fz_try(ctx) { - objstm = pdf_load_object(doc, num, gen); + objstm = pdf_load_object(ctx, doc, num, gen); - count = pdf_to_int(pdf_dict_gets(objstm, "N")); - first = pdf_to_int(pdf_dict_gets(objstm, "First")); + count = pdf_to_int(ctx, pdf_dict_gets(ctx, objstm, "N")); + first = pdf_to_int(ctx, pdf_dict_gets(ctx, objstm, "First")); if (count < 0) fz_throw(ctx, FZ_ERROR_GENERIC, "negative number of objects in object stream"); @@ -1598,39 +1582,39 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe numbuf = fz_calloc(ctx, count, sizeof(int)); ofsbuf = fz_calloc(ctx, count, sizeof(int)); - stm = pdf_open_stream(doc, num, gen); + stm = pdf_open_stream(ctx, doc, num, gen); for (i = 0; i < count; i++) { - tok = pdf_lex(stm, buf); + tok = pdf_lex(ctx, stm, buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "corrupt object stream (%d %d R)", num, gen); numbuf[i] = buf->i; - tok = pdf_lex(stm, buf); + tok = pdf_lex(ctx, stm, buf); if (tok != PDF_TOK_INT) fz_throw(ctx, FZ_ERROR_GENERIC, "corrupt object stream (%d %d R)", num, gen); ofsbuf[i] = buf->i; } - fz_seek(stm, first, SEEK_SET); + fz_seek(ctx, stm, first, SEEK_SET); for (i = 0; i < count; i++) { - int xref_len = pdf_xref_len(doc); + int xref_len = pdf_xref_len(ctx, doc); pdf_xref_entry *entry; - fz_seek(stm, first + ofsbuf[i], SEEK_SET); + fz_seek(ctx, stm, first + ofsbuf[i], SEEK_SET); - obj = pdf_parse_stm_obj(doc, stm, buf); + obj = pdf_parse_stm_obj(ctx, doc, stm, buf); if (numbuf[i] <= 0 || numbuf[i] >= xref_len) { - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); fz_throw(ctx, FZ_ERROR_GENERIC, "object id (%d 0 R) out of range (0..%d)", numbuf[i], xref_len - 1); } - entry = pdf_get_xref_entry(doc, numbuf[i]); + entry = pdf_get_xref_entry(ctx, doc, numbuf[i]); - pdf_set_obj_parent(obj, numbuf[i]); + pdf_set_obj_parent(ctx, obj, numbuf[i]); if (entry->type == 'o' && entry->ofs == num) { @@ -1642,9 +1626,9 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe * and trust that the old one is correct. */ if (entry->obj) { - if (pdf_objcmp(entry->obj, obj)) + if (pdf_objcmp(ctx, entry->obj, obj)) fz_warn(ctx, "Encountered new definition for object %d - keeping the original one", numbuf[i]); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } else entry->obj = obj; @@ -1653,16 +1637,16 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe } else { - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } } } fz_always(ctx) { - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); fz_free(ctx, ofsbuf); fz_free(ctx, numbuf); - pdf_drop_obj(objstm); + pdf_drop_obj(ctx, objstm); } fz_catch(ctx) { @@ -1675,21 +1659,20 @@ pdf_load_obj_stm(pdf_document *doc, int num, int gen, pdf_lexbuf *buf, int targe * object loading */ static int -pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) +pdf_obj_read(fz_context *ctx, pdf_document *doc, int *offset, int *nump, pdf_obj **page) { - int num, numofs, gen, genofs, stmofs, tmpofs, tok; pdf_lexbuf *buf = &doc->lexbuf.base; - fz_context *ctx = doc->ctx; + int num, numofs, gen, genofs, stmofs, tmpofs, tok; int xref_len; pdf_xref_entry *entry; int newtmpofs; numofs = *offset; - fz_seek(doc->file, numofs, SEEK_SET); + fz_seek(ctx, doc->file, numofs, SEEK_SET); /* We expect to read 'num' here */ - tok = pdf_lex(doc->file, buf); - genofs = fz_tell(doc->file); + tok = pdf_lex(ctx, doc->file, buf); + genofs = fz_tell(ctx, doc->file); if (tok != PDF_TOK_INT) { /* Failed! */ @@ -1700,8 +1683,8 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) *nump = num = buf->i; /* We expect to read 'gen' here */ - tok = pdf_lex(doc->file, buf); - tmpofs = fz_tell(doc->file); + tok = pdf_lex(ctx, doc->file, buf); + tmpofs = fz_tell(ctx, doc->file); if (tok != PDF_TOK_INT) { /* Failed! */ @@ -1714,14 +1697,14 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) /* We expect to read 'obj' here */ do { - tmpofs = fz_tell(doc->file); - tok = pdf_lex(doc->file, buf); + tmpofs = fz_tell(ctx, doc->file); + tok = pdf_lex(ctx, doc->file, buf); if (tok == PDF_TOK_OBJ) break; if (tok != PDF_TOK_INT) { DEBUGMESS((ctx, "skipping unexpected data (tok=%d) at %d", tok, tmpofs)); - *offset = fz_tell(doc->file); + *offset = fz_tell(ctx, doc->file); return tok == PDF_TOK_EOF; } DEBUGMESS((ctx, "skipping unexpected int %d at %d", num, numofs)); @@ -1733,7 +1716,7 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) while (1); /* Now we read the actual object */ - xref_len = pdf_xref_len(doc); + xref_len = pdf_xref_len(ctx, doc); /* When we are reading a progressive file, we typically see: * File Header @@ -1751,7 +1734,7 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) * whenever we read an object it should just go into the * previous xref. */ - tok = pdf_repair_obj(doc, buf, &stmofs, NULL, NULL, NULL, page, &newtmpofs); + tok = pdf_repair_obj(ctx, doc, buf, &stmofs, NULL, NULL, NULL, page, &newtmpofs); do /* So we can break out of it */ { @@ -1764,7 +1747,7 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) { fz_warn(ctx, "Unexpected non zero generation number in linearized file"); } - entry = pdf_get_populating_xref_entry(doc, num); + entry = pdf_get_populating_xref_entry(ctx, doc, num); if (entry->type != 0) { DEBUGMESS((ctx, "Duplicate object found (%d %d obj)", num, gen)); @@ -1774,10 +1757,10 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) { DEBUGMESS((ctx, "Successfully read object %d @ %d - and found page %d!", num, numofs, doc->linear_page_num)); if (!entry->obj) - entry->obj = pdf_keep_obj(*page); + entry->obj = pdf_keep_obj(ctx, *page); if (doc->linear_page_refs[doc->linear_page_num] == NULL) - doc->linear_page_refs[doc->linear_page_num] = pdf_new_indirect(doc, num, gen); + doc->linear_page_refs[doc->linear_page_num] = pdf_new_indirect(ctx, doc, num, gen); } else { @@ -1794,7 +1777,7 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) if (tok == PDF_TOK_ENDOBJ) { - *offset = fz_tell(doc->file); + *offset = fz_tell(ctx, doc->file); } else { @@ -1804,9 +1787,8 @@ pdf_obj_read(pdf_document *doc, int *offset, int *nump, pdf_obj **page) } static void -pdf_load_hinted_page(pdf_document *doc, int pagenum) +pdf_load_hinted_page(fz_context *ctx, pdf_document *doc, int pagenum) { - fz_context *ctx = doc->ctx; if (!doc->hints_loaded || !doc->linear_page_refs) return; @@ -1817,14 +1799,14 @@ pdf_load_hinted_page(pdf_document *doc, int pagenum) fz_try(ctx) { int num = doc->hint_page[pagenum].number; - pdf_obj *page = pdf_load_object(doc, num, 0); - if (!strcmp("Page", pdf_to_name(pdf_dict_gets(page, "Type")))) + pdf_obj *page = pdf_load_object(ctx, doc, num, 0); + if (!strcmp("Page", pdf_to_name(ctx, pdf_dict_gets(ctx, page, "Type")))) { /* We have found the page object! */ DEBUGMESS((ctx, "LoadHintedPage pagenum=%d num=%d", pagenum, num)); - doc->linear_page_refs[pagenum] = pdf_new_indirect(doc, num, 0); + doc->linear_page_refs[pagenum] = pdf_new_indirect(ctx, doc, num, 0); } - pdf_drop_obj(page); + pdf_drop_obj(ctx, page); } fz_catch(ctx) { @@ -1835,12 +1817,11 @@ pdf_load_hinted_page(pdf_document *doc, int pagenum) } static int -read_hinted_object(pdf_document *doc, int num) +read_hinted_object(fz_context *ctx, pdf_document *doc, int num) { /* Try to find the object using our hint table. Find the closest * object <= the one we want that has a hint and read forward from * there. */ - fz_context *ctx = doc->ctx; int expected = num; int curr_pos; int start, offset; @@ -1852,7 +1833,7 @@ read_hinted_object(pdf_document *doc, int num) if (expected == 0) /* No hints found, just bale */ return 0; - curr_pos = fz_tell(doc->file); + curr_pos = fz_tell(ctx, doc->file); offset = doc->hint_obj_offsets[expected]; fz_var(expected); @@ -1866,7 +1847,7 @@ read_hinted_object(pdf_document *doc, int num) { start = offset; DEBUGMESS((ctx, "Searching for object %d @ %d", expected, offset)); - pdf_obj_read(doc, &offset, &found, 0); + pdf_obj_read(ctx, doc, &offset, &found, 0); DEBUGMESS((ctx, "Found object %d - next will be @ %d", found, offset)); if (found <= expected) { @@ -1894,7 +1875,7 @@ read_hinted_object(pdf_document *doc, int num) } fz_always(ctx) { - fz_seek(doc->file, curr_pos, SEEK_SET); + fz_seek(ctx, doc->file, curr_pos, SEEK_SET); } fz_catch(ctx) { @@ -1908,37 +1889,36 @@ read_hinted_object(pdf_document *doc, int num) } pdf_xref_entry * -pdf_cache_object(pdf_document *doc, int num, int gen) +pdf_cache_object(fz_context *ctx, pdf_document *doc, int num, int gen) { pdf_xref_entry *x; int rnum, rgen, try_repair; - fz_context *ctx = doc->ctx; fz_var(try_repair); - if (num <= 0 || num >= pdf_xref_len(doc)) - fz_throw(ctx, FZ_ERROR_GENERIC, "object out of range (%d %d R); xref size %d", num, gen, pdf_xref_len(doc)); + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) + fz_throw(ctx, FZ_ERROR_GENERIC, "object out of range (%d %d R); xref size %d", num, gen, pdf_xref_len(ctx, doc)); object_updated: try_repair = 0; rnum = num; - x = pdf_get_xref_entry(doc, num); + x = pdf_get_xref_entry(ctx, doc, num); if (x->obj != NULL) return x; if (x->type == 'f') { - x->obj = pdf_new_null(doc); + x->obj = pdf_new_null(ctx, doc); } else if (x->type == 'n') { - fz_seek(doc->file, x->ofs, SEEK_SET); + fz_seek(ctx, doc->file, x->ofs, SEEK_SET); fz_try(ctx) { - x->obj = pdf_parse_ind_obj(doc, doc->file, &doc->lexbuf.base, + x->obj = pdf_parse_ind_obj(ctx, doc, doc->file, &doc->lexbuf.base, &rnum, &rgen, &x->stm_ofs, &try_repair); } fz_catch(ctx) @@ -1949,7 +1929,7 @@ object_updated: if (!try_repair && rnum != num) { - pdf_drop_obj(x->obj); + pdf_drop_obj(ctx, x->obj); x->obj = NULL; try_repair = 1; } @@ -1958,8 +1938,8 @@ object_updated: { fz_try(ctx) { - pdf_repair_xref(doc); - pdf_prime_xref_index(doc); + pdf_repair_xref(ctx, doc); + pdf_prime_xref_index(ctx, doc); } fz_catch(ctx) { @@ -1980,7 +1960,7 @@ object_updated: { fz_try(ctx) { - x = pdf_load_obj_stm(doc, x->ofs, 0, &doc->lexbuf.base, num); + x = pdf_load_obj_stm(ctx, doc, x->ofs, 0, &doc->lexbuf.base, num); } fz_catch(ctx) { @@ -1992,7 +1972,7 @@ object_updated: fz_throw(ctx, FZ_ERROR_GENERIC, "object (%d %d R) was not found in its object stream", num, gen); } } - else if (doc->hint_obj_offsets && read_hinted_object(doc, num)) + else if (doc->hint_obj_offsets && read_hinted_object(ctx, doc, num)) { goto object_updated; } @@ -2005,19 +1985,18 @@ object_updated: fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find object in xref (%d %d R)", num, gen); } - pdf_set_obj_parent(x->obj, num); + pdf_set_obj_parent(ctx, x->obj, num); return x; } pdf_obj * -pdf_load_object(pdf_document *doc, int num, int gen) +pdf_load_object(fz_context *ctx, pdf_document *doc, int num, int gen) { - fz_context *ctx = doc->ctx; pdf_xref_entry *entry; fz_try(ctx) { - entry = pdf_cache_object(doc, num, gen); + entry = pdf_cache_object(ctx, doc, num, gen); } fz_catch(ctx) { @@ -2026,32 +2005,32 @@ pdf_load_object(pdf_document *doc, int num, int gen) assert(entry->obj != NULL); - return pdf_keep_obj(entry->obj); + return pdf_keep_obj(ctx, entry->obj); } pdf_obj * -pdf_resolve_indirect(pdf_obj *ref) +pdf_resolve_indirect(fz_context *ctx, pdf_obj *ref) { int sanity = 10; int num; int gen; - fz_context *ctx = NULL; /* Avoid warning for stupid compilers */ - pdf_document *doc; pdf_xref_entry *entry; - while (pdf_is_indirect(ref)) + while (pdf_is_indirect(ctx, ref)) { + pdf_document *doc; + if (--sanity == 0) { fz_warn(ctx, "too many indirections (possible indirection cycle involving %d %d R)", num, gen); return NULL; } - doc = pdf_get_indirect_document(ref); + + doc = pdf_get_indirect_document(ctx, ref); if (!doc) return NULL; - ctx = doc->ctx; - num = pdf_to_num(ref); - gen = pdf_to_gen(ref); + num = pdf_to_num(ctx, ref); + gen = pdf_to_gen(ctx, ref); if (num <= 0 || gen < 0) { @@ -2061,7 +2040,7 @@ pdf_resolve_indirect(pdf_obj *ref) fz_try(ctx) { - entry = pdf_cache_object(doc, num, gen); + entry = pdf_cache_object(ctx, doc, num, gen); } fz_catch(ctx) { @@ -2079,18 +2058,18 @@ pdf_resolve_indirect(pdf_obj *ref) } int -pdf_count_objects(pdf_document *doc) +pdf_count_objects(fz_context *ctx, pdf_document *doc) { - return pdf_xref_len(doc); + return pdf_xref_len(ctx, doc); } int -pdf_create_object(pdf_document *doc) +pdf_create_object(fz_context *ctx, pdf_document *doc) { /* TODO: reuse free object slots by properly linking free object chains in the ofs field */ pdf_xref_entry *entry; - int num = pdf_xref_len(doc); - entry = pdf_get_incremental_xref_entry(doc, num); + int num = pdf_xref_len(ctx, doc); + entry = pdf_get_incremental_xref_entry(ctx, doc, num); entry->type = 'f'; entry->ofs = -1; entry->gen = 0; @@ -2101,20 +2080,20 @@ pdf_create_object(pdf_document *doc) } void -pdf_delete_object(pdf_document *doc, int num) +pdf_delete_object(fz_context *ctx, pdf_document *doc, int num) { pdf_xref_entry *x; - if (num <= 0 || num >= pdf_xref_len(doc)) + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) { - fz_warn(doc->ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(doc)); + fz_warn(ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(ctx, doc)); return; } - x = pdf_get_incremental_xref_entry(doc, num); + x = pdf_get_incremental_xref_entry(ctx, doc, num); - fz_drop_buffer(doc->ctx, x->stm_buf); - pdf_drop_obj(x->obj); + fz_drop_buffer(ctx, x->stm_buf); + pdf_drop_obj(ctx, x->obj); x->type = 'f'; x->ofs = 0; @@ -2125,46 +2104,46 @@ pdf_delete_object(pdf_document *doc, int num) } void -pdf_update_object(pdf_document *doc, int num, pdf_obj *newobj) +pdf_update_object(fz_context *ctx, pdf_document *doc, int num, pdf_obj *newobj) { pdf_xref_entry *x; - if (num <= 0 || num >= pdf_xref_len(doc)) + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) { - fz_warn(doc->ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(doc)); + fz_warn(ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(ctx, doc)); return; } - x = pdf_get_incremental_xref_entry(doc, num); + x = pdf_get_incremental_xref_entry(ctx, doc, num); - pdf_drop_obj(x->obj); + pdf_drop_obj(ctx, x->obj); x->type = 'n'; x->ofs = 0; - x->obj = pdf_keep_obj(newobj); + x->obj = pdf_keep_obj(ctx, newobj); - pdf_set_obj_parent(newobj, num); + pdf_set_obj_parent(ctx, newobj, num); } void -pdf_update_stream(pdf_document *doc, int num, fz_buffer *newbuf) +pdf_update_stream(fz_context *ctx, pdf_document *doc, int num, fz_buffer *newbuf) { pdf_xref_entry *x; - if (num <= 0 || num >= pdf_xref_len(doc)) + if (num <= 0 || num >= pdf_xref_len(ctx, doc)) { - fz_warn(doc->ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(doc)); + fz_warn(ctx, "object out of range (%d 0 R); xref size %d", num, pdf_xref_len(ctx, doc)); return; } - x = pdf_get_xref_entry(doc, num); + x = pdf_get_xref_entry(ctx, doc, num); - fz_drop_buffer(doc->ctx, x->stm_buf); - x->stm_buf = fz_keep_buffer(doc->ctx, newbuf); + fz_drop_buffer(ctx, x->stm_buf); + x->stm_buf = fz_keep_buffer(ctx, newbuf); } int -pdf_meta(pdf_document *doc, int key, void *ptr, int size) +pdf_meta(fz_context *ctx, pdf_document *doc, int key, void *ptr, int size) { switch (key) { @@ -2179,10 +2158,10 @@ pdf_meta(pdf_document *doc, int key, void *ptr, int size) case FZ_META_CRYPT_INFO: if (doc->crypt) sprintf((char *)ptr, "Standard V%d R%d %d-bit %s", - pdf_crypt_version(doc), - pdf_crypt_revision(doc), - pdf_crypt_length(doc), - pdf_crypt_method(doc)); + pdf_crypt_version(ctx, doc), + pdf_crypt_revision(ctx, doc), + pdf_crypt_length(ctx, doc), + pdf_crypt_method(ctx, doc)); else sprintf((char *)ptr, "None"); return FZ_META_OK; @@ -2206,18 +2185,18 @@ pdf_meta(pdf_document *doc, int key, void *ptr, int size) default: return 0; } - return pdf_has_permission(doc, i); + return pdf_has_permission(ctx, doc, i); } case FZ_META_INFO: { - pdf_obj *info = pdf_dict_gets(pdf_trailer(doc), "Info"); + pdf_obj *info = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Info"); if (!info) { if (ptr) *(char *)ptr = 0; return 0; } - info = pdf_dict_gets(info, *(char **)ptr); + info = pdf_dict_gets(ctx, info, *(char **)ptr); if (!info) { if (ptr) @@ -2226,9 +2205,9 @@ pdf_meta(pdf_document *doc, int key, void *ptr, int size) } if (info && ptr && size) { - char *utf8 = pdf_to_utf8(doc, info); + char *utf8 = pdf_to_utf8(ctx, doc, info); fz_strlcpy(ptr, utf8, size); - fz_free(doc->ctx, utf8); + fz_free(ctx, utf8); } return 1; } @@ -2238,7 +2217,7 @@ pdf_meta(pdf_document *doc, int key, void *ptr, int size) } fz_transition * -pdf_page_presentation(pdf_document *doc, pdf_page *page, float *duration) +pdf_page_presentation(fz_context *ctx, pdf_page *page, float *duration) { *duration = page->duration; if (!page->transition_present) @@ -2246,13 +2225,6 @@ pdf_page_presentation(pdf_document *doc, pdf_page *page, float *duration) return &page->transition; } -static void -pdf_rebind(pdf_document *doc, fz_context *ctx) -{ - doc->ctx = ctx; - fz_rebind_stream(doc->file, ctx); -} - /* Initializers for the fz_document interface. @@ -2275,22 +2247,11 @@ pdf_new_document(fz_context *ctx, fz_stream *file) doc->super.load_outline = (fz_document_load_outline_fn *)pdf_load_outline; doc->super.count_pages = (fz_document_count_pages_fn *)pdf_count_pages; doc->super.load_page = (fz_document_load_page_fn *)pdf_load_page; - doc->super.load_links = (fz_document_load_links_fn *)pdf_load_links; - doc->super.bound_page = (fz_document_bound_page_fn *)pdf_bound_page; - doc->super.first_annot = (fz_document_first_annot_fn *)pdf_first_annot; - doc->super.next_annot = (fz_document_next_annot_fn *)pdf_next_annot; - doc->super.bound_annot = (fz_document_bound_annot_fn *)pdf_bound_annot; - doc->super.run_page_contents = NULL; /* see pdf_xref_aux.c */ - doc->super.run_annot = NULL; /* see pdf_xref_aux.c */ - doc->super.free_page = (fz_document_free_page_fn *)pdf_drop_page; doc->super.meta = (fz_document_meta_fn *)pdf_meta; - doc->super.page_presentation = (fz_document_page_presentation_fn *)pdf_page_presentation; doc->super.write = (fz_document_write_fn *)pdf_write_document; - doc->super.rebind = (fz_document_rebind_fn *)pdf_rebind; pdf_lexbuf_init(ctx, &doc->lexbuf.base, PDF_LEXBUF_LARGE); - doc->file = fz_keep_stream(file); - doc->ctx = ctx; + doc->file = fz_keep_stream(ctx, file); return doc; } @@ -2299,16 +2260,13 @@ pdf_document * pdf_open_document_no_run_with_stream(fz_context *ctx, fz_stream *file) { pdf_document *doc = pdf_new_document(ctx, file); - - fz_var(doc); - fz_try(ctx) { - pdf_init_document(doc); + pdf_init_document(ctx, doc); } fz_catch(ctx) { - pdf_close_document(doc); + pdf_close_document(ctx, doc); fz_rethrow_message(ctx, "cannot load document from stream"); } return doc; @@ -2327,26 +2285,25 @@ pdf_open_document_no_run(fz_context *ctx, const char *filename) { file = fz_open_file(ctx, filename); doc = pdf_new_document(ctx, file); - pdf_init_document(doc); + pdf_init_document(ctx, doc); } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { - pdf_close_document(doc); + pdf_close_document(ctx, doc); fz_rethrow_message(ctx, "cannot load document '%s'", filename); } return doc; } static void -pdf_load_hints(pdf_document *doc, int objnum, int gennum) +pdf_load_hints(fz_context *ctx, pdf_document *doc, int objnum, int gennum) { fz_stream *stream = NULL; pdf_obj *dict; - fz_context *ctx = doc->ctx; fz_var(stream); fz_var(dict); @@ -2363,14 +2320,14 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) int shared_obj_num, shared_obj_offset, shared_obj_count_page1; int shared_obj_count_total; int least_shared_group_len, shared_group_len_num_bits; - int max_object_num = pdf_xref_len(doc); + int max_object_num = pdf_xref_len(ctx, doc); - stream = pdf_open_stream(doc, objnum, gennum); - dict = pdf_get_xref_entry(doc, objnum)->obj; - if (dict == NULL || !pdf_is_dict(dict)) + stream = pdf_open_stream(ctx, doc, objnum, gennum); + dict = pdf_get_xref_entry(ctx, doc, objnum)->obj; + if (dict == NULL || !pdf_is_dict(ctx, dict)) fz_throw(ctx, FZ_ERROR_GENERIC, "malformed hint object"); - shared_hint_offset = pdf_to_int(pdf_dict_gets(dict, "S")); + shared_hint_offset = pdf_to_int(ctx, pdf_dict_gets(ctx, dict, "S")); /* Malloc the structures (use realloc to cope with the fact we * may try this several times before enough data is loaded) */ @@ -2381,45 +2338,45 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) doc->hint_obj_offsets_max = max_object_num; /* Read the page object hints table: Header first */ - least_num_page_objs = fz_read_bits(stream, 32); + least_num_page_objs = fz_read_bits(ctx, stream, 32); /* The following is sometimes a lie, but we read this version, * as other table values are built from it. In * pdf_reference17.pdf, this points to 2 objects before the * first pages page object. */ - doc->hint_page[0].offset = fz_read_bits(stream, 32); + doc->hint_page[0].offset = fz_read_bits(ctx, stream, 32); if (doc->hint_page[0].offset > doc->hint_object_offset) doc->hint_page[0].offset += doc->hint_object_length; - page_obj_num_bits = fz_read_bits(stream, 16); - least_page_len = fz_read_bits(stream, 32); - page_len_num_bits = fz_read_bits(stream, 16); - /* least_page_offset = */ (void) fz_read_bits(stream, 32); - /* page_offset_num_bits = */ (void) fz_read_bits(stream, 16); - /* least_content_stream_len = */ (void) fz_read_bits(stream, 32); - /* content_stream_len_num_bits = */ (void) fz_read_bits(stream, 16); - num_shared_obj_num_bits = fz_read_bits(stream, 16); - shared_obj_num_bits = fz_read_bits(stream, 16); - /* numerator_bits = */ (void) fz_read_bits(stream, 16); - /* denominator_bits = */ (void) fz_read_bits(stream, 16); + page_obj_num_bits = fz_read_bits(ctx, stream, 16); + least_page_len = fz_read_bits(ctx, stream, 32); + page_len_num_bits = fz_read_bits(ctx, stream, 16); + /* least_page_offset = */ (void) fz_read_bits(ctx, stream, 32); + /* page_offset_num_bits = */ (void) fz_read_bits(ctx, stream, 16); + /* least_content_stream_len = */ (void) fz_read_bits(ctx, stream, 32); + /* content_stream_len_num_bits = */ (void) fz_read_bits(ctx, stream, 16); + num_shared_obj_num_bits = fz_read_bits(ctx, stream, 16); + shared_obj_num_bits = fz_read_bits(ctx, stream, 16); + /* numerator_bits = */ (void) fz_read_bits(ctx, stream, 16); + /* denominator_bits = */ (void) fz_read_bits(ctx, stream, 16); /* Item 1: Page object numbers */ doc->hint_page[0].number = doc->linear_page1_obj_num; /* We don't care about the number of objects in the first page */ - (void)fz_read_bits(stream, page_obj_num_bits); + (void)fz_read_bits(ctx, stream, page_obj_num_bits); j = 1; for (i = 1; i < doc->page_count; i++) { - int delta_page_objs = fz_read_bits(stream, page_obj_num_bits); + int delta_page_objs = fz_read_bits(ctx, stream, page_obj_num_bits); doc->hint_page[i].number = j; j += least_num_page_objs + delta_page_objs; } doc->hint_page[i].number = j; /* Not a real page object */ - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 2: Page lengths */ j = doc->hint_page[0].offset; for (i = 0; i < doc->page_count; i++) { - int delta_page_len = fz_read_bits(stream, page_len_num_bits); + int delta_page_len = fz_read_bits(ctx, stream, page_len_num_bits); int old = j; doc->hint_page[i].offset = j; @@ -2428,39 +2385,39 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) j += doc->hint_object_length; } doc->hint_page[i].offset = j; - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 3: Shared references */ shared = 0; for (i = 0; i < doc->page_count; i++) { - int num_shared_objs = fz_read_bits(stream, num_shared_obj_num_bits); + int num_shared_objs = fz_read_bits(ctx, stream, num_shared_obj_num_bits); doc->hint_page[i].index = shared; shared += num_shared_objs; } doc->hint_page[i].index = shared; doc->hint_shared_ref = fz_resize_array(ctx, doc->hint_shared_ref, shared, sizeof(*doc->hint_shared_ref)); memset(doc->hint_shared_ref, 0, sizeof(*doc->hint_shared_ref) * shared); - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 4: Shared references */ for (i = 0; i < shared; i++) { - int ref = fz_read_bits(stream, shared_obj_num_bits); + int ref = fz_read_bits(ctx, stream, shared_obj_num_bits); doc->hint_shared_ref[i] = ref; } /* Skip items 5,6,7 as we don't use them */ - fz_seek(stream, shared_hint_offset, SEEK_SET); + fz_seek(ctx, stream, shared_hint_offset, SEEK_SET); /* Read the shared object hints table: Header first */ - shared_obj_num = fz_read_bits(stream, 32); - shared_obj_offset = fz_read_bits(stream, 32); + shared_obj_num = fz_read_bits(ctx, stream, 32); + shared_obj_offset = fz_read_bits(ctx, stream, 32); if (shared_obj_offset > doc->hint_object_offset) shared_obj_offset += doc->hint_object_length; - shared_obj_count_page1 = fz_read_bits(stream, 32); - shared_obj_count_total = fz_read_bits(stream, 32); - shared_obj_num_bits = fz_read_bits(stream, 16); - least_shared_group_len = fz_read_bits(stream, 32); - shared_group_len_num_bits = fz_read_bits(stream, 16); + shared_obj_count_page1 = fz_read_bits(ctx, stream, 32); + shared_obj_count_total = fz_read_bits(ctx, stream, 32); + shared_obj_num_bits = fz_read_bits(ctx, stream, 16); + least_shared_group_len = fz_read_bits(ctx, stream, 32); + shared_group_len_num_bits = fz_read_bits(ctx, stream, 16); /* Sanity check the references in Item 4 above to ensure we * don't access out of range with malicious files. */ @@ -2479,7 +2436,7 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) j = doc->hint_page[0].offset; for (i = 0; i < shared_obj_count_page1; i++) { - int off = fz_read_bits(stream, shared_group_len_num_bits); + int off = fz_read_bits(ctx, stream, shared_group_len_num_bits); int old = j; doc->hint_shared[i].offset = j; j += off + least_shared_group_len; @@ -2492,7 +2449,7 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) j = shared_obj_offset; for (; i < shared_obj_count_total; i++) { - int off = fz_read_bits(stream, shared_group_len_num_bits); + int off = fz_read_bits(ctx, stream, shared_group_len_num_bits); int old = j; doc->hint_shared[i].offset = j; j += off + least_shared_group_len; @@ -2500,34 +2457,34 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) j += doc->hint_object_length; } doc->hint_shared[i].offset = j; - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 2: Signature flags: read these just so we can skip */ for (i = 0; i < shared_obj_count_total; i++) { - doc->hint_shared[i].number = fz_read_bits(stream, 1); + doc->hint_shared[i].number = fz_read_bits(ctx, stream, 1); } - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 3: Signatures: just skip */ for (i = 0; i < shared_obj_count_total; i++) { if (doc->hint_shared[i].number) { - (void) fz_read_bits(stream, 128); + (void) fz_read_bits(ctx, stream, 128); } } - fz_sync_bits(stream); + fz_sync_bits(ctx, stream); /* Item 4: Shared object object numbers */ j = doc->linear_page1_obj_num; /* FIXME: This is a lie! */ for (i = 0; i < shared_obj_count_page1; i++) { doc->hint_shared[i].number = j; - j += fz_read_bits(stream, shared_obj_num_bits) + 1; + j += fz_read_bits(ctx, stream, shared_obj_num_bits) + 1; } j = shared_obj_num; for (; i < shared_obj_count_total; i++) { doc->hint_shared[i].number = j; - j += fz_read_bits(stream, shared_obj_num_bits) + 1; + j += fz_read_bits(ctx, stream, shared_obj_num_bits) + 1; } doc->hint_shared[i].number = j; @@ -2543,7 +2500,7 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) } fz_always(ctx) { - fz_drop_stream(stream); + fz_drop_stream(ctx, stream); } fz_catch(ctx) { @@ -2559,14 +2516,13 @@ pdf_load_hints(pdf_document *doc, int objnum, int gennum) } static void -pdf_load_hint_object(pdf_document *doc) +pdf_load_hint_object(fz_context *ctx, pdf_document *doc) { - fz_context *ctx = doc->ctx; pdf_lexbuf *buf = &doc->lexbuf.base; int curr_pos; - curr_pos = fz_tell(doc->file); - fz_seek(doc->file, doc->hint_object_offset, SEEK_SET); + curr_pos = fz_tell(ctx, doc->file); + fz_seek(ctx, doc->file, doc->hint_object_offset, SEEK_SET); fz_try(ctx) { while (1) @@ -2574,24 +2530,24 @@ pdf_load_hint_object(pdf_document *doc) pdf_obj *page = NULL; int tmpofs, num, gen, tok; - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, doc->file, buf); if (tok != PDF_TOK_INT) break; num = buf->i; - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, doc->file, buf); if (tok != PDF_TOK_INT) break; gen = buf->i; - tok = pdf_lex(doc->file, buf); + tok = pdf_lex(ctx, doc->file, buf); if (tok != PDF_TOK_OBJ) break; - (void)pdf_repair_obj(doc, buf, &tmpofs, NULL, NULL, NULL, &page, &tmpofs); - pdf_load_hints(doc, num, gen); + (void)pdf_repair_obj(ctx, doc, buf, &tmpofs, NULL, NULL, NULL, &page, &tmpofs); + pdf_load_hints(ctx, doc, num, gen); } } fz_always(ctx) { - fz_seek(doc->file, curr_pos, SEEK_SET); + fz_seek(ctx, doc->file, curr_pos, SEEK_SET); } fz_catch(ctx) { @@ -2599,17 +2555,16 @@ pdf_load_hint_object(pdf_document *doc) } } -pdf_obj *pdf_progressive_advance(pdf_document *doc, int pagenum) +pdf_obj *pdf_progressive_advance(fz_context *ctx, pdf_document *doc, int pagenum) { - fz_context *ctx = doc->ctx; pdf_lexbuf *buf = &doc->lexbuf.base; int curr_pos; pdf_obj *page; - pdf_load_hinted_page(doc, pagenum); + pdf_load_hinted_page(ctx, doc, pagenum); if (pagenum < 0 || pagenum >= doc->page_count) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "page load out of range (%d of %d)", pagenum, doc->page_count); + fz_throw(ctx, FZ_ERROR_GENERIC, "page load out of range (%d of %d)", pagenum, doc->page_count); if (doc->linear_pos == doc->file_length) return doc->linear_page_refs[pagenum]; @@ -2618,11 +2573,11 @@ pdf_obj *pdf_progressive_advance(pdf_document *doc, int pagenum) if (pagenum > 0 && !doc->hints_loaded && doc->hint_object_offset > 0 && doc->linear_pos >= doc->hint_object_offset) { /* Found hint object */ - pdf_load_hint_object(doc); + pdf_load_hint_object(ctx, doc); } DEBUGMESS((ctx, "continuing to try to advance from %d", doc->linear_pos)); - curr_pos = fz_tell(doc->file); + curr_pos = fz_tell(ctx, doc->file); fz_var(page); @@ -2633,8 +2588,8 @@ pdf_obj *pdf_progressive_advance(pdf_document *doc, int pagenum) { int num; page = NULL; - eof = pdf_obj_read(doc, &doc->linear_pos, &num, &page); - pdf_drop_obj(page); + eof = pdf_obj_read(ctx, doc, &doc->linear_pos, &num, &page); + pdf_drop_obj(ctx, page); page = NULL; } while (!eof); @@ -2643,22 +2598,22 @@ pdf_obj *pdf_progressive_advance(pdf_document *doc, int pagenum) pdf_obj *catalog; pdf_obj *pages; doc->linear_pos = doc->file_length; - pdf_load_xref(doc, buf); - catalog = pdf_dict_gets(pdf_trailer(doc), "Root"); - pages = pdf_dict_gets(catalog, "Pages"); + pdf_load_xref(ctx, doc, buf); + catalog = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pages = pdf_dict_gets(ctx, catalog, "Pages"); - if (!pdf_is_dict(pages)) + if (!pdf_is_dict(ctx, pages)) fz_throw(ctx, FZ_ERROR_GENERIC, "missing page tree"); break; } } fz_always(ctx) { - fz_seek(doc->file, curr_pos, SEEK_SET); + fz_seek(ctx, doc->file, curr_pos, SEEK_SET); } fz_catch(ctx) { - pdf_drop_obj(page); + pdf_drop_obj(ctx, page); if (fz_caught(ctx) == FZ_ERROR_TRYLATER) { if (doc->linear_page_refs[pagenum] == NULL) @@ -2674,7 +2629,7 @@ pdf_obj *pdf_progressive_advance(pdf_document *doc, int pagenum) return doc->linear_page_refs[pagenum]; } -pdf_document *pdf_specifics(fz_document *doc) +pdf_document *pdf_specifics(fz_context *ctx, fz_document *doc) { return (pdf_document *)((doc && doc->close == (fz_document_close_fn *)pdf_close_document) ? doc : NULL); } @@ -2697,29 +2652,29 @@ pdf_document *pdf_create_document(fz_context *ctx) doc->file_size = 0; doc->startxref = 0; doc->num_xref_sections = 0; - pdf_get_populating_xref_entry(doc, 0); + pdf_get_populating_xref_entry(ctx, doc, 0); doc->xref_altered = 1; - trailer = pdf_new_dict(doc, 2); - pdf_dict_puts_drop(trailer, "Size", pdf_new_int(doc, 3)); - o = root = pdf_new_dict(doc, 2); - pdf_dict_puts_drop(trailer, "Root", pdf_new_ref(doc, o)); - pdf_drop_obj(o); + trailer = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts_drop(ctx, trailer, "Size", pdf_new_int(ctx, doc, 3)); + o = root = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts_drop(ctx, trailer, "Root", pdf_new_ref(ctx, doc, o)); + pdf_drop_obj(ctx, o); o = NULL; - pdf_dict_puts_drop(root, "Type", pdf_new_name(doc, "Catalog")); - o = pages = pdf_new_dict(doc, 3); - pdf_dict_puts_drop(root, "Pages", pdf_new_ref(doc, o)); - pdf_drop_obj(o); + pdf_dict_puts_drop(ctx, root, "Type", pdf_new_name(ctx, doc, "Catalog")); + o = pages = pdf_new_dict(ctx, doc, 3); + pdf_dict_puts_drop(ctx, root, "Pages", pdf_new_ref(ctx, doc, o)); + pdf_drop_obj(ctx, o); o = NULL; - pdf_dict_puts_drop(pages, "Type", pdf_new_name(doc, "Pages")); - pdf_dict_puts_drop(pages, "Count", pdf_new_int(doc, 0)); - pdf_dict_puts_drop(pages, "Kids", pdf_new_array(doc, 1)); - pdf_set_populating_xref_trailer(doc, trailer); - pdf_drop_obj(trailer); + pdf_dict_puts_drop(ctx, pages, "Type", pdf_new_name(ctx, doc, "Pages")); + pdf_dict_puts_drop(ctx, pages, "Count", pdf_new_int(ctx, doc, 0)); + pdf_dict_puts_drop(ctx, pages, "Kids", pdf_new_array(ctx, doc, 1)); + pdf_set_populating_xref_trailer(ctx, doc, trailer); + pdf_drop_obj(ctx, trailer); } fz_catch(ctx) { - pdf_drop_obj(trailer); - pdf_drop_obj(o); + pdf_drop_obj(ctx, trailer); + pdf_drop_obj(ctx, o); fz_rethrow_message(ctx, "Failed to create empty document"); } return doc; @@ -2748,7 +2703,7 @@ fz_document_handler pdf_no_run_document_handler = (fz_document_open_with_stream_fn *)&pdf_open_document_no_run_with_stream }; -void pdf_mark_xref(pdf_document *doc) +void pdf_mark_xref(fz_context *ctx, pdf_document *doc) { int x, e; @@ -2771,7 +2726,7 @@ void pdf_mark_xref(pdf_document *doc) } } -void pdf_clear_xref(pdf_document *doc) +void pdf_clear_xref(fz_context *ctx, pdf_document *doc) { int x, e; @@ -2789,9 +2744,9 @@ void pdf_clear_xref(pdf_document *doc) * buffer has been updated */ if (entry->obj != NULL && entry->stm_buf == NULL) { - if (pdf_obj_refs(entry->obj) == 1) + if (pdf_obj_refs(ctx, entry->obj) == 1) { - pdf_drop_obj(entry->obj); + pdf_drop_obj(ctx, entry->obj); entry->obj = NULL; } } @@ -2800,7 +2755,7 @@ void pdf_clear_xref(pdf_document *doc) } } -void pdf_clear_xref_to_mark(pdf_document *doc) +void pdf_clear_xref_to_mark(fz_context *ctx, pdf_document *doc) { int x, e; @@ -2819,9 +2774,9 @@ void pdf_clear_xref_to_mark(pdf_document *doc) * been updated */ if (entry->obj != NULL && entry->stm_buf == NULL) { - if ((entry->flags & PDF_OBJ_FLAG_MARK) == 0 && pdf_obj_refs(entry->obj) == 1) + if ((entry->flags & PDF_OBJ_FLAG_MARK) == 0 && pdf_obj_refs(ctx, entry->obj) == 1) { - pdf_drop_obj(entry->obj); + pdf_drop_obj(ctx, entry->obj); entry->obj = NULL; } } diff --git a/source/tools/mjsgen.c b/source/tools/mjsgen.c index cb4c1f1c..d1366062 100644 --- a/source/tools/mjsgen.c +++ b/source/tools/mjsgen.c @@ -100,14 +100,14 @@ static void processpage(fz_context *ctx, fz_document *doc, int pagenum) fz_try(ctx) { - page = fz_load_page(doc, pagenum - 1); + 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(doc); + pdf_document *inter = pdf_specifics(ctx, doc); pdf_widget *widget = NULL; if (inter) @@ -220,7 +220,7 @@ static void processpage(fz_context *ctx, fz_document *doc, int pagenum) static void processpages(fz_context *ctx, fz_document *doc) { int page, pagecount; - pagecount = fz_count_pages(doc); + pagecount = fz_count_pages(ctx, doc); for (page = 1; page <= pagecount; ++page) processpage(ctx, doc, page); } @@ -232,7 +232,7 @@ int main(int argc, char **argv) fz_context *ctx; int c; - fz_var(doc); + fz_var(ctx, doc); while ((c = fz_getopt(argc, argv, "p:")) != -1) { @@ -269,7 +269,7 @@ int main(int argc, char **argv) if (fz_needs_password(doc)) { - if (!fz_authenticate_password(doc, password)) + 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); } @@ -278,7 +278,7 @@ int main(int argc, char **argv) processpages(ctx, doc); - fz_drop_document(doc); + fz_drop_document(ctx, doc); } fz_catch(ctx) { diff --git a/source/tools/mudraw.c b/source/tools/mudraw.c index 7f93d492..b2feccf6 100644 --- a/source/tools/mudraw.c +++ b/source/tools/mudraw.c @@ -212,7 +212,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) fz_try(ctx) { - page = fz_load_page(doc, pagenum - 1); + page = fz_load_page(ctx, doc, pagenum - 1); } fz_catch(ctx) { @@ -225,17 +225,17 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) { list = fz_new_display_list(ctx); dev = fz_new_list_device(ctx, list); - fz_run_page(doc, page, dev, &fz_identity, &cookie); + fz_run_page(ctx, page, dev, &fz_identity, &cookie); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow_message(ctx, "cannot draw page %d in file '%s'", pagenum, filename); } } @@ -246,19 +246,19 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) { dev = fz_new_trace_device(ctx); if (list) - fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie); + fz_run_display_list(ctx, list, dev, &fz_identity, &fz_infinite_rect, &cookie); else - fz_run_page(doc, page, dev, &fz_identity, &cookie); + fz_run_page(ctx, page, dev, &fz_identity, &cookie); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow(ctx); } } @@ -274,12 +274,12 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) text = fz_new_text_page(ctx); dev = fz_new_text_device(ctx, sheet, text); if (showtext == TEXT_HTML) - fz_disable_device_hints(dev, FZ_IGNORE_IMAGE); + fz_disable_device_hints(ctx, dev, FZ_IGNORE_IMAGE); if (list) - fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie); + fz_run_display_list(ctx, list, dev, &fz_identity, &fz_infinite_rect, &cookie); else - fz_run_page(doc, page, dev, &fz_identity, &cookie); - fz_drop_device(dev); + fz_run_page(ctx, page, dev, &fz_identity, &cookie); + fz_drop_device(ctx, dev); dev = NULL; if (showtext == TEXT_XML) { @@ -293,19 +293,19 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) else if (showtext == TEXT_PLAIN) { fz_print_text_page(ctx, out, text); - fz_printf(out, "\f\n"); + fz_printf(ctx, out, "\f\n"); } } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; fz_drop_text_page(ctx, text); } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow(ctx); } } @@ -320,13 +320,13 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) fz_try(ctx) { if (list) - fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, NULL); + fz_run_display_list(ctx, list, dev, &fz_identity, &fz_infinite_rect, NULL); else - fz_run_page(doc, page, dev, &fz_identity, &cookie); + fz_run_page(ctx, page, dev, &fz_identity, &cookie); } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; } fz_catch(ctx) @@ -342,36 +342,36 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) fz_rect bounds, tbounds; pdf_page *newpage; - fz_bound_page(doc, page, &bounds); + fz_bound_page(ctx, page, &bounds); fz_rotate(&ctm, rotation); tbounds = bounds; fz_transform_rect(&tbounds, &ctm); - newpage = pdf_create_page(pdfout, bounds, 72, 0); + newpage = pdf_create_page(ctx, pdfout, bounds, 72, 0); fz_try(ctx) { - dev = pdf_page_write(pdfout, newpage); + dev = pdf_page_write(ctx, pdfout, newpage); if (list) - fz_run_display_list(list, dev, &ctm, &tbounds, &cookie); + fz_run_display_list(ctx, list, dev, &ctm, &tbounds, &cookie); else - fz_run_page(doc, page, dev, &ctm, &cookie); - fz_drop_device(dev); + fz_run_page(ctx, page, dev, &ctm, &cookie); + fz_drop_device(ctx, dev); dev = NULL; } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow(ctx); } - pdf_insert_page(pdfout, newpage, INT_MAX); - pdf_drop_page(pdfout, newpage); + pdf_insert_page(ctx, pdfout, newpage, INT_MAX); + fz_drop_page(ctx, &newpage->super); } if (output && output_format == OUT_SVG) @@ -393,9 +393,9 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot open file '%s': %s", buf, strerror(errno)); } - out = fz_new_output_with_file(ctx, file); + out = fz_new_output_with_file(ctx, file, 0); - fz_bound_page(doc, page, &bounds); + fz_bound_page(ctx, page, &bounds); zoom = resolution / 72; fz_pre_rotate(fz_scale(&ctm, zoom, zoom), rotation); tbounds = bounds; @@ -405,24 +405,24 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) { dev = fz_new_svg_device(ctx, out, tbounds.x1-tbounds.x0, tbounds.y1-tbounds.y0); if (list) - fz_run_display_list(list, dev, &ctm, &tbounds, &cookie); + fz_run_display_list(ctx, list, dev, &ctm, &tbounds, &cookie); else - fz_run_page(doc, page, dev, &ctm, &cookie); - fz_drop_device(dev); + fz_run_page(ctx, page, dev, &ctm, &cookie); + fz_drop_device(ctx, dev); dev = NULL; } fz_always(ctx) { - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; - fz_drop_output(out); + fz_drop_output(ctx, out); if (file != stdout) fclose(file); } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow(ctx); } } @@ -441,7 +441,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) fz_var(pix); fz_var(poc); - fz_bound_page(doc, page, &bounds); + fz_bound_page(ctx, page, &bounds); zoom = resolution / 72; fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom); tbounds = bounds; @@ -527,7 +527,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) if (output) { if (!strcmp(output, "-")) - output_file = fz_new_output_with_file(ctx, stdout); + output_file = fz_new_output_with_file(ctx, stdout, 0); else { sprintf(filename_buf, output, pagenum); @@ -535,11 +535,11 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) } if (output_format == OUT_PGM || output_format == OUT_PPM || output_format == OUT_PNM) - fz_output_pnm_header(output_file, pix->w, totalheight, pix->n); + fz_output_pnm_header(ctx, output_file, pix->w, totalheight, pix->n); else if (output_format == OUT_PAM) - fz_output_pam_header(output_file, pix->w, totalheight, pix->n, savealpha); + fz_output_pam_header(ctx, output_file, pix->w, totalheight, pix->n, savealpha); else if (output_format == OUT_PNG) - poc = fz_output_png_header(output_file, pix->w, totalheight, pix->n, savealpha); + poc = fz_output_png_header(ctx, output_file, pix->w, totalheight, pix->n, savealpha); } for (band = 0; band < bands; band++) @@ -551,12 +551,12 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) dev = fz_new_draw_device(ctx, pix); if (alphabits == 0) - fz_enable_device_hints(dev, FZ_DONT_INTERPOLATE_IMAGES); + fz_enable_device_hints(ctx, dev, FZ_DONT_INTERPOLATE_IMAGES); if (list) - fz_run_display_list(list, dev, &ctm, &tbounds, &cookie); + fz_run_display_list(ctx, list, dev, &ctm, &tbounds, &cookie); else - fz_run_page(doc, page, dev, &ctm, &cookie); - fz_drop_device(dev); + fz_run_page(ctx, page, dev, &ctm, &cookie); + fz_drop_device(ctx, dev); dev = NULL; if (invert) @@ -570,11 +570,11 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) if (output) { if (output_format == OUT_PGM || output_format == OUT_PPM || output_format == OUT_PNM) - fz_output_pnm_band(output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples); + fz_output_pnm_band(ctx, output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples); else if (output_format == OUT_PAM) - fz_output_pam_band(output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples, savealpha); + fz_output_pam_band(ctx, output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples, savealpha); else if (output_format == OUT_PNG) - fz_output_png_band(output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples, savealpha, poc); + fz_output_png_band(ctx, output_file, pix->w, totalheight, pix->n, band, drawheight, pix->samples, savealpha, poc); else if (output_format == OUT_PWG) { if (strstr(output, "%d") != NULL) @@ -625,7 +625,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) unsigned char digest[16]; int i; - fz_md5_pixmap(pix, digest); + fz_md5_pixmap(ctx, pix, digest); printf(" "); for (i = 0; i < 16; i++) printf("%02x", digest[i]); @@ -636,19 +636,19 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) if (output) { if (output_format == OUT_PNG) - fz_output_png_trailer(output_file, poc); + fz_output_png_trailer(ctx, output_file, poc); } - fz_drop_device(dev); + fz_drop_device(ctx, dev); dev = NULL; fz_drop_pixmap(ctx, pix); if (output_file) - fz_drop_output(output_file); + fz_drop_output(ctx, output_file); } fz_catch(ctx) { fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); fz_rethrow(ctx); } } @@ -656,7 +656,7 @@ static void drawpage(fz_context *ctx, fz_document *doc, int pagenum) if (list) fz_drop_display_list(ctx, list); - fz_free_page(doc, page); + fz_drop_page(ctx, page); if (showtime) { @@ -700,7 +700,7 @@ static void drawrange(fz_context *ctx, fz_document *doc, char *range) int page, spage, epage, pagecount; char *spec, *dash; - pagecount = fz_count_pages(doc); + pagecount = fz_count_pages(ctx, doc); spec = fz_strsep(&range, ","); while (spec) { @@ -735,13 +735,13 @@ static void drawrange(fz_context *ctx, fz_document *doc, char *range) static void drawoutline(fz_context *ctx, fz_document *doc) { - fz_outline *outline = fz_load_outline(doc); + fz_outline *outline = fz_load_outline(ctx, doc); fz_output *out = NULL; fz_var(out); fz_try(ctx) { - out = fz_new_output_with_file(ctx, stdout); + out = fz_new_output_with_file(ctx, stdout, 0); if (showoutline > 1) fz_print_outline_xml(ctx, out, outline); else @@ -749,7 +749,7 @@ static void drawoutline(fz_context *ctx, fz_document *doc) } fz_always(ctx) { - fz_drop_output(out); + fz_drop_output(ctx, out); fz_drop_outline(ctx, outline); } fz_catch(ctx) @@ -1002,26 +1002,26 @@ int main(int argc, char **argv) timing.maxfilename = ""; if (showxml || showtext) - out = fz_new_output_with_file(ctx, stdout); + out = fz_new_output_with_file(ctx, stdout, 0); if (showxml || showtext == TEXT_XML) - fz_printf(out, "<?xml version=\"1.0\"?>\n"); + fz_printf(ctx, out, "<?xml version=\"1.0\"?>\n"); if (showtext) sheet = fz_new_text_sheet(ctx); if (showtext == TEXT_HTML) { - fz_printf(out, "<style>\n"); - fz_printf(out, "body{background-color:gray;margin:12pt;}\n"); - fz_printf(out, "div.page{background-color:white;margin:6pt;padding:6pt;}\n"); - fz_printf(out, "div.block{border:1px solid gray;margin:6pt;padding:6pt;}\n"); - fz_printf(out, "div.metaline{display:table;width:100%%}\n"); - fz_printf(out, "div.line{display:table-row;padding:6pt}\n"); - fz_printf(out, "div.cell{display:table-cell;padding-left:6pt;padding-right:6pt}\n"); - fz_printf(out, "p{margin:0pt;padding:0pt;}\n"); - fz_printf(out, "</style>\n"); - fz_printf(out, "<body>\n"); + fz_printf(ctx, out, "<style>\n"); + fz_printf(ctx, out, "body{background-color:gray;margin:12pt;}\n"); + fz_printf(ctx, out, "div.page{background-color:white;margin:6pt;padding:6pt;}\n"); + fz_printf(ctx, out, "div.block{border:1px solid gray;margin:6pt;padding:6pt;}\n"); + fz_printf(ctx, out, "div.metaline{display:table;width:100%%}\n"); + fz_printf(ctx, out, "div.line{display:table-row;padding:6pt}\n"); + fz_printf(ctx, out, "div.cell{display:table-cell;padding-left:6pt;padding-right:6pt}\n"); + fz_printf(ctx, out, "p{margin:0pt;padding:0pt;}\n"); + fz_printf(ctx, out, "</style>\n"); + fz_printf(ctx, out, "<body>\n"); } fz_try(ctx) @@ -1044,14 +1044,14 @@ int main(int argc, char **argv) fz_rethrow_message(ctx, "cannot open document: %s", filename); } - if (fz_needs_password(doc)) + if (fz_needs_password(ctx, doc)) { - if (!fz_authenticate_password(doc, password)) + if (!fz_authenticate_password(ctx, doc, password)) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", filename); } if (showxml || showtext == TEXT_XML) - fz_printf(out, "<document name=\"%s\">\n", filename); + fz_printf(ctx, out, "<document name=\"%s\">\n", filename); if (showoutline) drawoutline(ctx, doc); @@ -1065,9 +1065,9 @@ int main(int argc, char **argv) } if (showxml || showtext == TEXT_XML) - fz_printf(out, "</document>\n"); + fz_printf(ctx, out, "</document>\n"); - fz_drop_document(doc); + fz_drop_document(ctx, doc); doc = NULL; } fz_catch(ctx) @@ -1075,7 +1075,7 @@ int main(int argc, char **argv) if (!ignore_errors) fz_rethrow(ctx); - fz_drop_document(doc); + fz_drop_document(ctx, doc); doc = NULL; fz_warn(ctx, "ignoring error in '%s'", filename); } @@ -1083,7 +1083,7 @@ int main(int argc, char **argv) } fz_catch(ctx) { - fz_drop_document(doc); + fz_drop_document(ctx, doc); fprintf(stderr, "error: cannot draw '%s'\n", filename); errored = 1; } @@ -1092,16 +1092,16 @@ int main(int argc, char **argv) { fz_write_options opts = { 0 }; - pdf_write_document(pdfout, output, &opts); - pdf_close_document(pdfout); + pdf_write_document(ctx, pdfout, output, &opts); + pdf_close_document(ctx, pdfout); } if (showtext == TEXT_HTML) { - fz_printf(out, "</body>\n"); - fz_printf(out, "<style>\n"); + fz_printf(ctx, out, "</body>\n"); + fz_printf(ctx, out, "<style>\n"); fz_print_text_sheet(ctx, out, sheet); - fz_printf(out, "</style>\n"); + fz_printf(ctx, out, "</style>\n"); } if (showtext) @@ -1109,7 +1109,7 @@ int main(int argc, char **argv) if (showxml || showtext) { - fz_drop_output(out); + fz_drop_output(ctx, out); out = NULL; } diff --git a/source/tools/pdfclean.c b/source/tools/pdfclean.c index bfeca0e4..07ca7e5a 100644 --- a/source/tools/pdfclean.c +++ b/source/tools/pdfclean.c @@ -36,15 +36,15 @@ static void usage(void) } static int -string_in_names_list(pdf_obj *p, pdf_obj *names_list) +string_in_names_list(fz_context *ctx, pdf_obj *p, pdf_obj *names_list) { - int n = pdf_array_len(names_list); + int n = pdf_array_len(ctx, names_list); int i; - char *str = pdf_to_str_buf(p); + char *str = pdf_to_str_buf(ctx, p); for (i = 0; i < n ; i += 2) { - if (!strcmp(pdf_to_str_buf(pdf_array_get(names_list, i)), str)) + if (!strcmp(pdf_to_str_buf(ctx, pdf_array_get(ctx, names_list, i)), str)) return 1; } return 0; @@ -54,18 +54,18 @@ string_in_names_list(pdf_obj *p, pdf_obj *names_list) * Recreate page tree to only retain specified pages. */ -static void retainpage(pdf_document *doc, pdf_obj *parent, pdf_obj *kids, int page) +static void retainpage(fz_context *ctx, pdf_document *doc, pdf_obj *parent, pdf_obj *kids, int page) { - pdf_obj *pageref = pdf_lookup_page_obj(doc, page-1); - pdf_obj *pageobj = pdf_resolve_indirect(pageref); + pdf_obj *pageref = pdf_lookup_page_obj(ctx, doc, page-1); + pdf_obj *pageobj = pdf_resolve_indirect(ctx, pageref); - pdf_dict_puts(pageobj, "Parent", parent); + pdf_dict_puts(ctx, pageobj, "Parent", parent); /* Store page object in new kids array */ - pdf_array_push(kids, pageref); + pdf_array_push(ctx, kids, pageref); } -static void retainpages(globals *glo, int argc, char **argv) +static void retainpages(fz_context *ctx, globals *glo, int argc, char **argv) { pdf_obj *oldroot, *root, *pages, *kids, *countobj, *parent, *olddests; pdf_document *doc = glo->doc; @@ -76,21 +76,21 @@ static void retainpages(globals *glo, int argc, char **argv) /* Keep only pages/type and (reduced) dest entries to avoid * references to unretained pages */ - oldroot = pdf_dict_gets(pdf_trailer(doc), "Root"); - pages = pdf_dict_gets(oldroot, "Pages"); - olddests = pdf_load_name_tree(doc, "Dests"); + oldroot = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pages = pdf_dict_gets(ctx, oldroot, "Pages"); + olddests = pdf_load_name_tree(ctx, doc, "Dests"); - root = pdf_new_dict(doc, 2); - pdf_dict_puts(root, "Type", pdf_dict_gets(oldroot, "Type")); - pdf_dict_puts(root, "Pages", pdf_dict_gets(oldroot, "Pages")); + root = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts(ctx, root, "Type", pdf_dict_gets(ctx, oldroot, "Type")); + pdf_dict_puts(ctx, root, "Pages", pdf_dict_gets(ctx, oldroot, "Pages")); - pdf_update_object(doc, pdf_to_num(oldroot), root); + pdf_update_object(ctx, doc, pdf_to_num(ctx, oldroot), root); - pdf_drop_obj(root); + pdf_drop_obj(ctx, root); /* Create a new kids array with only the pages we want to keep */ - parent = pdf_new_indirect(doc, pdf_to_num(pages), pdf_to_gen(pages)); - kids = pdf_new_array(doc, 1); + parent = pdf_new_indirect(ctx, doc, pdf_to_num(ctx, pages), pdf_to_gen(ctx, pages)); + kids = pdf_new_array(ctx, doc, 1); /* Retain pages specified */ while (argc - argidx) @@ -99,7 +99,7 @@ static void retainpages(globals *glo, int argc, char **argv) char *spec, *dash; char *pagelist = argv[argidx]; - pagecount = pdf_count_pages(doc); + pagecount = pdf_count_pages(ctx, doc); spec = fz_strsep(&pagelist, ","); while (spec) { @@ -123,10 +123,10 @@ static void retainpages(globals *glo, int argc, char **argv) if (spage < epage) for (page = spage; page <= epage; ++page) - retainpage(doc, parent, kids, page); + retainpage(ctx, doc, parent, kids, page); else for (page = spage; page >= epage; --page) - retainpage(doc, parent, kids, page); + retainpage(ctx, doc, parent, kids, page); spec = fz_strsep(&pagelist, ","); } @@ -134,49 +134,49 @@ static void retainpages(globals *glo, int argc, char **argv) argidx++; } - pdf_drop_obj(parent); + pdf_drop_obj(ctx, parent); /* Update page count and kids array */ - countobj = pdf_new_int(doc, pdf_array_len(kids)); - pdf_dict_puts(pages, "Count", countobj); - pdf_drop_obj(countobj); - pdf_dict_puts(pages, "Kids", kids); - pdf_drop_obj(kids); + countobj = pdf_new_int(ctx, doc, pdf_array_len(ctx, kids)); + pdf_dict_puts(ctx, pages, "Count", countobj); + pdf_drop_obj(ctx, countobj); + pdf_dict_puts(ctx, pages, "Kids", kids); + pdf_drop_obj(ctx, kids); /* Also preserve the (partial) Dests name tree */ if (olddests) { - pdf_obj *names = pdf_new_dict(doc, 1); - pdf_obj *dests = pdf_new_dict(doc, 1); - int len = pdf_dict_len(olddests); + pdf_obj *names = pdf_new_dict(ctx, doc, 1); + pdf_obj *dests = pdf_new_dict(ctx, doc, 1); + int len = pdf_dict_len(ctx, olddests); - names_list = pdf_new_array(doc, 32); + names_list = pdf_new_array(ctx, doc, 32); for (i = 0; i < len; i++) { - pdf_obj *key = pdf_dict_get_key(olddests, i); - pdf_obj *val = pdf_dict_get_val(olddests, i); - pdf_obj *dest = pdf_dict_gets(val, "D"); + pdf_obj *key = pdf_dict_get_key(ctx, olddests, i); + pdf_obj *val = pdf_dict_get_val(ctx, olddests, i); + pdf_obj *dest = pdf_dict_gets(ctx, val, "D"); - dest = pdf_array_get(dest ? dest : val, 0); - if (pdf_array_contains(pdf_dict_gets(pages, "Kids"), dest)) + dest = pdf_array_get(ctx, dest ? dest : val, 0); + if (pdf_array_contains(ctx, pdf_dict_gets(ctx, pages, "Kids"), dest)) { - pdf_obj *key_str = pdf_new_string(doc, pdf_to_name(key), strlen(pdf_to_name(key))); - pdf_array_push(names_list, key_str); - pdf_array_push(names_list, val); - pdf_drop_obj(key_str); + pdf_obj *key_str = pdf_new_string(ctx, doc, pdf_to_name(ctx, key), strlen(pdf_to_name(ctx, key))); + pdf_array_push(ctx, names_list, key_str); + pdf_array_push(ctx, names_list, val); + pdf_drop_obj(ctx, key_str); } } - root = pdf_dict_gets(pdf_trailer(doc), "Root"); - pdf_dict_puts(dests, "Names", names_list); - pdf_dict_puts(names, "Dests", dests); - pdf_dict_puts(root, "Names", names); + root = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pdf_dict_puts(ctx, dests, "Names", names_list); + pdf_dict_puts(ctx, names, "Dests", dests); + pdf_dict_puts(ctx, root, "Names", names); - pdf_drop_obj(names); - pdf_drop_obj(dests); - pdf_drop_obj(names_list); - pdf_drop_obj(olddests); + pdf_drop_obj(ctx, names); + pdf_drop_obj(ctx, dests); + pdf_drop_obj(ctx, names_list); + pdf_drop_obj(ctx, olddests); } /* Force the next call to pdf_count_pages to recount */ @@ -184,36 +184,36 @@ static void retainpages(globals *glo, int argc, char **argv) /* Edit each pages /Annot list to remove any links that point to * nowhere. */ - pagecount = pdf_count_pages(doc); + pagecount = pdf_count_pages(ctx, doc); for (i = 0; i < pagecount; i++) { - pdf_obj *pageref = pdf_lookup_page_obj(doc, i); - pdf_obj *pageobj = pdf_resolve_indirect(pageref); + pdf_obj *pageref = pdf_lookup_page_obj(ctx, doc, i); + pdf_obj *pageobj = pdf_resolve_indirect(ctx, pageref); - pdf_obj *annots = pdf_dict_gets(pageobj, "Annots"); + pdf_obj *annots = pdf_dict_gets(ctx, pageobj, "Annots"); - int len = pdf_array_len(annots); + int len = pdf_array_len(ctx, annots); int j; for (j = 0; j < len; j++) { - pdf_obj *o = pdf_array_get(annots, j); + pdf_obj *o = pdf_array_get(ctx, annots, j); pdf_obj *p; - if (strcmp(pdf_to_name(pdf_dict_gets(o, "Subtype")), "Link")) + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, o, "Subtype")), "Link")) continue; - p = pdf_dict_gets(o, "A"); - if (strcmp(pdf_to_name(pdf_dict_gets(p, "S")), "GoTo")) + p = pdf_dict_gets(ctx, o, "A"); + if (strcmp(pdf_to_name(ctx, pdf_dict_gets(ctx, p, "S")), "GoTo")) continue; - if (string_in_names_list(pdf_dict_gets(p, "D"), names_list)) + if (string_in_names_list(ctx, pdf_dict_gets(ctx, p, "D"), names_list)) continue; /* FIXME: Should probably look at Next too */ /* Remove this annotation */ - pdf_array_delete(annots, j); + pdf_array_delete(ctx, annots, j); j--; } } @@ -228,19 +228,19 @@ void pdfclean_clean(fz_context *ctx, char *infile, char *outfile, char *password fz_try(ctx) { glo.doc = pdf_open_document_no_run(ctx, infile); - if (pdf_needs_password(glo.doc)) - if (!pdf_authenticate_password(glo.doc, password)) + if (pdf_needs_password(ctx, glo.doc)) + if (!pdf_authenticate_password(ctx, glo.doc, password)) fz_throw(glo.ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", infile); /* Only retain the specified subset of the pages */ if (argc) - retainpages(&glo, argc, argv); + retainpages(ctx, &glo, argc, argv); - pdf_write_document(glo.doc, outfile, opts); + pdf_write_document(ctx, glo.doc, outfile, opts); } fz_always(ctx) { - pdf_close_document(glo.doc); + pdf_close_document(ctx, glo.doc); } fz_catch(ctx) { diff --git a/source/tools/pdfextract.c b/source/tools/pdfextract.c index 0c7463f7..ce293cfd 100644 --- a/source/tools/pdfextract.c +++ b/source/tools/pdfextract.c @@ -18,14 +18,14 @@ static void usage(void) static int isimage(pdf_obj *obj) { - pdf_obj *type = pdf_dict_gets(obj, "Subtype"); - return pdf_is_name(type) && !strcmp(pdf_to_name(type), "Image"); + pdf_obj *type = pdf_dict_gets(ctx, obj, "Subtype"); + return pdf_is_name(ctx, type) && !strcmp(pdf_to_name(ctx, type), "Image"); } static int isfontdesc(pdf_obj *obj) { - pdf_obj *type = pdf_dict_gets(obj, "Type"); - return pdf_is_name(type) && !strcmp(pdf_to_name(type), "FontDescriptor"); + pdf_obj *type = pdf_dict_gets(ctx, obj, "Type"); + return pdf_is_name(ctx, type) && !strcmp(pdf_to_name(ctx, type), "FontDescriptor"); } static void writepixmap(fz_context *ctx, fz_pixmap *pix, char *file, int rgb) @@ -67,11 +67,11 @@ static void saveimage(int num) pdf_obj *ref; char buf[32]; - ref = pdf_new_indirect(doc, num, 0); + ref = pdf_new_indirect(ctx, doc, num, 0); /* TODO: detect DCTD and save as jpeg */ - image = pdf_load_image(doc, ref); + image = pdf_load_image(ctx, doc, ref); pix = fz_new_pixmap_from_image(ctx, image, 0, 0); fz_drop_image(ctx, image); @@ -79,7 +79,7 @@ static void saveimage(int num) writepixmap(ctx, pix, buf, dorgb); fz_drop_pixmap(ctx, pix); - pdf_drop_obj(ref); + pdf_drop_obj(ctx, ref); } static void savefont(pdf_obj *dict, int num) @@ -95,34 +95,34 @@ static void savefont(pdf_obj *dict, int num) int n, len; unsigned char *data; - obj = pdf_dict_gets(dict, "FontName"); + obj = pdf_dict_gets(ctx, dict, "FontName"); if (obj) - fontname = pdf_to_name(obj); + fontname = pdf_to_name(ctx, obj); - obj = pdf_dict_gets(dict, "FontFile"); + obj = pdf_dict_gets(ctx, dict, "FontFile"); if (obj) { stream = obj; ext = "pfa"; } - obj = pdf_dict_gets(dict, "FontFile2"); + obj = pdf_dict_gets(ctx, dict, "FontFile2"); if (obj) { stream = obj; ext = "ttf"; } - obj = pdf_dict_gets(dict, "FontFile3"); + obj = pdf_dict_gets(ctx, dict, "FontFile3"); if (obj) { stream = obj; - obj = pdf_dict_gets(obj, "Subtype"); - if (obj && !pdf_is_name(obj)) + obj = pdf_dict_gets(ctx, obj, "Subtype"); + if (obj && !pdf_is_name(ctx, obj)) fz_throw(ctx, FZ_ERROR_GENERIC, "invalid font descriptor subtype"); - subtype = pdf_to_name(obj); + subtype = pdf_to_name(ctx, obj); if (!strcmp(subtype, "Type1C")) ext = "cff"; else if (!strcmp(subtype, "CIDFontType0C")) @@ -139,7 +139,7 @@ static void savefont(pdf_obj *dict, int num) return; } - buf = pdf_load_stream(doc, pdf_to_num(stream), pdf_to_gen(stream)); + buf = pdf_load_stream(ctx, doc, pdf_to_num(ctx, stream), pdf_to_gen(ctx, stream)); snprintf(namebuf, sizeof(namebuf), "%s-%04d.%s", fontname, num, ext); printf("extracting font %s\n", namebuf); @@ -168,14 +168,14 @@ static void showobject(int num) fz_try(ctx) { - obj = pdf_load_object(doc, num, 0); + obj = pdf_load_object(ctx, doc, num, 0); if (isimage(obj)) saveimage(num); else if (isfontdesc(obj)) savefont(obj, num); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } fz_catch(ctx) { @@ -212,13 +212,13 @@ int pdfextract_main(int argc, char **argv) } doc = pdf_open_document_no_run(ctx, infile); - if (pdf_needs_password(doc)) - if (!pdf_authenticate_password(doc, password)) + 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(doc); + int len = pdf_count_objects(ctx, doc); for (o = 1; o < len; o++) showobject(o); } @@ -231,7 +231,7 @@ int pdfextract_main(int argc, char **argv) } } - pdf_close_document(doc); + pdf_close_document(ctx, doc); fz_flush_warnings(ctx); fz_drop_context(ctx); return 0; diff --git a/source/tools/pdfinfo.c b/source/tools/pdfinfo.c index 453f271a..41989982 100644 --- a/source/tools/pdfinfo.c +++ b/source/tools/pdfinfo.c @@ -87,62 +87,62 @@ typedef struct globals_s int psobjs; } globals; -static void closexref(globals *glo) +static void closexref(fz_context *ctx, globals *glo) { int i; if (glo->doc) { - pdf_close_document(glo->doc); + pdf_close_document(ctx, glo->doc); glo->doc = NULL; } if (glo->dim) { for (i = 0; i < glo->dims; i++) - fz_free(glo->ctx, glo->dim[i].u.dim.bbox); - fz_free(glo->ctx, glo->dim); + fz_free(ctx, glo->dim[i].u.dim.bbox); + fz_free(ctx, glo->dim); glo->dim = NULL; glo->dims = 0; } if (glo->font) { - fz_free(glo->ctx, glo->font); + fz_free(ctx, glo->font); glo->font = NULL; glo->fonts = 0; } if (glo->image) { - fz_free(glo->ctx, glo->image); + fz_free(ctx, glo->image); glo->image = NULL; glo->images = 0; } if (glo->shading) { - fz_free(glo->ctx, glo->shading); + fz_free(ctx, glo->shading); glo->shading = NULL; glo->shadings = 0; } if (glo->pattern) { - fz_free(glo->ctx, glo->pattern); + fz_free(ctx, glo->pattern); glo->pattern = NULL; glo->patterns = 0; } if (glo->form) { - fz_free(glo->ctx, glo->form); + fz_free(ctx, glo->form); glo->form = NULL; glo->forms = 0; } if (glo->psobj) { - fz_free(glo->ctx, glo->psobj); + fz_free(ctx, glo->psobj); glo->psobj = NULL; glo->psobjs = 0; } @@ -164,48 +164,48 @@ infousage(void) } static void -showglobalinfo(globals *glo) +showglobalinfo(fz_context *ctx, globals *glo) { pdf_obj *obj; fz_output *out = glo->out; pdf_document *doc = glo->doc; - fz_printf(out, "\nPDF-%d.%d\n", doc->version / 10, doc->version % 10); + fz_printf(ctx, out, "\nPDF-%d.%d\n", doc->version / 10, doc->version % 10); - obj = pdf_dict_gets(pdf_trailer(doc), "Info"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Info"); if (obj) { - fz_printf(out, "Info object (%d %d R):\n", pdf_to_num(obj), pdf_to_gen(obj)); - pdf_output_obj(out, pdf_resolve_indirect(obj), 1); + fz_printf(ctx, out, "Info object (%d %d R):\n", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); + pdf_output_obj(ctx, out, pdf_resolve_indirect(ctx, obj), 1); } - obj = pdf_dict_gets(pdf_trailer(doc), "Encrypt"); + obj = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Encrypt"); if (obj) { - fz_printf(out, "\nEncryption object (%d %d R):\n", pdf_to_num(obj), pdf_to_gen(obj)); - pdf_output_obj(out, pdf_resolve_indirect(obj), 1); + fz_printf(ctx, out, "\nEncryption object (%d %d R):\n", pdf_to_num(ctx, obj), pdf_to_gen(ctx, obj)); + pdf_output_obj(ctx, out, pdf_resolve_indirect(ctx, obj), 1); } - fz_printf(out, "\nPages: %d\n\n", glo->pagecount); + fz_printf(ctx, out, "\nPages: %d\n\n", glo->pagecount); } static void -gatherdimensions(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj) +gatherdimensions(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj) { fz_rect bbox; pdf_obj *obj; int j; - obj = pdf_dict_gets(pageobj, "MediaBox"); - if (!pdf_is_array(obj)) + obj = pdf_dict_gets(ctx, pageobj, "MediaBox"); + if (!pdf_is_array(ctx, obj)) return; - pdf_to_rect(glo->ctx, obj, &bbox); + pdf_to_rect(ctx, obj, &bbox); - obj = pdf_dict_gets(pageobj, "UserUnit"); - if (pdf_is_real(obj)) + obj = pdf_dict_gets(ctx, pageobj, "UserUnit"); + if (pdf_is_real(ctx, obj)) { - float unit = pdf_to_real(obj); + float unit = pdf_to_real(ctx, obj); bbox.x0 *= unit; bbox.y0 *= unit; bbox.x1 *= unit; @@ -219,24 +219,24 @@ gatherdimensions(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj) if (j < glo->dims) return; - glo->dim = fz_resize_array(glo->ctx, glo->dim, glo->dims+1, sizeof(struct info)); + glo->dim = fz_resize_array(ctx, glo->dim, glo->dims+1, sizeof(struct info)); glo->dims++; glo->dim[glo->dims - 1].page = page; glo->dim[glo->dims - 1].pageref = pageref; glo->dim[glo->dims - 1].pageobj = pageobj; - glo->dim[glo->dims - 1].u.dim.bbox = fz_malloc(glo->ctx, sizeof(fz_rect)); + glo->dim[glo->dims - 1].u.dim.bbox = fz_malloc(ctx, sizeof(fz_rect)); memcpy(glo->dim[glo->dims - 1].u.dim.bbox, &bbox, sizeof (fz_rect)); return; } static void -gatherfonts(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gatherfonts(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *fontdict = NULL; @@ -245,26 +245,26 @@ gatherfonts(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj pdf_obj *name = NULL; int k; - fontdict = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(fontdict)) + fontdict = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, fontdict)) { - fz_warn(glo->ctx, "not a font dict (%d %d R)", pdf_to_num(fontdict), pdf_to_gen(fontdict)); + fz_warn(ctx, "not a font dict (%d %d R)", pdf_to_num(ctx, fontdict), pdf_to_gen(ctx, fontdict)); continue; } - subtype = pdf_dict_gets(fontdict, "Subtype"); - basefont = pdf_dict_gets(fontdict, "BaseFont"); - if (!basefont || pdf_is_null(basefont)) - name = pdf_dict_gets(fontdict, "Name"); + subtype = pdf_dict_gets(ctx, fontdict, "Subtype"); + basefont = pdf_dict_gets(ctx, fontdict, "BaseFont"); + if (!basefont || pdf_is_null(ctx, basefont)) + name = pdf_dict_gets(ctx, fontdict, "Name"); for (k = 0; k < glo->fonts; k++) - if (!pdf_objcmp(glo->font[k].u.font.obj, fontdict)) + if (!pdf_objcmp(ctx, glo->font[k].u.font.obj, fontdict)) break; if (k < glo->fonts) continue; - glo->font = fz_resize_array(glo->ctx, glo->font, glo->fonts+1, sizeof(struct info)); + glo->font = fz_resize_array(ctx, glo->font, glo->fonts+1, sizeof(struct info)); glo->fonts++; glo->font[glo->fonts - 1].page = page; @@ -277,11 +277,11 @@ gatherfonts(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj } static void -gatherimages(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gatherimages(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *imagedict; @@ -294,46 +294,46 @@ gatherimages(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj pdf_obj *altcs; int k; - imagedict = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(imagedict)) + imagedict = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, imagedict)) { - fz_warn(glo->ctx, "not an image dict (%d %d R)", pdf_to_num(imagedict), pdf_to_gen(imagedict)); + fz_warn(ctx, "not an image dict (%d %d R)", pdf_to_num(ctx, imagedict), pdf_to_gen(ctx, imagedict)); continue; } - type = pdf_dict_gets(imagedict, "Subtype"); - if (strcmp(pdf_to_name(type), "Image")) + type = pdf_dict_gets(ctx, imagedict, "Subtype"); + if (strcmp(pdf_to_name(ctx, type), "Image")) continue; - filter = pdf_dict_gets(imagedict, "Filter"); + filter = pdf_dict_gets(ctx, imagedict, "Filter"); altcs = NULL; - cs = pdf_dict_gets(imagedict, "ColorSpace"); - if (pdf_is_array(cs)) + cs = pdf_dict_gets(ctx, imagedict, "ColorSpace"); + if (pdf_is_array(ctx, cs)) { pdf_obj *cses = cs; - cs = pdf_array_get(cses, 0); - if (pdf_is_name(cs) && (!strcmp(pdf_to_name(cs), "DeviceN") || !strcmp(pdf_to_name(cs), "Separation"))) + cs = pdf_array_get(ctx, cses, 0); + if (pdf_is_name(ctx, cs) && (!strcmp(pdf_to_name(ctx, cs), "DeviceN") || !strcmp(pdf_to_name(ctx, cs), "Separation"))) { - altcs = pdf_array_get(cses, 2); - if (pdf_is_array(altcs)) - altcs = pdf_array_get(altcs, 0); + altcs = pdf_array_get(ctx, cses, 2); + if (pdf_is_array(ctx, altcs)) + altcs = pdf_array_get(ctx, altcs, 0); } } - width = pdf_dict_gets(imagedict, "Width"); - height = pdf_dict_gets(imagedict, "Height"); - bpc = pdf_dict_gets(imagedict, "BitsPerComponent"); + width = pdf_dict_gets(ctx, imagedict, "Width"); + height = pdf_dict_gets(ctx, imagedict, "Height"); + bpc = pdf_dict_gets(ctx, imagedict, "BitsPerComponent"); for (k = 0; k < glo->images; k++) - if (!pdf_objcmp(glo->image[k].u.image.obj, imagedict)) + if (!pdf_objcmp(ctx, glo->image[k].u.image.obj, imagedict)) break; if (k < glo->images) continue; - glo->image = fz_resize_array(glo->ctx, glo->image, glo->images+1, sizeof(struct info)); + glo->image = fz_resize_array(ctx, glo->image, glo->images+1, sizeof(struct info)); glo->images++; glo->image[glo->images - 1].page = page; @@ -350,11 +350,11 @@ gatherimages(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj } static void -gatherforms(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gatherforms(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *xobjdict; @@ -365,33 +365,33 @@ gatherforms(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj pdf_obj *reference; int k; - xobjdict = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(xobjdict)) + xobjdict = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, xobjdict)) { - fz_warn(glo->ctx, "not a xobject dict (%d %d R)", pdf_to_num(xobjdict), pdf_to_gen(xobjdict)); + fz_warn(ctx, "not a xobject dict (%d %d R)", pdf_to_num(ctx, xobjdict), pdf_to_gen(ctx, xobjdict)); continue; } - type = pdf_dict_gets(xobjdict, "Subtype"); - if (strcmp(pdf_to_name(type), "Form")) + type = pdf_dict_gets(ctx, xobjdict, "Subtype"); + if (strcmp(pdf_to_name(ctx, type), "Form")) continue; - subtype = pdf_dict_gets(xobjdict, "Subtype2"); - if (!strcmp(pdf_to_name(subtype), "PS")) + subtype = pdf_dict_gets(ctx, xobjdict, "Subtype2"); + if (!strcmp(pdf_to_name(ctx, subtype), "PS")) continue; - group = pdf_dict_gets(xobjdict, "Group"); - groupsubtype = pdf_dict_gets(group, "S"); - reference = pdf_dict_gets(xobjdict, "Ref"); + group = pdf_dict_gets(ctx, xobjdict, "Group"); + groupsubtype = pdf_dict_gets(ctx, group, "S"); + reference = pdf_dict_gets(ctx, xobjdict, "Ref"); for (k = 0; k < glo->forms; k++) - if (!pdf_objcmp(glo->form[k].u.form.obj, xobjdict)) + if (!pdf_objcmp(ctx, glo->form[k].u.form.obj, xobjdict)) break; if (k < glo->forms) continue; - glo->form = fz_resize_array(glo->ctx, glo->form, glo->forms+1, sizeof(struct info)); + glo->form = fz_resize_array(ctx, glo->form, glo->forms+1, sizeof(struct info)); glo->forms++; glo->form[glo->forms - 1].page = page; @@ -404,11 +404,11 @@ gatherforms(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj } static void -gatherpsobjs(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gatherpsobjs(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *xobjdict; @@ -416,27 +416,27 @@ gatherpsobjs(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj pdf_obj *subtype; int k; - xobjdict = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(xobjdict)) + xobjdict = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, xobjdict)) { - fz_warn(glo->ctx, "not a xobject dict (%d %d R)", pdf_to_num(xobjdict), pdf_to_gen(xobjdict)); + fz_warn(ctx, "not a xobject dict (%d %d R)", pdf_to_num(ctx, xobjdict), pdf_to_gen(ctx, xobjdict)); continue; } - type = pdf_dict_gets(xobjdict, "Subtype"); - subtype = pdf_dict_gets(xobjdict, "Subtype2"); - if (strcmp(pdf_to_name(type), "PS") && - (strcmp(pdf_to_name(type), "Form") || strcmp(pdf_to_name(subtype), "PS"))) + type = pdf_dict_gets(ctx, xobjdict, "Subtype"); + subtype = pdf_dict_gets(ctx, xobjdict, "Subtype2"); + if (strcmp(pdf_to_name(ctx, type), "PS") && + (strcmp(pdf_to_name(ctx, type), "Form") || strcmp(pdf_to_name(ctx, subtype), "PS"))) continue; for (k = 0; k < glo->psobjs; k++) - if (!pdf_objcmp(glo->psobj[k].u.form.obj, xobjdict)) + if (!pdf_objcmp(ctx, glo->psobj[k].u.form.obj, xobjdict)) break; if (k < glo->psobjs) continue; - glo->psobj = fz_resize_array(glo->ctx, glo->psobj, glo->psobjs+1, sizeof(struct info)); + glo->psobj = fz_resize_array(ctx, glo->psobj, glo->psobjs+1, sizeof(struct info)); glo->psobjs++; glo->psobj[glo->psobjs - 1].page = page; @@ -447,39 +447,39 @@ gatherpsobjs(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj } static void -gathershadings(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gathershadings(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *shade; pdf_obj *type; int k; - shade = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(shade)) + shade = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, shade)) { - fz_warn(glo->ctx, "not a shading dict (%d %d R)", pdf_to_num(shade), pdf_to_gen(shade)); + fz_warn(ctx, "not a shading dict (%d %d R)", pdf_to_num(ctx, shade), pdf_to_gen(ctx, shade)); continue; } - type = pdf_dict_gets(shade, "ShadingType"); - if (!pdf_is_int(type) || pdf_to_int(type) < 1 || pdf_to_int(type) > 7) + type = pdf_dict_gets(ctx, shade, "ShadingType"); + if (!pdf_is_int(ctx, type) || pdf_to_int(ctx, type) < 1 || pdf_to_int(ctx, type) > 7) { - fz_warn(glo->ctx, "not a shading type (%d %d R)", pdf_to_num(shade), pdf_to_gen(shade)); + fz_warn(ctx, "not a shading type (%d %d R)", pdf_to_num(ctx, shade), pdf_to_gen(ctx, shade)); type = NULL; } for (k = 0; k < glo->shadings; k++) - if (!pdf_objcmp(glo->shading[k].u.shading.obj, shade)) + if (!pdf_objcmp(ctx, glo->shading[k].u.shading.obj, shade)) break; if (k < glo->shadings) continue; - glo->shading = fz_resize_array(glo->ctx, glo->shading, glo->shadings+1, sizeof(struct info)); + glo->shading = fz_resize_array(ctx, glo->shading, glo->shadings+1, sizeof(struct info)); glo->shadings++; glo->shading[glo->shadings - 1].page = page; @@ -491,11 +491,11 @@ gathershadings(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_o } static void -gatherpatterns(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) +gatherpatterns(fz_context *ctx, globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict) { int i, n; - n = pdf_dict_len(dict); + n = pdf_dict_len(ctx, dict); for (i = 0; i < n; i++) { pdf_obj *patterndict; @@ -505,49 +505,49 @@ gatherpatterns(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_o pdf_obj *shading = NULL; int k; - patterndict = pdf_dict_get_val(dict, i); - if (!pdf_is_dict(patterndict)) + patterndict = pdf_dict_get_val(ctx, dict, i); + if (!pdf_is_dict(ctx, patterndict)) { - fz_warn(glo->ctx, "not a pattern dict (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict)); + fz_warn(ctx, "not a pattern dict (%d %d R)", pdf_to_num(ctx, patterndict), pdf_to_gen(ctx, patterndict)); continue; } - type = pdf_dict_gets(patterndict, "PatternType"); - if (!pdf_is_int(type) || pdf_to_int(type) < 1 || pdf_to_int(type) > 2) + type = pdf_dict_gets(ctx, patterndict, "PatternType"); + if (!pdf_is_int(ctx, type) || pdf_to_int(ctx, type) < 1 || pdf_to_int(ctx, type) > 2) { - fz_warn(glo->ctx, "not a pattern type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict)); + fz_warn(ctx, "not a pattern type (%d %d R)", pdf_to_num(ctx, patterndict), pdf_to_gen(ctx, patterndict)); type = NULL; } - if (pdf_to_int(type) == 1) + if (pdf_to_int(ctx, type) == 1) { - paint = pdf_dict_gets(patterndict, "PaintType"); - if (!pdf_is_int(paint) || pdf_to_int(paint) < 1 || pdf_to_int(paint) > 2) + paint = pdf_dict_gets(ctx, patterndict, "PaintType"); + if (!pdf_is_int(ctx, paint) || pdf_to_int(ctx, paint) < 1 || pdf_to_int(ctx, paint) > 2) { - fz_warn(glo->ctx, "not a pattern paint type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict)); + fz_warn(ctx, "not a pattern paint type (%d %d R)", pdf_to_num(ctx, patterndict), pdf_to_gen(ctx, patterndict)); paint = NULL; } - tiling = pdf_dict_gets(patterndict, "TilingType"); - if (!pdf_is_int(tiling) || pdf_to_int(tiling) < 1 || pdf_to_int(tiling) > 3) + tiling = pdf_dict_gets(ctx, patterndict, "TilingType"); + if (!pdf_is_int(ctx, tiling) || pdf_to_int(ctx, tiling) < 1 || pdf_to_int(ctx, tiling) > 3) { - fz_warn(glo->ctx, "not a pattern tiling type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict)); + fz_warn(ctx, "not a pattern tiling type (%d %d R)", pdf_to_num(ctx, patterndict), pdf_to_gen(ctx, patterndict)); tiling = NULL; } } else { - shading = pdf_dict_gets(patterndict, "Shading"); + shading = pdf_dict_gets(ctx, patterndict, "Shading"); } for (k = 0; k < glo->patterns; k++) - if (!pdf_objcmp(glo->pattern[k].u.pattern.obj, patterndict)) + if (!pdf_objcmp(ctx, glo->pattern[k].u.pattern.obj, patterndict)) break; if (k < glo->patterns) continue; - glo->pattern = fz_resize_array(glo->ctx, glo->pattern, glo->patterns+1, sizeof(struct info)); + glo->pattern = fz_resize_array(ctx, glo->pattern, glo->patterns+1, sizeof(struct info)); glo->patterns++; glo->pattern[glo->patterns - 1].page = page; @@ -562,7 +562,7 @@ gatherpatterns(globals *glo, int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_o } static void -gatherresourceinfo(globals *glo, int page, pdf_obj *rsrc, int show) +gatherresourceinfo(fz_context *ctx, globals *glo, int page, pdf_obj *rsrc, int show) { pdf_obj *pageobj; pdf_obj *pageref; @@ -573,88 +573,88 @@ gatherresourceinfo(globals *glo, int page, pdf_obj *rsrc, int show) pdf_obj *subrsrc; int i; - pageref = pdf_lookup_page_obj(glo->doc, page-1); - pageobj = pdf_resolve_indirect(pageref); + pageref = pdf_lookup_page_obj(ctx, glo->doc, page-1); + pageobj = pdf_resolve_indirect(ctx, pageref); if (!pageobj) - fz_throw(glo->ctx, FZ_ERROR_GENERIC, "cannot retrieve info from page %d", page); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot retrieve info from page %d", page); - font = pdf_dict_gets(rsrc, "Font"); + font = pdf_dict_gets(ctx, rsrc, "Font"); if (show & FONTS && font) { int n; - gatherfonts(glo, page, pageref, pageobj, font); - n = pdf_dict_len(font); + gatherfonts(ctx, glo, page, pageref, pageobj, font); + n = pdf_dict_len(ctx, font); for (i = 0; i < n; i++) { - pdf_obj *obj = pdf_dict_get_val(font, i); + pdf_obj *obj = pdf_dict_get_val(ctx, font, i); - subrsrc = pdf_dict_gets(obj, "Resources"); - if (subrsrc && pdf_objcmp(rsrc, subrsrc)) - gatherresourceinfo(glo, page, subrsrc, show); + subrsrc = pdf_dict_gets(ctx, obj, "Resources"); + if (subrsrc && pdf_objcmp(ctx, rsrc, subrsrc)) + gatherresourceinfo(ctx, glo, page, subrsrc, show); } } - xobj = pdf_dict_gets(rsrc, "XObject"); + xobj = pdf_dict_gets(ctx, rsrc, "XObject"); if (show & XOBJS && xobj) { int n; - gatherimages(glo, page, pageref, pageobj, xobj); - gatherforms(glo, page, pageref, pageobj, xobj); - gatherpsobjs(glo, page, pageref, pageobj, xobj); - n = pdf_dict_len(xobj); + gatherimages(ctx, glo, page, pageref, pageobj, xobj); + gatherforms(ctx, glo, page, pageref, pageobj, xobj); + gatherpsobjs(ctx, glo, page, pageref, pageobj, xobj); + n = pdf_dict_len(ctx, xobj); for (i = 0; i < n; i++) { - pdf_obj *obj = pdf_dict_get_val(xobj, i); - subrsrc = pdf_dict_gets(obj, "Resources"); - if (subrsrc && pdf_objcmp(rsrc, subrsrc)) - gatherresourceinfo(glo, page, subrsrc, show); + pdf_obj *obj = pdf_dict_get_val(ctx, xobj, i); + subrsrc = pdf_dict_gets(ctx, obj, "Resources"); + if (subrsrc && pdf_objcmp(ctx, rsrc, subrsrc)) + gatherresourceinfo(ctx, glo, page, subrsrc, show); } } - shade = pdf_dict_gets(rsrc, "Shading"); + shade = pdf_dict_gets(ctx, rsrc, "Shading"); if (show & SHADINGS && shade) - gathershadings(glo, page, pageref, pageobj, shade); + gathershadings(ctx, glo, page, pageref, pageobj, shade); - pattern = pdf_dict_gets(rsrc, "Pattern"); + pattern = pdf_dict_gets(ctx, rsrc, "Pattern"); if (show & PATTERNS && pattern) { int n; - gatherpatterns(glo, page, pageref, pageobj, pattern); - n = pdf_dict_len(pattern); + gatherpatterns(ctx, glo, page, pageref, pageobj, pattern); + n = pdf_dict_len(ctx, pattern); for (i = 0; i < n; i++) { - pdf_obj *obj = pdf_dict_get_val(pattern, i); - subrsrc = pdf_dict_gets(obj, "Resources"); - if (subrsrc && pdf_objcmp(rsrc, subrsrc)) - gatherresourceinfo(glo, page, subrsrc, show); + pdf_obj *obj = pdf_dict_get_val(ctx, pattern, i); + subrsrc = pdf_dict_gets(ctx, obj, "Resources"); + if (subrsrc && pdf_objcmp(ctx, rsrc, subrsrc)) + gatherresourceinfo(ctx, glo, page, subrsrc, show); } } } static void -gatherpageinfo(globals *glo, int page, int show) +gatherpageinfo(fz_context *ctx, globals *glo, int page, int show) { pdf_obj *pageobj; pdf_obj *pageref; pdf_obj *rsrc; - pageref = pdf_lookup_page_obj(glo->doc, page-1); - pageobj = pdf_resolve_indirect(pageref); + pageref = pdf_lookup_page_obj(ctx, glo->doc, page-1); + pageobj = pdf_resolve_indirect(ctx, pageref); if (!pageobj) - fz_throw(glo->ctx, FZ_ERROR_GENERIC, "cannot retrieve info from page %d", page); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot retrieve info from page %d", page); - gatherdimensions(glo, page, pageref, pageobj); + gatherdimensions(ctx, glo, page, pageref, pageobj); - rsrc = pdf_dict_gets(pageobj, "Resources"); - gatherresourceinfo(glo, page, rsrc, show); + rsrc = pdf_dict_gets(ctx, pageobj, "Resources"); + gatherresourceinfo(ctx, glo, page, rsrc, show); } static void -printinfo(globals *glo, char *filename, int show, int page) +printinfo(fz_context *ctx, globals *glo, char *filename, int show, int page) { int i; int j; @@ -664,85 +664,85 @@ printinfo(globals *glo, char *filename, int show, int page) if (show & DIMENSIONS && glo->dims > 0) { - fz_printf(out, "Mediaboxes (%d):\n", glo->dims); + fz_printf(ctx, out, "Mediaboxes (%d):\n", glo->dims); for (i = 0; i < glo->dims; i++) { - fz_printf(out, PAGE_FMT "[ %g %g %g %g ]\n", + fz_printf(ctx, out, PAGE_FMT "[ %g %g %g %g ]\n", glo->dim[i].page, - pdf_to_num(glo->dim[i].pageref), - pdf_to_gen(glo->dim[i].pageref), + pdf_to_num(ctx, glo->dim[i].pageref), + pdf_to_gen(ctx, glo->dim[i].pageref), glo->dim[i].u.dim.bbox->x0, glo->dim[i].u.dim.bbox->y0, glo->dim[i].u.dim.bbox->x1, glo->dim[i].u.dim.bbox->y1); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & FONTS && glo->fonts > 0) { - fz_printf(out, "Fonts (%d):\n", glo->fonts); + fz_printf(ctx, out, "Fonts (%d):\n", glo->fonts); for (i = 0; i < glo->fonts; i++) { - fz_printf(out, PAGE_FMT "%s '%s' (%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "%s '%s' (%d %d R)\n", glo->font[i].page, - pdf_to_num(glo->font[i].pageref), - pdf_to_gen(glo->font[i].pageref), - pdf_to_name(glo->font[i].u.font.subtype), - pdf_to_name(glo->font[i].u.font.name), - pdf_to_num(glo->font[i].u.font.obj), - pdf_to_gen(glo->font[i].u.font.obj)); + pdf_to_num(ctx, glo->font[i].pageref), + pdf_to_gen(ctx, glo->font[i].pageref), + pdf_to_name(ctx, glo->font[i].u.font.subtype), + pdf_to_name(ctx, glo->font[i].u.font.name), + pdf_to_num(ctx, glo->font[i].u.font.obj), + pdf_to_gen(ctx, glo->font[i].u.font.obj)); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & IMAGES && glo->images > 0) { - fz_printf(out, "Images (%d):\n", glo->images); + fz_printf(ctx, out, "Images (%d):\n", glo->images); for (i = 0; i < glo->images; i++) { char *cs = NULL; char *altcs = NULL; - fz_printf(out, PAGE_FMT "[ ", + fz_printf(ctx, out, PAGE_FMT "[ ", glo->image[i].page, - pdf_to_num(glo->image[i].pageref), - pdf_to_gen(glo->image[i].pageref)); + pdf_to_num(ctx, glo->image[i].pageref), + pdf_to_gen(ctx, glo->image[i].pageref)); - if (pdf_is_array(glo->image[i].u.image.filter)) + if (pdf_is_array(ctx, glo->image[i].u.image.filter)) { - int n = pdf_array_len(glo->image[i].u.image.filter); + int n = pdf_array_len(ctx, glo->image[i].u.image.filter); for (j = 0; j < n; j++) { - pdf_obj *obj = pdf_array_get(glo->image[i].u.image.filter, j); - char *filter = fz_strdup(glo->ctx, pdf_to_name(obj)); + pdf_obj *obj = pdf_array_get(ctx, glo->image[i].u.image.filter, j); + char *filter = fz_strdup(ctx, pdf_to_name(ctx, obj)); if (strstr(filter, "Decode")) *(strstr(filter, "Decode")) = '\0'; - fz_printf(out, "%s%s", + fz_printf(ctx, out, "%s%s", filter, - j == pdf_array_len(glo->image[i].u.image.filter) - 1 ? "" : " "); - fz_free(glo->ctx, filter); + j == pdf_array_len(ctx, glo->image[i].u.image.filter) - 1 ? "" : " "); + fz_free(ctx, filter); } } else if (glo->image[i].u.image.filter) { pdf_obj *obj = glo->image[i].u.image.filter; - char *filter = fz_strdup(glo->ctx, pdf_to_name(obj)); + char *filter = fz_strdup(ctx, pdf_to_name(ctx, obj)); if (strstr(filter, "Decode")) *(strstr(filter, "Decode")) = '\0'; - fz_printf(out, "%s", filter); - fz_free(glo->ctx, filter); + fz_printf(ctx, out, "%s", filter); + fz_free(ctx, filter); } else - fz_printf(out, "Raw"); + fz_printf(ctx, out, "Raw"); if (glo->image[i].u.image.cs) { - cs = fz_strdup(glo->ctx, pdf_to_name(glo->image[i].u.image.cs)); + cs = fz_strdup(ctx, pdf_to_name(ctx, glo->image[i].u.image.cs)); if (!strncmp(cs, "Device", 6)) { @@ -761,7 +761,7 @@ printinfo(globals *glo, char *filename, int show, int page) } if (glo->image[i].u.image.altcs) { - altcs = fz_strdup(glo->ctx, pdf_to_name(glo->image[i].u.image.altcs)); + altcs = fz_strdup(ctx, pdf_to_name(ctx, glo->image[i].u.image.altcs)); if (!strncmp(altcs, "Device", 6)) { @@ -779,25 +779,25 @@ printinfo(globals *glo, char *filename, int show, int page) fz_strlcpy(altcs, "Sep", 4); } - fz_printf(out, " ] %dx%d %dbpc %s%s%s (%d %d R)\n", - pdf_to_int(glo->image[i].u.image.width), - pdf_to_int(glo->image[i].u.image.height), - glo->image[i].u.image.bpc ? pdf_to_int(glo->image[i].u.image.bpc) : 1, + fz_printf(ctx, out, " ] %dx%d %dbpc %s%s%s (%d %d R)\n", + pdf_to_int(ctx, glo->image[i].u.image.width), + pdf_to_int(ctx, glo->image[i].u.image.height), + glo->image[i].u.image.bpc ? pdf_to_int(ctx, glo->image[i].u.image.bpc) : 1, glo->image[i].u.image.cs ? cs : "ImageMask", glo->image[i].u.image.altcs ? " " : "", glo->image[i].u.image.altcs ? altcs : "", - pdf_to_num(glo->image[i].u.image.obj), - pdf_to_gen(glo->image[i].u.image.obj)); + pdf_to_num(ctx, glo->image[i].u.image.obj), + pdf_to_gen(ctx, glo->image[i].u.image.obj)); - fz_free(glo->ctx, cs); - fz_free(glo->ctx, altcs); + fz_free(ctx, cs); + fz_free(ctx, altcs); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & SHADINGS && glo->shadings > 0) { - fz_printf(out, "Shading patterns (%d):\n", glo->shadings); + fz_printf(ctx, out, "Shading patterns (%d):\n", glo->shadings); for (i = 0; i < glo->shadings; i++) { char *shadingtype[] = @@ -812,23 +812,23 @@ printinfo(globals *glo, char *filename, int show, int page) "Tensor patch", }; - fz_printf(out, PAGE_FMT "%s (%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "%s (%d %d R)\n", glo->shading[i].page, - pdf_to_num(glo->shading[i].pageref), - pdf_to_gen(glo->shading[i].pageref), - shadingtype[pdf_to_int(glo->shading[i].u.shading.type)], - pdf_to_num(glo->shading[i].u.shading.obj), - pdf_to_gen(glo->shading[i].u.shading.obj)); + pdf_to_num(ctx, glo->shading[i].pageref), + pdf_to_gen(ctx, glo->shading[i].pageref), + shadingtype[pdf_to_int(ctx, glo->shading[i].u.shading.type)], + pdf_to_num(ctx, glo->shading[i].u.shading.obj), + pdf_to_gen(ctx, glo->shading[i].u.shading.obj)); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & PATTERNS && glo->patterns > 0) { - fz_printf(out, "Patterns (%d):\n", glo->patterns); + fz_printf(ctx, out, "Patterns (%d):\n", glo->patterns); for (i = 0; i < glo->patterns; i++) { - if (pdf_to_int(glo->pattern[i].u.pattern.type) == 1) + if (pdf_to_int(ctx, glo->pattern[i].u.pattern.type) == 1) { char *painttype[] = { @@ -844,67 +844,67 @@ printinfo(globals *glo, char *filename, int show, int page) "Constant/fast tiling", }; - fz_printf(out, PAGE_FMT "Tiling %s %s (%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "Tiling %s %s (%d %d R)\n", glo->pattern[i].page, - pdf_to_num(glo->pattern[i].pageref), - pdf_to_gen(glo->pattern[i].pageref), - painttype[pdf_to_int(glo->pattern[i].u.pattern.paint)], - tilingtype[pdf_to_int(glo->pattern[i].u.pattern.tiling)], - pdf_to_num(glo->pattern[i].u.pattern.obj), - pdf_to_gen(glo->pattern[i].u.pattern.obj)); + pdf_to_num(ctx, glo->pattern[i].pageref), + pdf_to_gen(ctx, glo->pattern[i].pageref), + painttype[pdf_to_int(ctx, glo->pattern[i].u.pattern.paint)], + tilingtype[pdf_to_int(ctx, glo->pattern[i].u.pattern.tiling)], + pdf_to_num(ctx, glo->pattern[i].u.pattern.obj), + pdf_to_gen(ctx, glo->pattern[i].u.pattern.obj)); } else { - fz_printf(out, PAGE_FMT "Shading %d %d R (%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "Shading %d %d R (%d %d R)\n", glo->pattern[i].page, - pdf_to_num(glo->pattern[i].pageref), - pdf_to_gen(glo->pattern[i].pageref), - pdf_to_num(glo->pattern[i].u.pattern.shading), - pdf_to_gen(glo->pattern[i].u.pattern.shading), - pdf_to_num(glo->pattern[i].u.pattern.obj), - pdf_to_gen(glo->pattern[i].u.pattern.obj)); + pdf_to_num(ctx, glo->pattern[i].pageref), + pdf_to_gen(ctx, glo->pattern[i].pageref), + pdf_to_num(ctx, glo->pattern[i].u.pattern.shading), + pdf_to_gen(ctx, glo->pattern[i].u.pattern.shading), + pdf_to_num(ctx, glo->pattern[i].u.pattern.obj), + pdf_to_gen(ctx, glo->pattern[i].u.pattern.obj)); } } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & XOBJS && glo->forms > 0) { - fz_printf(out, "Form xobjects (%d):\n", glo->forms); + fz_printf(ctx, out, "Form xobjects (%d):\n", glo->forms); for (i = 0; i < glo->forms; i++) { - fz_printf(out, PAGE_FMT "Form%s%s%s%s (%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "Form%s%s%s%s (%d %d R)\n", glo->form[i].page, - pdf_to_num(glo->form[i].pageref), - pdf_to_gen(glo->form[i].pageref), + pdf_to_num(ctx, glo->form[i].pageref), + pdf_to_gen(ctx, glo->form[i].pageref), glo->form[i].u.form.groupsubtype ? " " : "", - glo->form[i].u.form.groupsubtype ? pdf_to_name(glo->form[i].u.form.groupsubtype) : "", + glo->form[i].u.form.groupsubtype ? pdf_to_name(ctx, glo->form[i].u.form.groupsubtype) : "", glo->form[i].u.form.groupsubtype ? " Group" : "", glo->form[i].u.form.reference ? " Reference" : "", - pdf_to_num(glo->form[i].u.form.obj), - pdf_to_gen(glo->form[i].u.form.obj)); + pdf_to_num(ctx, glo->form[i].u.form.obj), + pdf_to_gen(ctx, glo->form[i].u.form.obj)); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } if (show & XOBJS && glo->psobjs > 0) { - fz_printf(out, "Postscript xobjects (%d):\n", glo->psobjs); + fz_printf(ctx, out, "Postscript xobjects (%d):\n", glo->psobjs); for (i = 0; i < glo->psobjs; i++) { - fz_printf(out, PAGE_FMT "(%d %d R)\n", + fz_printf(ctx, out, PAGE_FMT "(%d %d R)\n", glo->psobj[i].page, - pdf_to_num(glo->psobj[i].pageref), - pdf_to_gen(glo->psobj[i].pageref), - pdf_to_num(glo->psobj[i].u.form.obj), - pdf_to_gen(glo->psobj[i].u.form.obj)); + pdf_to_num(ctx, glo->psobj[i].pageref), + pdf_to_gen(ctx, glo->psobj[i].pageref), + pdf_to_num(ctx, glo->psobj[i].u.form.obj), + pdf_to_gen(ctx, glo->psobj[i].u.form.obj)); } - fz_printf(out, "\n"); + fz_printf(ctx, out, "\n"); } } static void -showinfo(globals *glo, char *filename, int show, char *pagelist) +showinfo(fz_context *ctx, globals *glo, char *filename, int show, char *pagelist) { int page, spage, epage; char *spec, *dash; @@ -917,7 +917,7 @@ showinfo(globals *glo, char *filename, int show, char *pagelist) allpages = !strcmp(pagelist, "1-"); - pagecount = pdf_count_pages(glo->doc); + pagecount = pdf_count_pages(ctx, glo->doc); spec = fz_strsep(&pagelist, ","); while (spec && pagecount) { @@ -943,15 +943,15 @@ showinfo(globals *glo, char *filename, int show, char *pagelist) epage = fz_clampi(epage, 1, pagecount); if (allpages) - fz_printf(out, "Retrieving info from pages %d-%d...\n", spage, epage); + fz_printf(ctx, out, "Retrieving info from pages %d-%d...\n", spage, epage); for (page = spage; page <= epage; page++) { - gatherpageinfo(glo, page, show); + gatherpageinfo(ctx, glo, page, show); if (!allpages) { - fz_printf(out, "Page %d:\n", page); - printinfo(glo, filename, show, page); - fz_printf(out, "\n"); + fz_printf(ctx, out, "Page %d:\n", page); + printinfo(ctx, glo, filename, show, page); + fz_printf(ctx, out, "\n"); } } @@ -959,7 +959,7 @@ showinfo(globals *glo, char *filename, int show, char *pagelist) } if (allpages) - printinfo(glo, filename, show, -1); + printinfo(ctx, glo, filename, show, -1); } static int arg_is_page_range(const char *arg) @@ -981,7 +981,6 @@ pdfinfo_info(fz_context *ctx, fz_output *out, char *filename, char *password, in int argidx = 0; globals glo = { 0 }; - glo.ctx = ctx; glo.out = out; state = NO_FILE_OPENED; @@ -991,25 +990,25 @@ pdfinfo_info(fz_context *ctx, fz_output *out, char *filename, char *password, in { if (state == NO_INFO_GATHERED) { - showinfo(&glo, filename, show, "1-"); + showinfo(ctx, &glo, filename, show, "1-"); } - closexref(&glo); + closexref(ctx, &glo); filename = argv[argidx]; - fz_printf(out, "%s:\n", filename); + fz_printf(ctx, out, "%s:\n", filename); glo.doc = pdf_open_document_no_run(glo.ctx, filename); - if (pdf_needs_password(glo.doc)) - if (!pdf_authenticate_password(glo.doc, password)) + if (pdf_needs_password(ctx, glo.doc)) + if (!pdf_authenticate_password(ctx, glo.doc, password)) fz_throw(glo.ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", filename); - glo.pagecount = pdf_count_pages(glo.doc); + glo.pagecount = pdf_count_pages(ctx, glo.doc); - showglobalinfo(&glo); + showglobalinfo(ctx, &glo); state = NO_INFO_GATHERED; } else { - showinfo(&glo, filename, show, argv[argidx]); + showinfo(ctx, &glo, filename, show, argv[argidx]); state = INFO_SHOWN; } @@ -1017,9 +1016,9 @@ pdfinfo_info(fz_context *ctx, fz_output *out, char *filename, char *password, in } if (state == NO_INFO_GATHERED) - showinfo(&glo, filename, show, "1-"); + showinfo(ctx, &glo, filename, show, "1-"); - closexref(&glo); + closexref(ctx, &glo); } int pdfinfo_main(int argc, char **argv) @@ -1064,14 +1063,14 @@ int pdfinfo_main(int argc, char **argv) ret = 0; fz_try(ctx) { - out = fz_new_output_with_file(ctx, stdout); + out = fz_new_output_with_file(ctx, stdout, 0); pdfinfo_info(ctx, out, filename, password, show, &argv[fz_optind], argc-fz_optind); } fz_catch(ctx) { ret = 1; } - fz_drop_output(out); + fz_drop_output(ctx, out); fz_drop_context(ctx); return ret; } diff --git a/source/tools/pdfposter.c b/source/tools/pdfposter.c index e4b631a6..f949a005 100644 --- a/source/tools/pdfposter.c +++ b/source/tools/pdfposter.c @@ -21,31 +21,31 @@ static void usage(void) * Recreate page tree with our posterised pages in. */ -static void decimatepages(pdf_document *doc) +static void decimatepages(fz_context *ctx, pdf_document *doc) { pdf_obj *oldroot, *root, *pages, *kids, *parent; - int num_pages = pdf_count_pages(doc); + int num_pages = pdf_count_pages(ctx, doc); int page, kidcount; - oldroot = pdf_dict_gets(pdf_trailer(doc), "Root"); - pages = pdf_dict_gets(oldroot, "Pages"); + oldroot = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Root"); + pages = pdf_dict_gets(ctx, oldroot, "Pages"); - root = pdf_new_dict(doc, 2); - pdf_dict_puts(root, "Type", pdf_dict_gets(oldroot, "Type")); - pdf_dict_puts(root, "Pages", pdf_dict_gets(oldroot, "Pages")); + root = pdf_new_dict(ctx, doc, 2); + pdf_dict_puts(ctx, root, "Type", pdf_dict_gets(ctx, oldroot, "Type")); + pdf_dict_puts(ctx, root, "Pages", pdf_dict_gets(ctx, oldroot, "Pages")); - pdf_update_object(doc, pdf_to_num(oldroot), root); + pdf_update_object(ctx, doc, pdf_to_num(ctx, oldroot), root); - pdf_drop_obj(root); + pdf_drop_obj(ctx, root); /* Create a new kids array with our new pages in */ - parent = pdf_new_indirect(doc, pdf_to_num(pages), pdf_to_gen(pages)); - kids = pdf_new_array(doc, 1); + parent = pdf_new_indirect(ctx, doc, pdf_to_num(ctx, pages), pdf_to_gen(ctx, pages)); + kids = pdf_new_array(ctx, doc, 1); kidcount = 0; for (page=0; page < num_pages; page++) { - pdf_page *page_details = pdf_load_page(doc, page); + pdf_page *page_details = pdf_load_page(ctx, doc, page); int xf = x_factor, yf = y_factor; int x, y; float w = page_details->mediabox.x1 - page_details->mediabox.x0; @@ -72,12 +72,12 @@ static void decimatepages(pdf_document *doc) fz_rect mb; int num; - newpageobj = pdf_copy_dict(pdf_lookup_page_obj(doc, page)); - num = pdf_create_object(doc); - pdf_update_object(doc, num, newpageobj); - newpageref = pdf_new_indirect(doc, num, 0); + newpageobj = pdf_copy_dict(ctx, pdf_lookup_page_obj(ctx, doc, page)); + num = pdf_create_object(ctx, doc); + pdf_update_object(ctx, doc, num, newpageobj); + newpageref = pdf_new_indirect(ctx, doc, num, 0); - newmediabox = pdf_new_array(doc, 4); + newmediabox = pdf_new_array(ctx, doc, 4); mb.x0 = page_details->mediabox.x0 + (w/xf)*x; if (x == xf-1) @@ -90,28 +90,28 @@ static void decimatepages(pdf_document *doc) else mb.y1 = page_details->mediabox.y0 + (h/yf)*(y+1); - pdf_array_push(newmediabox, pdf_new_real(doc, mb.x0)); - pdf_array_push(newmediabox, pdf_new_real(doc, mb.y0)); - pdf_array_push(newmediabox, pdf_new_real(doc, mb.x1)); - pdf_array_push(newmediabox, pdf_new_real(doc, mb.y1)); + pdf_array_push(ctx, newmediabox, pdf_new_real(ctx, doc, mb.x0)); + pdf_array_push(ctx, newmediabox, pdf_new_real(ctx, doc, mb.y0)); + pdf_array_push(ctx, newmediabox, pdf_new_real(ctx, doc, mb.x1)); + pdf_array_push(ctx, newmediabox, pdf_new_real(ctx, doc, mb.y1)); - pdf_dict_puts(newpageobj, "Parent", parent); - pdf_dict_puts(newpageobj, "MediaBox", newmediabox); + pdf_dict_puts(ctx, newpageobj, "Parent", parent); + pdf_dict_puts(ctx, newpageobj, "MediaBox", newmediabox); /* Store page object in new kids array */ - pdf_array_push(kids, newpageref); + pdf_array_push(ctx, kids, newpageref); kidcount++; } } } - pdf_drop_obj(parent); + pdf_drop_obj(ctx, parent); /* Update page count and kids array */ - pdf_dict_puts(pages, "Count", pdf_new_int(doc, kidcount)); - pdf_dict_puts(pages, "Kids", kids); - pdf_drop_obj(kids); + pdf_dict_puts(ctx, pages, "Count", pdf_new_int(ctx, doc, kidcount)); + pdf_dict_puts(ctx, pages, "Kids", kids); + pdf_drop_obj(ctx, kids); } int pdfposter_main(int argc, char **argv) @@ -160,15 +160,15 @@ int pdfposter_main(int argc, char **argv) } doc = pdf_open_document_no_run(ctx, infile); - if (pdf_needs_password(doc)) - if (!pdf_authenticate_password(doc, password)) + if (pdf_needs_password(ctx, doc)) + if (!pdf_authenticate_password(ctx, doc, password)) fz_throw(ctx, FZ_ERROR_GENERIC, "cannot authenticate password: %s", infile); - decimatepages(doc); + decimatepages(ctx, doc); - pdf_write_document(doc, outfile, &opts); + pdf_write_document(ctx, doc, outfile, &opts); - pdf_close_document(doc); + pdf_close_document(ctx, doc); fz_drop_context(ctx); return 0; } diff --git a/source/tools/pdfshow.c b/source/tools/pdfshow.c index 344f4c40..d084c080 100644 --- a/source/tools/pdfshow.c +++ b/source/tools/pdfshow.c @@ -27,7 +27,7 @@ static void showtrailer(void) if (!doc) fz_throw(ctx, FZ_ERROR_GENERIC, "no file specified"); fprintf(out, "trailer\n"); - pdf_fprint_obj(out, pdf_trailer(doc), 0); + pdf_fprint_obj(ctx, out, pdf_trailer(ctx, doc), 0); fprintf(out, "\n"); } @@ -37,11 +37,11 @@ static void showencrypt(void) if (!doc) fz_throw(ctx, FZ_ERROR_GENERIC, "no file specified"); - encrypt = pdf_dict_gets(pdf_trailer(doc), "Encrypt"); + encrypt = pdf_dict_gets(ctx, pdf_trailer(ctx, doc), "Encrypt"); if (!encrypt) fz_throw(ctx, FZ_ERROR_GENERIC, "document not encrypted"); fprintf(out, "encryption dictionary\n"); - pdf_fprint_obj(out, pdf_resolve_indirect(encrypt), 0); + pdf_fprint_obj(ctx, out, pdf_resolve_indirect(ctx, encrypt), 0); fprintf(out, "\n"); } @@ -49,7 +49,7 @@ static void showxref(void) { if (!doc) fz_throw(ctx, FZ_ERROR_GENERIC, "no file specified"); - pdf_print_xref(doc); + pdf_print_xref(ctx, doc); fprintf(out, "\n"); } @@ -62,11 +62,11 @@ static void showpagetree(void) if (!doc) fz_throw(ctx, FZ_ERROR_GENERIC, "no file specified"); - count = pdf_count_pages(doc); + count = pdf_count_pages(ctx, doc); for (i = 0; i < count; i++) { - ref = pdf_lookup_page_obj(doc, i); - fprintf(out, "page %d = %d %d R\n", i + 1, pdf_to_num(ref), pdf_to_gen(ref)); + ref = pdf_lookup_page_obj(ctx, doc, i); + fprintf(out, "page %d = %d %d R\n", i + 1, pdf_to_num(ctx, ref), pdf_to_gen(ctx, ref)); } fprintf(out, "\n"); } @@ -103,13 +103,13 @@ static void showstream(int num, int gen) showcolumn = 0; if (showdecode) - stm = pdf_open_stream(doc, num, gen); + stm = pdf_open_stream(ctx, doc, num, gen); else - stm = pdf_open_raw_stream(doc, num, gen); + stm = pdf_open_raw_stream(ctx, doc, num, gen); while (1) { - n = fz_read(stm, buf, sizeof buf); + n = fz_read(ctx, stm, buf, sizeof buf); if (n == 0) break; if (showbinary) @@ -118,7 +118,7 @@ static void showstream(int num, int gen) showsafe(buf, n); } - fz_drop_stream(stm); + fz_drop_stream(ctx, stm); } static void showobject(int num, int gen) @@ -128,9 +128,9 @@ static void showobject(int num, int gen) if (!doc) fz_throw(ctx, FZ_ERROR_GENERIC, "no file specified"); - obj = pdf_load_object(doc, num, gen); + obj = pdf_load_object(ctx, doc, num, gen); - if (pdf_is_stream(doc, num, gen)) + if (pdf_is_stream(ctx, doc, num, gen)) { if (showbinary) { @@ -139,7 +139,7 @@ static void showobject(int num, int gen) else { fprintf(out, "%d %d obj\n", num, gen); - pdf_fprint_obj(out, obj, 0); + pdf_fprint_obj(ctx, out, obj, 0); fprintf(out, "stream\n"); showstream(num, gen); fprintf(out, "endstream\n"); @@ -149,11 +149,11 @@ static void showobject(int num, int gen) else { fprintf(out, "%d %d obj\n", num, gen); - pdf_fprint_obj(out, obj, 0); + pdf_fprint_obj(ctx, out, obj, 0); fprintf(out, "endobj\n\n"); } - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } static void showgrep(char *filename) @@ -161,15 +161,15 @@ static void showgrep(char *filename) pdf_obj *obj; int i, len; - len = pdf_count_objects(doc); + len = pdf_count_objects(ctx, doc); for (i = 0; i < len; i++) { - pdf_xref_entry *entry = pdf_get_xref_entry(doc, i); + pdf_xref_entry *entry = pdf_get_xref_entry(ctx, doc, i); if (entry->type == 'n' || entry->type == 'o') { fz_try(ctx) { - obj = pdf_load_object(doc, i, 0); + obj = pdf_load_object(ctx, doc, i, 0); } fz_catch(ctx) { @@ -177,17 +177,17 @@ static void showgrep(char *filename) continue; } - pdf_sort_dict(obj); + pdf_sort_dict(ctx, obj); fprintf(out, "%s:%d: ", filename, i); - pdf_fprint_obj(out, obj, 1); + pdf_fprint_obj(ctx, out, obj, 1); - pdf_drop_obj(obj); + pdf_drop_obj(ctx, obj); } } fprintf(out, "%s:trailer: ", filename); - pdf_fprint_obj(out, pdf_trailer(doc), 1); + pdf_fprint_obj(ctx, out, pdf_trailer(ctx, doc), 1); } int pdfshow_main(int argc, char **argv) @@ -236,8 +236,8 @@ int pdfshow_main(int argc, char **argv) fz_try(ctx) { doc = pdf_open_document_no_run(ctx, filename); - if (pdf_needs_password(doc)) - if (!pdf_authenticate_password(doc, password)) + if (pdf_needs_password(ctx, doc)) + if (!pdf_authenticate_password(ctx, doc, password)) fz_warn(ctx, "cannot authenticate password: %s", filename); if (fz_optind == argc) @@ -264,7 +264,7 @@ int pdfshow_main(int argc, char **argv) if (out != stdout) fclose(out); - pdf_close_document(doc); + pdf_close_document(ctx, doc); fz_drop_context(ctx); return 0; } diff --git a/source/xps/xps-common.c b/source/xps/xps-common.c index 04b78d2b..667b0631 100644 --- a/source/xps/xps-common.c +++ b/source/xps/xps-common.c @@ -9,7 +9,7 @@ static inline int unhex(int a) } fz_xml * -xps_lookup_alternate_content(fz_xml *node) +xps_lookup_alternate_content(fz_context *ctx, xps_document *doc, fz_xml *node) { for (node = fz_xml_down(node); node; node = fz_xml_next(node)) { @@ -29,48 +29,49 @@ xps_lookup_alternate_content(fz_xml *node) } void -xps_parse_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) +xps_parse_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) { if (doc->cookie && doc->cookie->abort) return; /* SolidColorBrushes are handled in a special case and will never show up here */ if (fz_xml_is_tag(node, "ImageBrush")) - xps_parse_image_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_image_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "VisualBrush")) - xps_parse_visual_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_visual_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "LinearGradientBrush")) - xps_parse_linear_gradient_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_linear_gradient_brush(ctx, doc, ctm, area, base_uri, dict, node); else if (fz_xml_is_tag(node, "RadialGradientBrush")) - xps_parse_radial_gradient_brush(doc, ctm, area, base_uri, dict, node); + xps_parse_radial_gradient_brush(ctx, doc, ctm, area, base_uri, dict, node); else - fz_warn(doc->ctx, "unknown brush tag: %s", fz_xml_tag(node)); + fz_warn(ctx, "unknown brush tag: %s", fz_xml_tag(node)); } void -xps_parse_element(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) +xps_parse_element(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *node) { if (doc->cookie && doc->cookie->abort) return; if (fz_xml_is_tag(node, "Path")) - xps_parse_path(doc, ctm, base_uri, dict, node); + xps_parse_path(ctx, doc, ctm, base_uri, dict, node); if (fz_xml_is_tag(node, "Glyphs")) - xps_parse_glyphs(doc, ctm, base_uri, dict, node); + xps_parse_glyphs(ctx, doc, ctm, base_uri, dict, node); if (fz_xml_is_tag(node, "Canvas")) - xps_parse_canvas(doc, ctm, area, base_uri, dict, node); + xps_parse_canvas(ctx, doc, ctm, area, base_uri, dict, node); if (fz_xml_is_tag(node, "AlternateContent")) { - node = xps_lookup_alternate_content(node); + node = xps_lookup_alternate_content(ctx, doc, node); if (node) - xps_parse_element(doc, ctm, area, base_uri, dict, node); + xps_parse_element(ctx, doc, ctm, area, base_uri, dict, node); } /* skip unknown tags (like Foo.Resources and similar) */ } void -xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_begin_opacity(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag) { + fz_device *dev = doc->dev; float opacity; if (!opacity_att && !opacity_mask_tag) @@ -90,7 +91,7 @@ xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, { fz_colorspace *colorspace; float samples[FZ_MAX_COLORS]; - xps_parse_color(doc, base_uri, scb_color_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, scb_color_att, &colorspace, samples); opacity = opacity * samples[0]; } opacity_mask_tag = NULL; @@ -104,16 +105,18 @@ xps_begin_opacity(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, if (opacity_mask_tag) { - fz_begin_mask(doc->dev, area, 0, NULL, NULL); - xps_parse_brush(doc, ctm, area, base_uri, dict, opacity_mask_tag); - fz_end_mask(doc->dev); + fz_begin_mask(ctx, dev, area, 0, NULL, NULL); + xps_parse_brush(ctx, doc, ctm, area, base_uri, dict, opacity_mask_tag); + fz_end_mask(ctx, dev); } } void -xps_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, +xps_end_opacity(fz_context *ctx, xps_document *doc, char *base_uri, xps_resource *dict, char *opacity_att, fz_xml *opacity_mask_tag) { + fz_device *dev = doc->dev; + if (!opacity_att && !opacity_mask_tag) return; @@ -123,12 +126,12 @@ xps_end_opacity(xps_document *doc, char *base_uri, xps_resource *dict, if (opacity_mask_tag) { if (strcmp(fz_xml_tag(opacity_mask_tag), "SolidColorBrush")) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); } } void -xps_parse_render_transform(xps_document *doc, char *transform, fz_matrix *matrix) +xps_parse_render_transform(fz_context *ctx, xps_document *doc, char *transform, fz_matrix *matrix) { float args[6]; char *s = transform; @@ -153,7 +156,7 @@ xps_parse_render_transform(xps_document *doc, char *transform, fz_matrix *matrix } void -xps_parse_matrix_transform(xps_document *doc, fz_xml *root, fz_matrix *matrix) +xps_parse_matrix_transform(fz_context *ctx, xps_document *doc, fz_xml *root, fz_matrix *matrix) { char *transform; @@ -163,12 +166,12 @@ xps_parse_matrix_transform(xps_document *doc, fz_xml *root, fz_matrix *matrix) { transform = fz_xml_att(root, "Matrix"); if (transform) - xps_parse_render_transform(doc, transform, matrix); + xps_parse_render_transform(ctx, doc, transform, matrix); } } void -xps_parse_rectangle(xps_document *doc, char *text, fz_rect *rect) +xps_parse_rectangle(fz_context *ctx, xps_document *doc, char *text, fz_rect *rect) { float args[4]; char *s = text; @@ -205,10 +208,9 @@ static int count_commas(char *s) } void -xps_parse_color(xps_document *doc, char *base_uri, char *string, +xps_parse_color(fz_context *ctx, xps_document *doc, char *base_uri, char *string, fz_colorspace **csp, float *samples) { - fz_context *ctx = doc->ctx; char *p; int i, n; char buf[1024]; @@ -307,7 +309,7 @@ xps_parse_color(xps_document *doc, char *base_uri, char *string, } void -xps_set_color(xps_document *doc, fz_colorspace *colorspace, float *samples) +xps_set_color(fz_context *ctx, xps_document *doc, fz_colorspace *colorspace, float *samples) { int i; doc->colorspace = colorspace; diff --git a/source/xps/xps-doc.c b/source/xps/xps-doc.c index 2b8cee8e..41823d56 100644 --- a/source/xps/xps-doc.c +++ b/source/xps/xps-doc.c @@ -15,7 +15,7 @@ "http://schemas.openxps.org/oxps/v1.0/documentstructure" static void -xps_rels_for_part(char *buf, char *name, int buflen) +xps_rels_for_part(fz_context *ctx, xps_document *doc, char *buf, char *name, int buflen) { char *p, *basename; p = strrchr(name, '/'); @@ -34,10 +34,10 @@ xps_rels_for_part(char *buf, char *name, int buflen) */ void -xps_print_page_list(xps_document *doc) +xps_print_page_list(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc = doc->first_fixdoc; - xps_page *page = doc->first_page; + xps_fixpage *page = doc->first_page; if (doc->start_part) printf("start part %s\n", doc->start_part); @@ -56,7 +56,7 @@ xps_print_page_list(xps_document *doc) } static void -xps_add_fixed_document(xps_document *doc, char *name) +xps_add_fixed_document(fz_context *ctx, xps_document *doc, char *name) { xps_fixdoc *fixdoc; @@ -65,8 +65,8 @@ xps_add_fixed_document(xps_document *doc, char *name) if (!strcmp(fixdoc->name, name)) return; - fixdoc = fz_malloc_struct(doc->ctx, xps_fixdoc); - fixdoc->name = fz_strdup(doc->ctx, name); + fixdoc = fz_malloc_struct(ctx, xps_fixdoc); + fixdoc->name = fz_strdup(ctx, name); fixdoc->outline = NULL; fixdoc->next = NULL; @@ -83,7 +83,7 @@ xps_add_fixed_document(xps_document *doc, char *name) } void -xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri) +xps_add_link(fz_context *ctx, xps_document *doc, const fz_rect *area, char *base_uri, char *target_uri) { int len; char *buffer = NULL; @@ -91,7 +91,6 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe xps_target *target; fz_link_dest dest; fz_link *link; - fz_context *ctx = doc->ctx; fz_var(buffer); @@ -102,9 +101,9 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe { len = 2 + (base_uri ? strlen(base_uri) : 0) + (target_uri ? strlen(target_uri) : 0); - buffer = fz_malloc(doc->ctx, len); - xps_resolve_url(buffer, base_uri, target_uri, len); - if (xps_url_is_remote(buffer)) + buffer = fz_malloc(ctx, len); + xps_resolve_url(ctx, doc, buffer, base_uri, target_uri, len); + if (xps_url_is_remote(ctx, doc, buffer)) { dest.kind = FZ_LINK_URI; dest.ld.uri.is_map = 0; @@ -140,13 +139,13 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe dest.ld.gotor.new_window = 0; } - link = fz_new_link(doc->ctx, area, dest); + link = fz_new_link(ctx, area, dest); link->next = doc->current_page->links; doc->current_page->links = link; } fz_always(ctx) { - fz_free(doc->ctx, buffer); + fz_free(ctx, buffer); } fz_catch(ctx) { @@ -154,32 +153,23 @@ xps_add_link(xps_document *doc, const fz_rect *area, char *base_uri, char *targe } } -fz_link * -xps_load_links(xps_document *doc, xps_page *page) -{ - if (!page->links_resolved) - fz_warn(doc->ctx, "xps_load_links before page has been executed!"); - return fz_keep_link(doc->ctx, page->links); -} - static void -xps_add_fixed_page(xps_document *doc, char *name, int width, int height) +xps_add_fixed_page(fz_context *ctx, xps_document *doc, char *name, int width, int height) { - xps_page *page; + xps_fixpage *page; /* Check for duplicates first */ for (page = doc->first_page; page; page = page->next) if (!strcmp(page->name, name)) return; - page = fz_malloc_struct(doc->ctx, xps_page); - page->name = fz_strdup(doc->ctx, name); + page = fz_malloc_struct(ctx, xps_fixpage); + page->name = fz_strdup(ctx, name); page->number = doc->page_count++; page->width = width; page->height = height; page->links = NULL; page->links_resolved = 0; - page->root = NULL; page->next = NULL; if (!doc->first_page) @@ -195,18 +185,18 @@ xps_add_fixed_page(xps_document *doc, char *name, int width, int height) } static void -xps_add_link_target(xps_document *doc, char *name) +xps_add_link_target(fz_context *ctx, xps_document *doc, char *name) { - xps_page *page = doc->last_page; - xps_target *target = fz_malloc_struct(doc->ctx, xps_target); - target->name = fz_strdup(doc->ctx, name); + xps_fixpage *page = doc->last_page; + xps_target *target = fz_malloc_struct(ctx, xps_target); + target->name = fz_strdup(ctx, name); target->page = page->number; target->next = doc->target; doc->target = target; } int -xps_lookup_link_target(xps_document *doc, char *target_uri) +xps_lookup_link_target(fz_context *ctx, xps_document *doc, char *target_uri) { xps_target *target; char *needle = strrchr(target_uri, '#'); @@ -218,29 +208,28 @@ xps_lookup_link_target(xps_document *doc, char *target_uri) } static void -xps_drop_link_targets(xps_document *doc) +xps_drop_link_targets(fz_context *ctx, xps_document *doc) { xps_target *target = doc->target, *next; while (target) { next = target->next; - fz_free(doc->ctx, target->name); - fz_free(doc->ctx, target); + fz_free(ctx, target->name); + fz_free(ctx, target); target = next; } } static void -xps_drop_fixed_pages(xps_document *doc) +xps_drop_fixed_pages(fz_context *ctx, xps_document *doc) { - xps_page *page = doc->first_page; + xps_fixpage *page = doc->first_page; while (page) { - xps_page *next = page->next; - xps_drop_page(doc, page); - fz_drop_link(doc->ctx, page->links); - fz_free(doc->ctx, page->name); - fz_free(doc->ctx, page); + xps_fixpage *next = page->next; + fz_drop_link(ctx, page->links); + fz_free(ctx, page->name); + fz_free(ctx, page); page = next; } doc->first_page = NULL; @@ -248,15 +237,15 @@ xps_drop_fixed_pages(xps_document *doc) } static void -xps_drop_fixed_documents(xps_document *doc) +xps_drop_fixed_documents(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc = doc->first_fixdoc; while (fixdoc) { xps_fixdoc *next = fixdoc->next; - fz_free(doc->ctx, fixdoc->name); - fz_free(doc->ctx, fixdoc->outline); - fz_free(doc->ctx, fixdoc); + fz_free(ctx, fixdoc->name); + fz_free(ctx, fixdoc->outline); + fz_free(ctx, fixdoc); fixdoc = next; } doc->first_fixdoc = NULL; @@ -264,11 +253,11 @@ xps_drop_fixed_documents(xps_document *doc) } void -xps_drop_page_list(xps_document *doc) +xps_drop_page_list(fz_context *ctx, xps_document *doc) { - xps_drop_fixed_documents(doc); - xps_drop_fixed_pages(doc); - xps_drop_link_targets(doc); + xps_drop_fixed_documents(ctx, doc); + xps_drop_fixed_pages(ctx, doc); + xps_drop_link_targets(ctx, doc); } /* @@ -276,7 +265,7 @@ xps_drop_page_list(xps_document *doc) */ static void -xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) +xps_parse_metadata_imp(fz_context *ctx, xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) { while (item) { @@ -287,13 +276,13 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (target && type) { char tgtbuf[1024]; - xps_resolve_url(tgtbuf, doc->base_uri, target, sizeof tgtbuf); + xps_resolve_url(ctx, doc, tgtbuf, doc->base_uri, target, sizeof tgtbuf); if (!strcmp(type, REL_START_PART) || !strcmp(type, REL_START_PART_OXPS)) - doc->start_part = fz_strdup(doc->ctx, tgtbuf); + doc->start_part = fz_strdup(ctx, tgtbuf); if ((!strcmp(type, REL_DOC_STRUCTURE) || !strcmp(type, REL_DOC_STRUCTURE_OXPS)) && fixdoc) - fixdoc->outline = fz_strdup(doc->ctx, tgtbuf); + fixdoc->outline = fz_strdup(ctx, tgtbuf); if (!fz_xml_att(item, "Id")) - fz_warn(doc->ctx, "missing relationship id for %s", target); + fz_warn(ctx, "missing relationship id for %s", target); } } @@ -303,8 +292,8 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (source) { char srcbuf[1024]; - xps_resolve_url(srcbuf, doc->base_uri, source, sizeof srcbuf); - xps_add_fixed_document(doc, srcbuf); + xps_resolve_url(ctx, doc, srcbuf, doc->base_uri, source, sizeof srcbuf); + xps_add_fixed_document(ctx, doc, srcbuf); } } @@ -318,8 +307,8 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) if (source) { char srcbuf[1024]; - xps_resolve_url(srcbuf, doc->base_uri, source, sizeof srcbuf); - xps_add_fixed_page(doc, srcbuf, width, height); + xps_resolve_url(ctx, doc, srcbuf, doc->base_uri, source, sizeof srcbuf); + xps_add_fixed_page(ctx, doc, srcbuf, width, height); } } @@ -327,17 +316,17 @@ xps_parse_metadata_imp(xps_document *doc, fz_xml *item, xps_fixdoc *fixdoc) { char *name = fz_xml_att(item, "Name"); if (name) - xps_add_link_target(doc, name); + xps_add_link_target(ctx, doc, name); } - xps_parse_metadata_imp(doc, fz_xml_down(item), fixdoc); + xps_parse_metadata_imp(ctx, doc, fz_xml_down(item), fixdoc); item = fz_xml_next(item); } } static void -xps_parse_metadata(xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) +xps_parse_metadata(fz_context *ctx, xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) { fz_xml *root; char buf[1024]; @@ -360,31 +349,30 @@ xps_parse_metadata(xps_document *doc, xps_part *part, xps_fixdoc *fixdoc) doc->base_uri = buf; doc->part_uri = part->name; - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); - xps_parse_metadata_imp(doc, root, fixdoc); - fz_drop_xml(doc->ctx, root); + root = fz_parse_xml(ctx, part->data, part->size, 0); + xps_parse_metadata_imp(ctx, doc, root, fixdoc); + fz_drop_xml(ctx, root); doc->base_uri = NULL; doc->part_uri = NULL; } static void -xps_read_and_process_metadata_part(xps_document *doc, char *name, xps_fixdoc *fixdoc) +xps_read_and_process_metadata_part(fz_context *ctx, xps_document *doc, char *name, xps_fixdoc *fixdoc) { - fz_context *ctx = doc->ctx; xps_part *part; - if (!xps_has_part(doc, name)) + if (!xps_has_part(ctx, doc, name)) return; - part = xps_read_part(doc, name); + part = xps_read_part(ctx, doc, name); fz_try(ctx) { - xps_parse_metadata(doc, part, fixdoc); + xps_parse_metadata(ctx, doc, part, fixdoc); } fz_always(ctx) { - xps_drop_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -393,57 +381,56 @@ xps_read_and_process_metadata_part(xps_document *doc, char *name, xps_fixdoc *fi } void -xps_read_page_list(xps_document *doc) +xps_read_page_list(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc; - xps_read_and_process_metadata_part(doc, "/_rels/.rels", NULL); + xps_read_and_process_metadata_part(ctx, doc, "/_rels/.rels", NULL); if (!doc->start_part) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find fixed document sequence start part"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find fixed document sequence start part"); - xps_read_and_process_metadata_part(doc, doc->start_part, NULL); + xps_read_and_process_metadata_part(ctx, doc, doc->start_part, NULL); for (fixdoc = doc->first_fixdoc; fixdoc; fixdoc = fixdoc->next) { char relbuf[1024]; - fz_try(doc->ctx) + fz_try(ctx) { - xps_rels_for_part(relbuf, fixdoc->name, sizeof relbuf); - xps_read_and_process_metadata_part(doc, relbuf, fixdoc); + xps_rels_for_part(ctx, doc, relbuf, fixdoc->name, sizeof relbuf); + xps_read_and_process_metadata_part(ctx, doc, relbuf, fixdoc); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot process FixedDocument rels part"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot process FixedDocument rels part"); } - xps_read_and_process_metadata_part(doc, fixdoc->name, fixdoc); + xps_read_and_process_metadata_part(ctx, doc, fixdoc->name, fixdoc); } } int -xps_count_pages(xps_document *doc) +xps_count_pages(fz_context *ctx, xps_document *doc) { return doc->page_count; } -static void -xps_load_fixed_page(xps_document *doc, xps_page *page) +static fz_xml * +xps_load_fixed_page(fz_context *ctx, xps_document *doc, xps_fixpage *page) { xps_part *part; fz_xml *root; char *width_att; char *height_att; - fz_context *ctx = doc->ctx; - part = xps_read_part(doc, page->name); + part = xps_read_part(ctx, doc, page->name); fz_try(ctx) { - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); + root = fz_parse_xml(ctx, part->data, part->size, 0); } fz_always(ctx) { - xps_drop_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -451,89 +438,117 @@ xps_load_fixed_page(xps_document *doc, xps_page *page) root = NULL; } if (!root) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing root element"); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing root element"); if (fz_xml_is_tag(root, "AlternateContent")) { - fz_xml *node = xps_lookup_alternate_content(root); + fz_xml *node = xps_lookup_alternate_content(ctx, doc, root); if (!node) { - fz_drop_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing alternate root element"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing alternate root element"); } fz_detach_xml(node); - fz_drop_xml(doc->ctx, root); + fz_drop_xml(ctx, root); root = node; } if (strcmp(fz_xml_tag(root), "FixedPage")) { - fz_drop_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected FixedPage element"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected FixedPage element"); } width_att = fz_xml_att(root, "Width"); if (!width_att) { - fz_drop_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Width"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Width"); } height_att = fz_xml_att(root, "Height"); if (!height_att) { - fz_drop_xml(doc->ctx, root); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Height"); + fz_drop_xml(ctx, root); + fz_throw(ctx, FZ_ERROR_GENERIC, "FixedPage missing required attribute: Height"); } page->width = atoi(width_att); page->height = atoi(height_att); - page->root = root; + + return root; } -xps_page * -xps_load_page(xps_document *doc, int number) +fz_link * +xps_load_links(fz_context *ctx, xps_page *page) { - xps_page *page; - int n = 0; - - for (page = doc->first_page; page; page = page->next) - { - if (n == number) - { - doc->current_page = page; - if (!page->root) - xps_load_fixed_page(doc, page); - return page; - } - n ++; - } - - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find page %d", number + 1); + if (!page->fix->links_resolved) + fz_warn(ctx, "xps_load_links before page has been executed!"); + return fz_keep_link(ctx, page->fix->links); } fz_rect * -xps_bound_page(xps_document *doc, xps_page *page, fz_rect *bounds) +xps_bound_page(fz_context *ctx, xps_page *page, fz_rect *bounds) { bounds->x0 = bounds->y0 = 0; - bounds->x1 = page->width * 72.0f / 96.0f; - bounds->y1 = page->height * 72.0f / 96.0f; + bounds->x1 = page->fix->width * 72.0f / 96.0f; + bounds->y1 = page->fix->height * 72.0f / 96.0f; return bounds; } void -xps_drop_page(xps_document *doc, xps_page *page) +xps_drop_page_imp(fz_context *ctx, xps_page *page) { if (page == NULL) return; - /* only free the XML contents */ - if (page->root) - fz_drop_xml(doc->ctx, page->root); - page->root = NULL; + fz_drop_document(ctx, &page->doc->super); + fz_drop_xml(ctx, page->root); +} + +xps_page * +xps_load_page(fz_context *ctx, xps_document *doc, int number) +{ + xps_page *page = NULL; + xps_fixpage *fix; + fz_xml *root; + int n = 0; + + fz_var(page); + + for (fix = doc->first_page; fix; fix = fix->next) + { + if (n == number) + { + doc->current_page = fix; + + root = xps_load_fixed_page(ctx, doc, fix); + fz_try(ctx) + { + page = fz_new_page(ctx, sizeof *page); + page->super.load_links = (fz_page_load_links_fn *)xps_load_links; + page->super.bound_page = (fz_page_bound_page_fn *)xps_bound_page; + page->super.run_page_contents = (fz_page_run_page_contents_fn *)xps_run_page; + page->super.drop_page_imp = (fz_page_drop_page_imp_fn *)xps_drop_page_imp; + + page->doc = (xps_document*) fz_keep_document(ctx, &doc->super); + page->fix = fix; + page->root = root; + } + fz_catch(ctx) + { + fz_drop_xml(ctx, root); + fz_rethrow(ctx); + } + return page; + } + n ++; + } + + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find page %d", number + 1); } static int -xps_recognize(fz_context *doc, const char *magic) +xps_recognize(fz_context *ctx, const char *magic) { char *ext = strrchr(magic, '.'); diff --git a/source/xps/xps-glyphs.c b/source/xps/xps-glyphs.c index 4f030be0..e15eb726 100644 --- a/source/xps/xps-glyphs.c +++ b/source/xps/xps-glyphs.c @@ -52,12 +52,11 @@ xps_encode_font_char(fz_font *font, int code) } void -xps_measure_font_glyph(xps_document *doc, fz_font *font, int gid, xps_glyph_metrics *mtx) +xps_measure_font_glyph(fz_context *ctx, xps_document *doc, fz_font *font, int gid, xps_glyph_metrics *mtx) { int mask = FT_LOAD_NO_SCALE | FT_LOAD_IGNORE_TRANSFORM; FT_Face face = font->ft_face; FT_Fixed hadv = 0, vadv = 0; - fz_context *ctx = doc->ctx; fz_lock(ctx, FZ_LOCK_FREETYPE); FT_Get_Advance(face, gid, mask, &hadv); @@ -70,21 +69,21 @@ xps_measure_font_glyph(xps_document *doc, fz_font *font, int gid, xps_glyph_metr } static fz_font * -xps_lookup_font(xps_document *doc, char *name) +xps_lookup_font(fz_context *ctx, xps_document *doc, char *name) { xps_font_cache *cache; for (cache = doc->font_table; cache; cache = cache->next) if (!xps_strcasecmp(cache->name, name)) - return fz_keep_font(doc->ctx, cache->font); + return fz_keep_font(ctx, cache->font); return NULL; } static void -xps_insert_font(xps_document *doc, char *name, fz_font *font) +xps_insert_font(fz_context *ctx, xps_document *doc, char *name, fz_font *font) { - xps_font_cache *cache = fz_malloc_struct(doc->ctx, xps_font_cache); - cache->name = fz_strdup(doc->ctx, name); - cache->font = fz_keep_font(doc->ctx, font); + xps_font_cache *cache = fz_malloc_struct(ctx, xps_font_cache); + cache->name = fz_strdup(ctx, name); + cache->font = fz_keep_font(ctx, font); cache->next = doc->font_table; doc->font_table = cache; } @@ -94,7 +93,7 @@ xps_insert_font(xps_document *doc, char *name, fz_font *font) * data with the GUID in the fontname. */ static void -xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) +xps_deobfuscate_font_resource(fz_context *ctx, xps_document *doc, xps_part *part) { unsigned char buf[33]; unsigned char key[16]; @@ -103,7 +102,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) if (part->size < 32) { - fz_warn(doc->ctx, "insufficient data for font deobfuscation"); + fz_warn(ctx, "insufficient data for font deobfuscation"); return; } @@ -120,7 +119,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) if (i != 32) { - fz_warn(doc->ctx, "cannot extract GUID from obfuscated font part name"); + fz_warn(ctx, "cannot extract GUID from obfuscated font part name"); return; } @@ -135,7 +134,7 @@ xps_deobfuscate_font_resource(xps_document *doc, xps_part *part) } static void -xps_select_best_font_encoding(xps_document *doc, fz_font *font) +xps_select_best_font_encoding(fz_context *ctx, xps_document *doc, fz_font *font) { static struct { int pid, eid; } xps_cmap_list[] = { @@ -166,7 +165,7 @@ xps_select_best_font_encoding(xps_document *doc, fz_font *font) } } - fz_warn(doc->ctx, "cannot find a suitable cmap"); + fz_warn(ctx, "cannot find a suitable cmap"); } /* @@ -257,7 +256,7 @@ xps_parse_glyph_metrics(char *s, float *advance, float *uofs, float *vofs) * Calculate metrics for positioning. */ static fz_text * -xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, +xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, fz_font *font, float size, float originx, float originy, int is_sideways, int bidi_level, char *indices, char *unicode) @@ -273,7 +272,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, int un = 0; if (!unicode && !indices) - fz_warn(doc->ctx, "glyphs element with neither characters nor indices"); + fz_warn(ctx, "glyphs element with neither characters nor indices"); if (us) { @@ -289,7 +288,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, else fz_scale(&tm, size, -size); - text = fz_new_text(doc->ctx, font, &tm, is_sideways); + text = fz_new_text(ctx, font, &tm, is_sideways); while ((us && un > 0) || (is && *is)) { @@ -331,7 +330,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, if (glyph_index == -1) glyph_index = xps_encode_font_char(font, char_code); - xps_measure_font_glyph(doc, font, glyph_index, &mtx); + xps_measure_font_glyph(ctx, doc, font, glyph_index, &mtx); if (is_sideways) advance = mtx.vadv * 100; else if (bidi_level & 1) @@ -366,7 +365,7 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, f = y - v_offset; } - fz_add_text(doc->ctx, text, glyph_index, char_code, e, f); + fz_add_text(ctx, text, glyph_index, char_code, e, f); x += advance * 0.01f * size; } @@ -376,9 +375,11 @@ xps_parse_glyphs_imp(xps_document *doc, const fz_matrix *ctm, } void -xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, +xps_parse_glyphs(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; + fz_xml *node; char *fill_uri; @@ -459,17 +460,17 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, fill_uri = base_uri; opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &fill_att, &fill_tag, &fill_uri); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); /* * Check that we have all the necessary information. */ if (!font_size_att || !font_uri_att || !origin_x_att || !origin_y_att) { - fz_warn(doc->ctx, "missing attributes in glyphs element"); + fz_warn(ctx, "missing attributes in glyphs element"); return; } @@ -486,7 +487,7 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, * Find and load the font resource */ - xps_resolve_url(partname, base_uri, font_uri_att, sizeof partname); + xps_resolve_url(ctx, doc, partname, base_uri, font_uri_att, sizeof partname); subfont = strrchr(partname, '#'); if (subfont) { @@ -506,45 +507,45 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, fz_strlcat(fakename, "#BoldItalic", sizeof fakename); } - font = xps_lookup_font(doc, fakename); + font = xps_lookup_font(ctx, doc, fakename); if (!font) { fz_buffer *buf = NULL; fz_var(buf); - fz_try(doc->ctx) + fz_try(ctx) { - part = xps_read_part(doc, partname); + part = xps_read_part(ctx, doc, partname); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot find font resource part '%s'", partname); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot find font resource part '%s'", partname); return; } /* deobfuscate if necessary */ if (strstr(part->name, ".odttf")) - xps_deobfuscate_font_resource(doc, part); + xps_deobfuscate_font_resource(ctx, doc, part); if (strstr(part->name, ".ODTTF")) - xps_deobfuscate_font_resource(doc, part); + xps_deobfuscate_font_resource(ctx, doc, part); - fz_try(doc->ctx) + fz_try(ctx) { - buf = fz_new_buffer_from_data(doc->ctx, part->data, part->size); + buf = fz_new_buffer_from_data(ctx, part->data, part->size); /* part->data is now owned by buf */ part->data = NULL; - font = fz_new_font_from_buffer(doc->ctx, NULL, buf, subfontid, 1); + font = fz_new_font_from_buffer(ctx, NULL, buf, subfontid, 1); } - fz_always(doc->ctx) + fz_always(ctx) { - fz_drop_buffer(doc->ctx, buf); - xps_drop_part(doc, part); + fz_drop_buffer(ctx, buf); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot load font resource '%s'", partname); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot load font resource '%s'", partname); return; } @@ -554,8 +555,8 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, font->ft_italic = !!strstr(style_att, "Italic"); } - xps_select_best_font_encoding(doc, font); - xps_insert_font(doc, fakename, font); + xps_select_best_font_encoding(ctx, doc, font); + xps_insert_font(ctx, doc, fakename, font); } /* @@ -566,27 +567,27 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, { fz_matrix transform; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&local_ctm, &transform, &local_ctm); } if (clip_att || clip_tag) - xps_clip(doc, &local_ctm, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag); font_size = fz_atof(font_size_att); - text = xps_parse_glyphs_imp(doc, &local_ctm, font, font_size, + text = xps_parse_glyphs_imp(ctx, doc, &local_ctm, font, font_size, fz_atof(origin_x_att), fz_atof(origin_y_att), is_sideways, bidi_level, indices_att, unicode_att); - fz_bound_text(doc->ctx, text, NULL, &local_ctm, &area); + fz_bound_text(ctx, text, NULL, &local_ctm, &area); if (navigate_uri_att) - xps_add_link(doc, &area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att); - xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); /* If it's a solid color brush fill/stroke do a simple fill */ @@ -602,12 +603,12 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, float samples[FZ_MAX_COLORS]; fz_colorspace *colorspace; - xps_parse_color(doc, base_uri, fill_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples); if (fill_opacity_att) samples[0] *= fz_atof(fill_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_fill_text(doc->dev, text, &local_ctm, + fz_fill_text(ctx, dev, text, &local_ctm, doc->colorspace, doc->color, doc->alpha); } @@ -615,17 +616,17 @@ xps_parse_glyphs(xps_document *doc, const fz_matrix *ctm, if (fill_tag) { - fz_clip_text(doc->dev, text, &local_ctm, 0); - xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag); - fz_pop_clip(doc->dev); + fz_clip_text(ctx, dev, text, &local_ctm, 0); + xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag); + fz_pop_clip(ctx, dev); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); - fz_drop_text(doc->ctx, text); + fz_drop_text(ctx, text); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); - fz_drop_font(doc->ctx, font); + fz_drop_font(ctx, font); } diff --git a/source/xps/xps-gradient.c b/source/xps/xps-gradient.c index d156a406..f3a9f8e8 100644 --- a/source/xps/xps-gradient.c +++ b/source/xps/xps-gradient.c @@ -35,7 +35,7 @@ static inline float lerp(float a, float b, float x) } static int -xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, +xps_parse_gradient_stops(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *node, struct stop *stops, int maxcount) { fz_colorspace *colorspace; @@ -60,9 +60,9 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, stops[count].offset = fz_atof(offset); stops[count].index = count; - xps_parse_color(doc, base_uri, color, &colorspace, sample); + xps_parse_color(ctx, doc, base_uri, color, &colorspace, sample); - fz_convert_color(doc->ctx, fz_device_rgb(doc->ctx), rgb, colorspace, sample + 1); + fz_convert_color(ctx, fz_device_rgb(ctx), rgb, colorspace, sample + 1); stops[count].r = rgb[0]; stops[count].g = rgb[1]; @@ -77,7 +77,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, if (count == 0) { - fz_warn(doc->ctx, "gradient brush has no gradient stops"); + fz_warn(ctx, "gradient brush has no gradient stops"); stops[0].offset = 0; stops[0].r = 0; stops[0].g = 0; @@ -92,7 +92,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, } if (count == maxcount) - fz_warn(doc->ctx, "gradient brush exceeded maximum number of gradient stops"); + fz_warn(ctx, "gradient brush exceeded maximum number of gradient stops"); /* Postprocess to make sure the range of offsets is 0.0 to 1.0 */ @@ -175,7 +175,7 @@ xps_parse_gradient_stops(xps_document *doc, char *base_uri, fz_xml *node, } static void -xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count) +xps_sample_gradient_stops(fz_context *ctx, xps_document *doc, fz_shade *shade, struct stop *stops, int count) { float offset, d; int i, k; @@ -204,18 +204,19 @@ xps_sample_gradient_stops(fz_shade *shade, struct stop *stops, int count) */ static void -xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, +xps_draw_one_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, struct stop *stops, int count, int extend, float x0, float y0, float r0, float x1, float y1, float r1) { + fz_device *dev = doc->dev; fz_shade *shade; /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ - shade = fz_malloc_struct(doc->ctx, fz_shade); + shade = fz_malloc_struct(ctx, fz_shade); FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp); - shade->colorspace = fz_device_rgb(doc->ctx); + shade->colorspace = fz_device_rgb(ctx); shade->bbox = fz_infinite_rect; shade->matrix = fz_identity; shade->use_background = 0; @@ -224,7 +225,7 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.extend[0] = extend; shade->u.l_or_r.extend[1] = extend; - xps_sample_gradient_stops(shade, stops, count); + xps_sample_gradient_stops(ctx, doc, shade, stops, count); shade->u.l_or_r.coords[0][0] = x0; shade->u.l_or_r.coords[0][1] = y0; @@ -233,9 +234,9 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.coords[1][1] = y1; shade->u.l_or_r.coords[1][2] = r1; - fz_fill_shade(doc->dev, shade, ctm, 1); + fz_fill_shade(ctx, dev, shade, ctm, 1); - fz_drop_shade(doc->ctx, shade); + fz_drop_shade(ctx, shade); } /* @@ -243,17 +244,18 @@ xps_draw_one_radial_gradient(xps_document *doc, const fz_matrix *ctm, */ static void -xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, +xps_draw_one_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, struct stop *stops, int count, int extend, float x0, float y0, float x1, float y1) { + fz_device *dev = doc->dev; fz_shade *shade; /* TODO: this (and the stuff in pdf_shade) should move to res_shade.c */ - shade = fz_malloc_struct(doc->ctx, fz_shade); + shade = fz_malloc_struct(ctx, fz_shade); FZ_INIT_STORABLE(shade, 1, fz_drop_shade_imp); - shade->colorspace = fz_device_rgb(doc->ctx); + shade->colorspace = fz_device_rgb(ctx); shade->bbox = fz_infinite_rect; shade->matrix = fz_identity; shade->use_background = 0; @@ -262,7 +264,7 @@ xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.extend[0] = extend; shade->u.l_or_r.extend[1] = extend; - xps_sample_gradient_stops(shade, stops, count); + xps_sample_gradient_stops(ctx, doc, shade, stops, count); shade->u.l_or_r.coords[0][0] = x0; shade->u.l_or_r.coords[0][1] = y0; @@ -271,9 +273,9 @@ xps_draw_one_linear_gradient(xps_document *doc, const fz_matrix *ctm, shade->u.l_or_r.coords[1][1] = y1; shade->u.l_or_r.coords[1][2] = 0; - fz_fill_shade(doc->dev, shade, ctm, doc->opacity[doc->opacity_top]); + fz_fill_shade(ctx, dev, shade, ctm, doc->opacity[doc->opacity_top]); - fz_drop_shade(doc->ctx, shade); + fz_drop_shade(ctx, shade); } /* @@ -292,7 +294,7 @@ static inline float point_inside_circle(float px, float py, float x, float y, fl } static void -xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, struct stop *stops, int count, fz_xml *root, int spread) { @@ -317,9 +319,9 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect yrad = 1.0; if (origin_att) - xps_parse_point(origin_att, &x0, &y0); + xps_parse_point(ctx, doc, origin_att, &x0, &y0); if (center_att) - xps_parse_point(center_att, &x1, &y1); + xps_parse_point(ctx, doc, center_att, &x1, &y1); if (radius_x_att) xrad = fz_atof(radius_x_att); if (radius_y_att) @@ -353,7 +355,7 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect if (spread == SPREAD_REPEAT) { for (i = ma - 1; i >= 0; i--) - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); } else if (spread == SPREAD_REFLECT) { @@ -361,13 +363,13 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect ma++; for (i = ma - 2; i >= 0; i -= 2) { - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad); } } else { - xps_draw_one_radial_gradient(doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1); + xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1); } } @@ -377,7 +379,7 @@ xps_draw_radial_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect */ static void -xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_draw_linear_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, struct stop *stops, int count, fz_xml *root, int spread) { @@ -395,9 +397,9 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect x1 = y1 = 1; if (start_point_att) - xps_parse_point(start_point_att, &x0, &y0); + xps_parse_point(ctx, doc, start_point_att, &x0, &y0); if (end_point_att) - xps_parse_point(end_point_att, &x1, &y1); + xps_parse_point(ctx, doc, end_point_att, &x1, &y1); p1.x = x0; p1.y = y0; p2.x = x1; p2.y = y1; fz_transform_rect(&local_area, fz_invert_matrix(&inv, ctm)); @@ -415,7 +417,7 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect if (spread == SPREAD_REPEAT) { for (i = mi; i < ma; i++) - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); } else if (spread == SPREAD_REFLECT) { @@ -423,13 +425,13 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect mi--; for (i = mi; i < ma; i += 2) { - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); - xps_draw_one_linear_gradient(doc, ctm, stops, count, 0, x0 + (i + 2) * dx, y0 + (i + 2) * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + i * dx, y0 + i * dy, x1 + i * dx, y1 + i * dy); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 0, x0 + (i + 2) * dx, y0 + (i + 2) * dy, x1 + i * dx, y1 + i * dy); } } else { - xps_draw_one_linear_gradient(doc, ctm, stops, count, 1, x0, y0, x1, y1); + xps_draw_one_linear_gradient(ctx, doc, ctm, stops, count, 1, x0, y0, x1, y1); } } @@ -439,9 +441,9 @@ xps_draw_linear_gradient(xps_document *doc, const fz_matrix *ctm, const fz_rect */ static void -xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, - void (*draw)(xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int)) + void (*draw)(fz_context *ctx, xps_document *, const fz_matrix*, const fz_rect *, struct stop *, int, fz_xml *, int)) { fz_xml *node; @@ -473,7 +475,7 @@ xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect stop_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); spread_method = SPREAD_PAD; if (spread_att) @@ -488,40 +490,40 @@ xps_parse_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); if (!stop_tag) { - fz_warn(doc->ctx, "missing gradient stops tag"); + fz_warn(ctx, "missing gradient stops tag"); return; } - stop_count = xps_parse_gradient_stops(doc, base_uri, stop_tag, stop_list, MAX_STOPS); + stop_count = xps_parse_gradient_stops(ctx, doc, base_uri, stop_tag, stop_list, MAX_STOPS); if (stop_count == 0) { - fz_warn(doc->ctx, "no gradient stops found"); + fz_warn(ctx, "no gradient stops found"); return; } - xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL); + xps_begin_opacity(ctx, doc, &transform, area, base_uri, dict, opacity_att, NULL); - draw(doc, &transform, area, stop_list, stop_count, root, spread_method); + draw(ctx, doc, &transform, area, stop_list, stop_count, root, spread_method); - xps_end_opacity(doc, base_uri, dict, opacity_att, NULL); + xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL); } void -xps_parse_linear_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_linear_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { - xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient); + xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_linear_gradient); } void -xps_parse_radial_gradient_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_radial_gradient_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { - xps_parse_gradient_brush(doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient); + xps_parse_gradient_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_draw_radial_gradient); } diff --git a/source/xps/xps-image.c b/source/xps/xps-image.c index d9b2ad11..b0d00a2f 100644 --- a/source/xps/xps-image.c +++ b/source/xps/xps-image.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static fz_image * -xps_load_image(fz_context *ctx, xps_part *part) +xps_load_image(fz_context *ctx, xps_document *doc, xps_part *part) { /* Ownership of data always passes in here */ unsigned char *data = part->data; @@ -11,7 +11,7 @@ xps_load_image(fz_context *ctx, xps_part *part) /* FIXME: area unused! */ static void -xps_paint_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, +xps_paint_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void *vimage) { fz_image *image = vimage; @@ -23,11 +23,11 @@ xps_paint_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *ar xs = image->w * 96 / image->xres; ys = image->h * 96 / image->yres; fz_pre_scale(&local_ctm, xs, ys); - fz_fill_image(doc->dev, image, &local_ctm, doc->opacity[doc->opacity_top]); + fz_fill_image(ctx, doc->dev, image, &local_ctm, doc->opacity[doc->opacity_top]); } static void -xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root, xps_part **image_part, xps_part **profile_part) +xps_find_image_brush_source_part(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *root, xps_part **image_part, xps_part **profile_part) { char *image_source_att; char buf[1024]; @@ -38,7 +38,7 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root image_source_att = fz_xml_att(root, "ImageSource"); if (!image_source_att) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find image source attribute"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find image source attribute"); /* "{ColorConvertedBitmap /Resources/Image.tiff /Resources/Profile.icc}" */ if (strstr(image_source_att, "{ColorConvertedBitmap") == image_source_att) @@ -69,20 +69,20 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root } if (!image_name) - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "cannot find image source"); + fz_throw(ctx, FZ_ERROR_GENERIC, "cannot find image source"); if (image_part) { - xps_resolve_url(partname, base_uri, image_name, sizeof partname); - *image_part = xps_read_part(doc, partname); + xps_resolve_url(ctx, doc, partname, base_uri, image_name, sizeof partname); + *image_part = xps_read_part(ctx, doc, partname); } if (profile_part) { if (profile_name) { - xps_resolve_url(partname, base_uri, profile_name, sizeof partname); - *profile_part = xps_read_part(doc, partname); + xps_resolve_url(ctx, doc, partname, base_uri, profile_name, sizeof partname); + *profile_part = xps_read_part(ctx, doc, partname); } else *profile_part = NULL; @@ -90,40 +90,40 @@ xps_find_image_brush_source_part(xps_document *doc, char *base_uri, fz_xml *root } void -xps_parse_image_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_image_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { xps_part *part; fz_image *image; - fz_try(doc->ctx) + fz_try(ctx) { - xps_find_image_brush_source_part(doc, base_uri, root, &part, NULL); + xps_find_image_brush_source_part(ctx, doc, base_uri, root, &part, NULL); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot find image source"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot find image source"); return; } - fz_try(doc->ctx) + fz_try(ctx) { - image = xps_load_image(doc->ctx, part); + image = xps_load_image(ctx, doc, part); image->invert_cmyk_jpeg = 1; } - fz_always(doc->ctx) + fz_always(ctx) { - xps_drop_part(doc, part); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); - fz_warn(doc->ctx, "cannot decode image resource"); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); + fz_warn(ctx, "cannot decode image resource"); return; } - xps_parse_tiling_brush(doc, ctm, area, base_uri, dict, root, xps_paint_image_brush, image); + xps_parse_tiling_brush(ctx, doc, ctm, area, base_uri, dict, root, xps_paint_image_brush, image); - fz_drop_image(doc->ctx, image); + fz_drop_image(ctx, image); } diff --git a/source/xps/xps-outline.c b/source/xps/xps-outline.c index 3b088d78..b6e68c29 100644 --- a/source/xps/xps-outline.c +++ b/source/xps/xps-outline.c @@ -5,17 +5,17 @@ */ static fz_outline * -xps_lookup_last_outline_at_level(fz_outline *node, int level, int target_level) +xps_lookup_last_outline_at_level(fz_context *ctx, xps_document *doc, fz_outline *node, int level, int target_level) { while (node->next) node = node->next; if (level == target_level || !node->down) return node; - return xps_lookup_last_outline_at_level(node->down, level + 1, target_level); + return xps_lookup_last_outline_at_level(ctx, doc, node->down, level + 1, target_level); } static fz_outline * -xps_parse_document_outline(xps_document *doc, fz_xml *root) +xps_parse_document_outline(fz_context *ctx, xps_document *doc, fz_xml *root) { fz_xml *node; fz_outline *head = NULL, *entry, *tail; @@ -30,11 +30,11 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) if (!target || !description) continue; - entry = fz_malloc_struct(doc->ctx, fz_outline); - entry->title = fz_strdup(doc->ctx, description); + entry = fz_malloc_struct(ctx, fz_outline); + entry->title = fz_strdup(ctx, description); entry->dest.kind = FZ_LINK_GOTO; entry->dest.ld.gotor.flags = 0; - entry->dest.ld.gotor.page = xps_lookup_link_target(doc, target); + entry->dest.ld.gotor.page = xps_lookup_link_target(ctx, doc, target); entry->down = NULL; entry->next = NULL; @@ -46,7 +46,7 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) } else { - tail = xps_lookup_last_outline_at_level(head, 1, this_level); + tail = xps_lookup_last_outline_at_level(ctx, doc, head, 1, this_level); if (this_level > last_level) tail->down = entry; else @@ -60,7 +60,7 @@ xps_parse_document_outline(xps_document *doc, fz_xml *root) } static fz_outline * -xps_parse_document_structure(xps_document *doc, fz_xml *root) +xps_parse_document_structure(fz_context *ctx, xps_document *doc, fz_xml *root) { fz_xml *node; if (fz_xml_is_tag(root, "DocumentStructure")) @@ -70,53 +70,53 @@ xps_parse_document_structure(xps_document *doc, fz_xml *root) { node = fz_xml_down(node); if (node && fz_xml_is_tag(node, "DocumentOutline")) - return xps_parse_document_outline(doc, node); + return xps_parse_document_outline(ctx, doc, node); } } return NULL; } static fz_outline * -xps_load_document_structure(xps_document *doc, xps_fixdoc *fixdoc) +xps_load_document_structure(fz_context *ctx, xps_document *doc, xps_fixdoc *fixdoc) { xps_part *part; fz_xml *root; fz_outline *outline; - part = xps_read_part(doc, fixdoc->outline); - fz_try(doc->ctx) + part = xps_read_part(ctx, doc, fixdoc->outline); + fz_try(ctx) { - root = fz_parse_xml(doc->ctx, part->data, part->size, 0); + root = fz_parse_xml(ctx, part->data, part->size, 0); } - fz_always(doc->ctx) + fz_always(ctx) { - xps_drop_part(doc, part); + xps_drop_part(ctx, doc, part); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow(doc->ctx); + fz_rethrow(ctx); } if (!root) return NULL; - fz_try(doc->ctx) + fz_try(ctx) { - outline = xps_parse_document_structure(doc, root); + outline = xps_parse_document_structure(ctx, doc, root); } - fz_always(doc->ctx) + fz_always(ctx) { - fz_drop_xml(doc->ctx, root); + fz_drop_xml(ctx, root); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow(doc->ctx); + fz_rethrow(ctx); } return outline; } fz_outline * -xps_load_outline(xps_document *doc) +xps_load_outline(fz_context *ctx, xps_document *doc) { xps_fixdoc *fixdoc; fz_outline *head = NULL, *tail, *outline; @@ -125,13 +125,13 @@ xps_load_outline(xps_document *doc) { if (fixdoc->outline) { - fz_try(doc->ctx) + fz_try(ctx) { - outline = xps_load_document_structure(doc, fixdoc); + outline = xps_load_document_structure(ctx, doc, fixdoc); } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_rethrow_if(doc->ctx, FZ_ERROR_TRYLATER); + fz_rethrow_if(ctx, FZ_ERROR_TRYLATER); outline = NULL; } if (!outline) diff --git a/source/xps/xps-path.c b/source/xps/xps-path.c index ee412d64..e1245a9a 100644 --- a/source/xps/xps-path.c +++ b/source/xps/xps-path.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static char * -xps_parse_float_array(char *s, int num, float *x) +xps_parse_float_array(fz_context *ctx, xps_document *doc, char *s, int num, float *x) { int k = 0; @@ -24,12 +24,12 @@ xps_parse_float_array(char *s, int num, float *x) } char * -xps_parse_point(char *s_in, float *x, float *y) +xps_parse_point(fz_context *ctx, xps_document *doc, char *s_in, float *x, float *y) { char *s_out = s_in; float xy[2]; - s_out = xps_parse_float_array(s_out, 2, &xy[0]); + s_out = xps_parse_float_array(ctx, doc, s_out, 2, &xy[0]); *x = xy[0]; *y = xy[1]; return s_out; @@ -44,7 +44,7 @@ xps_parse_point(char *s_in, float *x, float *y) * calculated by th0, and on exit, a point is generated for us at th0. */ static void -xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw) +xps_draw_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, const fz_matrix *mtx, float th0, float th1, int iscw) { float t, d; fz_point p; @@ -59,7 +59,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float for (t = th0 + d; t < th1 - d/2; t += d) { fz_transform_point_xy(&p, mtx, cosf(t), sinf(t)); - fz_lineto(doc, path, p.x, p.y); + fz_lineto(ctx, path, p.x, p.y); } } else @@ -68,7 +68,7 @@ xps_draw_arc_segment(fz_context *doc, fz_path *path, const fz_matrix *mtx, float for (t = th0 - d; t > th1 + d/2; t -= d) { fz_transform_point_xy(&p, mtx, cosf(t), sinf(t)); - fz_lineto(doc, path, p.x, p.y); + fz_lineto(ctx, path, p.x, p.y); } } } @@ -106,7 +106,7 @@ angle_between(const fz_point u, const fz_point v) If is_clockwise, then the arc sweeps clockwise. */ static void -xps_draw_arc(fz_context *doc, fz_path *path, +xps_draw_arc(fz_context *ctx, xps_document *doc, fz_path *path, float size_x, float size_y, float rotation_angle, int is_large_arc, int is_clockwise, float point_x, float point_y) @@ -122,7 +122,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, float sign; float th1, dth; - pt = fz_currentpoint(doc, path); + pt = fz_currentpoint(ctx, path); x1 = pt.x; y1 = pt.y; x2 = point_x; @@ -146,7 +146,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, ry = fabsf(ry); if (rx < 0.001f || ry < 0.001f || (x1 == x2 && y1 == y2)) { - fz_lineto(doc, path, x2, y2); + fz_lineto(ctx, path, x2, y2); return; } @@ -203,9 +203,9 @@ xps_draw_arc(fz_context *doc, fz_path *path, } fz_pre_scale(fz_pre_rotate(fz_translate(&mtx, cx, cy), rotation_angle), rx, ry); - xps_draw_arc_segment(doc, path, &mtx, th1, th1 + dth, is_clockwise); + xps_draw_arc_segment(ctx, doc, path, &mtx, th1, th1 + dth, is_clockwise); - fz_lineto(doc, path, point_x, point_y); + fz_lineto(ctx, path, point_x, point_y); } /* @@ -215,7 +215,7 @@ xps_draw_arc(fz_context *doc, fz_path *path, */ static fz_path * -xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) +xps_parse_abbreviated_geometry(fz_context *ctx, xps_document *doc, char *geom, int *fill_rule) { fz_path *path; char **args; @@ -228,9 +228,9 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) float smooth_x, smooth_y; /* saved cubic bezier control point for smooth curves */ int reset_smooth; - path = fz_new_path(doc->ctx); + path = fz_new_path(ctx); - args = fz_malloc_array(doc->ctx, strlen(geom) + 1, sizeof(char*)); + args = fz_malloc_array(ctx, strlen(geom) + 1, sizeof(char*)); pargs = args; while (*s) @@ -288,51 +288,51 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'M': if (i + 1 >= n) break; - fz_moveto(doc->ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); + fz_moveto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); i += 2; break; case 'm': if (i + 1 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_moveto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); + pt = fz_currentpoint(ctx, path); + fz_moveto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); i += 2; break; case 'L': if (i + 1 >= n) break; - fz_lineto(doc->ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); + fz_lineto(ctx, path, fz_atof(args[i]), fz_atof(args[i+1])); i += 2; break; case 'l': if (i + 1 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y + fz_atof(args[i+1])); i += 2; break; case 'H': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, fz_atof(args[i]), pt.y); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, fz_atof(args[i]), pt.y); i += 1; break; case 'h': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x + fz_atof(args[i]), pt.y); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x + fz_atof(args[i]), pt.y); i += 1; break; case 'V': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x, fz_atof(args[i])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x, fz_atof(args[i])); i += 1; break; case 'v': if (i >= n) break; - pt = fz_currentpoint(doc->ctx, path); - fz_lineto(doc->ctx, path, pt.x, pt.y + fz_atof(args[i])); + pt = fz_currentpoint(ctx, path); + fz_lineto(ctx, path, pt.x, pt.y + fz_atof(args[i])); i += 1; break; @@ -344,7 +344,7 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) y2 = fz_atof(args[i+3]); x3 = fz_atof(args[i+4]); y3 = fz_atof(args[i+5]); - fz_curveto(doc->ctx, path, x1, y1, x2, y2, x3, y3); + fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3); i += 6; reset_smooth = 0; smooth_x = x3 - x2; @@ -353,14 +353,14 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'c': if (i + 5 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; x3 = fz_atof(args[i+4]) + pt.x; y3 = fz_atof(args[i+5]) + pt.y; - fz_curveto(doc->ctx, path, x1, y1, x2, y2, x3, y3); + fz_curveto(ctx, path, x1, y1, x2, y2, x3, y3); i += 6; reset_smooth = 0; smooth_x = x3 - x2; @@ -369,12 +369,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'S': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]); y1 = fz_atof(args[i+1]); x2 = fz_atof(args[i+2]); y2 = fz_atof(args[i+3]); - fz_curveto(doc->ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); + fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); i += 4; reset_smooth = 0; smooth_x = x2 - x1; @@ -383,12 +383,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 's': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; - fz_curveto(doc->ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); + fz_curveto(ctx, path, pt.x + smooth_x, pt.y + smooth_y, x1, y1, x2, y2); i += 4; reset_smooth = 0; smooth_x = x2 - x1; @@ -397,12 +397,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'Q': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]); y1 = fz_atof(args[i+1]); x2 = fz_atof(args[i+2]); y2 = fz_atof(args[i+3]); - fz_curveto(doc->ctx, path, + fz_curveto(ctx, path, (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, x2, y2); @@ -410,12 +410,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) break; case 'q': if (i + 3 >= n) break; - pt = fz_currentpoint(doc->ctx, path); + pt = fz_currentpoint(ctx, path); x1 = fz_atof(args[i+0]) + pt.x; y1 = fz_atof(args[i+1]) + pt.y; x2 = fz_atof(args[i+2]) + pt.x; y2 = fz_atof(args[i+3]) + pt.y; - fz_curveto(doc->ctx, path, + fz_curveto(ctx, path, (pt.x + 2 * x1) / 3, (pt.y + 2 * y1) / 3, (x2 + 2 * x1) / 3, (y2 + 2 * y1) / 3, x2, y2); @@ -424,7 +424,7 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'A': if (i + 6 >= n) break; - xps_draw_arc(doc->ctx, path, + xps_draw_arc(ctx, doc, path, fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), atoi(args[i+3]), atoi(args[i+4]), fz_atof(args[i+5]), fz_atof(args[i+6])); @@ -432,8 +432,8 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) break; case 'a': if (i + 6 >= n) break; - pt = fz_currentpoint(doc->ctx, path); - xps_draw_arc(doc->ctx, path, + pt = fz_currentpoint(ctx, path); + xps_draw_arc(ctx, doc, path, fz_atof(args[i+0]), fz_atof(args[i+1]), fz_atof(args[i+2]), atoi(args[i+3]), atoi(args[i+4]), fz_atof(args[i+5]) + pt.x, fz_atof(args[i+6]) + pt.y); @@ -442,12 +442,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) case 'Z': case 'z': - fz_closepath(doc->ctx, path); + fz_closepath(ctx, path); break; default: /* eek */ - fz_warn(doc->ctx, "ignoring invalid command '%c'", cmd); + fz_warn(ctx, "ignoring invalid command '%c'", cmd); /* Skip any trailing numbers to avoid an infinite loop */ while (i < n && (args[i][0] == '+' || args[i][0] == '.' || args[i][0] == '-' || (args[i][0] >= '0' && args[i][0] <= '9'))) i ++; @@ -457,12 +457,12 @@ xps_parse_abbreviated_geometry(xps_document *doc, char *geom, int *fill_rule) old = cmd; } - fz_free(doc->ctx, args); + fz_free(ctx, args); return path; } static void -xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_arc_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { /* ArcSegment pretty much follows the SVG algorithm for converting an * arc in endpoint representation to an arc in centerpoint @@ -484,7 +484,7 @@ xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking if (!point_att || !size_att || !rotation_angle_att || !is_large_arc_att || !sweep_direction_att) { - fz_warn(doc, "ArcSegment element is missing attributes"); + fz_warn(ctx, "ArcSegment element is missing attributes"); return; } @@ -497,23 +497,23 @@ xps_parse_arc_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking point_x = point_y = 0; size_x = size_y = 0; - xps_parse_point(point_att, &point_x, &point_y); - xps_parse_point(size_att, &size_x, &size_y); + xps_parse_point(ctx, doc, point_att, &point_x, &point_y); + xps_parse_point(ctx, doc, size_att, &size_x, &size_y); rotation_angle = fz_atof(rotation_angle_att); is_large_arc = !strcmp(is_large_arc_att, "true"); is_clockwise = !strcmp(sweep_direction_att, "Clockwise"); if (stroking && !is_stroked) { - fz_moveto(doc, path, point_x, point_y); + fz_moveto(ctx, path, point_x, point_y); return; } - xps_draw_arc(doc, path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y); + xps_draw_arc(ctx, doc, path, size_x, size_y, rotation_angle, is_large_arc, is_clockwise, point_x, point_y); } static void -xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_quadratic_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -525,7 +525,7 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * if (!points_att) { - fz_warn(doc, "PolyQuadraticBezierSegment element has no points"); + fz_warn(ctx, "PolyQuadraticBezierSegment element has no points"); return; } @@ -540,18 +540,18 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x[n], &y[n]); + s = xps_parse_point(ctx, doc, s, &x[n], &y[n]); n ++; if (n == 2) { if (stroking && !is_stroked) { - fz_moveto(doc, path, x[1], y[1]); + fz_moveto(ctx, path, x[1], y[1]); } else { - pt = fz_currentpoint(doc, path); - fz_curveto(doc, path, + pt = fz_currentpoint(ctx, path); + fz_curveto(ctx, path, (pt.x + 2 * x[0]) / 3, (pt.y + 2 * y[0]) / 3, (x[1] + 2 * x[0]) / 3, (y[1] + 2 * y[0]) / 3, x[1], y[1]); @@ -562,7 +562,7 @@ xps_parse_poly_quadratic_bezier_segment(fz_context *doc, fz_path *path, fz_xml * } static void -xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_bezier_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -573,7 +573,7 @@ xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int if (!points_att) { - fz_warn(doc, "PolyBezierSegment element has no points"); + fz_warn(ctx, "PolyBezierSegment element has no points"); return; } @@ -588,21 +588,21 @@ xps_parse_poly_bezier_segment(fz_context *doc, fz_path *path, fz_xml *root, int while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x[n], &y[n]); + s = xps_parse_point(ctx, doc, s, &x[n], &y[n]); n ++; if (n == 3) { if (stroking && !is_stroked) - fz_moveto(doc, path, x[2], y[2]); + fz_moveto(ctx, path, x[2], y[2]); else - fz_curveto(doc, path, x[0], y[0], x[1], y[1], x[2], y[2]); + fz_curveto(ctx, path, x[0], y[0], x[1], y[1], x[2], y[2]); n = 0; } } } static void -xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) +xps_parse_poly_line_segment(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking, int *skipped_stroke) { char *points_att = fz_xml_att(root, "Points"); char *is_stroked_att = fz_xml_att(root, "IsStroked"); @@ -612,7 +612,7 @@ xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int st if (!points_att) { - fz_warn(doc, "PolyLineSegment element has no points"); + fz_warn(ctx, "PolyLineSegment element has no points"); return; } @@ -626,16 +626,16 @@ xps_parse_poly_line_segment(fz_context *doc, fz_path *path, fz_xml *root, int st while (*s != 0) { while (*s == ' ') s++; - s = xps_parse_point(s, &x, &y); + s = xps_parse_point(ctx, doc, s, &x, &y); if (stroking && !is_stroked) - fz_moveto(doc, path, x, y); + fz_moveto(ctx, path, x, y); else - fz_lineto(doc, path, x, y); + fz_lineto(ctx, path, x, y); } } static void -xps_parse_path_figure(fz_context *doc, fz_path *path, fz_xml *root, int stroking) +xps_parse_path_figure(fz_context *ctx, xps_document *doc, fz_path *path, fz_xml *root, int stroking) { fz_xml *node; @@ -659,36 +659,36 @@ xps_parse_path_figure(fz_context *doc, fz_path *path, fz_xml *root, int stroking if (is_filled_att) is_filled = !strcmp(is_filled_att, "true"); if (start_point_att) - xps_parse_point(start_point_att, &start_x, &start_y); + xps_parse_point(ctx, doc, start_point_att, &start_x, &start_y); if (!stroking && !is_filled) /* not filled, when filling */ return; - fz_moveto(doc, path, start_x, start_y); + fz_moveto(ctx, path, start_x, start_y); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "ArcSegment")) - xps_parse_arc_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_arc_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyBezierSegment")) - xps_parse_poly_bezier_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyLineSegment")) - xps_parse_poly_line_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_line_segment(ctx, doc, path, node, stroking, &skipped_stroke); if (fz_xml_is_tag(node, "PolyQuadraticBezierSegment")) - xps_parse_poly_quadratic_bezier_segment(doc, path, node, stroking, &skipped_stroke); + xps_parse_poly_quadratic_bezier_segment(ctx, doc, path, node, stroking, &skipped_stroke); } if (is_closed) { if (stroking && skipped_stroke) - fz_lineto(doc, path, start_x, start_y); /* we've skipped using fz_moveto... */ + fz_lineto(ctx, path, start_x, start_y); /* we've skipped using fz_moveto... */ else - fz_closepath(doc, path); /* no skipped segments, safe to closepath properly */ + fz_closepath(ctx, path); /* no skipped segments, safe to closepath properly */ } } fz_path * -xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule) +xps_parse_path_geometry(fz_context *ctx, xps_document *doc, xps_resource *dict, fz_xml *root, int stroking, int *fill_rule) { fz_xml *node; @@ -712,8 +712,8 @@ xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int transform_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &figures_att, &figures_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &figures_att, &figures_tag, NULL); if (fill_rule_att) { @@ -725,26 +725,26 @@ xps_parse_path_geometry(xps_document *doc, xps_resource *dict, fz_xml *root, int transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); if (figures_att) - path = xps_parse_abbreviated_geometry(doc, figures_att, fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, figures_att, fill_rule); else - path = fz_new_path(doc->ctx); + path = fz_new_path(ctx); if (figures_tag) - xps_parse_path_figure(doc->ctx, path, figures_tag, stroking); + xps_parse_path_figure(ctx, doc, path, figures_tag, stroking); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "PathFigure")) - xps_parse_path_figure(doc->ctx, path, node, stroking); + xps_parse_path_figure(ctx, doc, path, node, stroking); } if (transform_att || transform_tag) - fz_transform_path(doc->ctx, path, &transform); + fz_transform_path(ctx, path, &transform); return path; } @@ -763,19 +763,20 @@ xps_parse_line_cap(char *attr) } void -xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag) +xps_clip(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip_att, fz_xml *clip_tag) { + fz_device *dev = doc->dev; fz_path *path; int fill_rule = 0; if (clip_att) - path = xps_parse_abbreviated_geometry(doc, clip_att, &fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, clip_att, &fill_rule); else if (clip_tag) - path = xps_parse_path_geometry(doc, dict, clip_tag, 0, &fill_rule); + path = xps_parse_path_geometry(ctx, doc, dict, clip_tag, 0, &fill_rule); else - path = fz_new_path(doc->ctx); - fz_clip_path(doc->dev, path, NULL, fill_rule == 0, ctm); - fz_drop_path(doc->ctx, path); + path = fz_new_path(ctx); + fz_clip_path(ctx, dev, path, NULL, fill_rule == 0, ctm); + fz_drop_path(ctx, path); } /* @@ -784,8 +785,10 @@ xps_clip(xps_document *doc, const fz_matrix *ctm, xps_resource *dict, char *clip */ void -xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) +xps_parse_path(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; + fz_xml *node; char *fill_uri; @@ -873,12 +876,12 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso stroke_uri = base_uri; opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &data_att, &data_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &fill_att, &fill_tag, &fill_uri); - xps_resolve_resource_reference(doc, dict, &stroke_att, &stroke_tag, &stroke_uri); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &data_att, &data_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &fill_att, &fill_tag, &fill_uri); + xps_resolve_resource_reference(ctx, doc, dict, &stroke_att, &stroke_tag, &stroke_uri); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); /* * Act on the information we have gathered: @@ -918,7 +921,7 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso s++; } } - stroke = fz_new_stroke_state_with_dash_len(doc->ctx, dash_len); + stroke = fz_new_stroke_state_with_dash_len(ctx, dash_len); stroke->start_cap = xps_parse_line_cap(stroke_start_line_cap_att); stroke->dash_cap = xps_parse_line_cap(stroke_dash_cap_att); stroke->end_cap = xps_parse_line_cap(stroke_end_line_cap_att); @@ -973,87 +976,87 @@ xps_parse_path(xps_document *doc, const fz_matrix *ctm, char *base_uri, xps_reso transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&local_ctm, &transform, ctm); if (clip_att || clip_tag) - xps_clip(doc, &local_ctm, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &local_ctm, dict, clip_att, clip_tag); fill_rule = 0; if (data_att) - path = xps_parse_abbreviated_geometry(doc, data_att, &fill_rule); + path = xps_parse_abbreviated_geometry(ctx, doc, data_att, &fill_rule); else if (data_tag) { - path = xps_parse_path_geometry(doc, dict, data_tag, 0, &fill_rule); + path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 0, &fill_rule); if (stroke_att || stroke_tag) - stroke_path = xps_parse_path_geometry(doc, dict, data_tag, 1, &fill_rule); + stroke_path = xps_parse_path_geometry(ctx, doc, dict, data_tag, 1, &fill_rule); } if (!stroke_path) stroke_path = path; if (stroke_att || stroke_tag) { - fz_bound_path(doc->ctx, stroke_path, stroke, &local_ctm, &area); + fz_bound_path(ctx, stroke_path, stroke, &local_ctm, &area); if (stroke_path != path && (fill_att || fill_tag)) { fz_rect bounds; - fz_bound_path(doc->ctx, path, NULL, &local_ctm, &bounds); + fz_bound_path(ctx, path, NULL, &local_ctm, &bounds); fz_union_rect(&area, &bounds); } } else - fz_bound_path(doc->ctx, path, NULL, &local_ctm, &area); + fz_bound_path(ctx, path, NULL, &local_ctm, &area); if (navigate_uri_att) - xps_add_link(doc, &area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, &area, base_uri, navigate_uri_att); - xps_begin_opacity(doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &local_ctm, &area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (fill_att) { - xps_parse_color(doc, base_uri, fill_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, fill_att, &colorspace, samples); if (fill_opacity_att) samples[0] *= fz_atof(fill_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_fill_path(doc->dev, path, fill_rule == 0, &local_ctm, + fz_fill_path(ctx, dev, path, fill_rule == 0, &local_ctm, doc->colorspace, doc->color, doc->alpha); } if (fill_tag) { - fz_clip_path(doc->dev, path, &area, fill_rule == 0, &local_ctm); - xps_parse_brush(doc, &local_ctm, &area, fill_uri, dict, fill_tag); - fz_pop_clip(doc->dev); + fz_clip_path(ctx, dev, path, &area, fill_rule == 0, &local_ctm); + xps_parse_brush(ctx, doc, &local_ctm, &area, fill_uri, dict, fill_tag); + fz_pop_clip(ctx, dev); } if (stroke_att) { - xps_parse_color(doc, base_uri, stroke_att, &colorspace, samples); + xps_parse_color(ctx, doc, base_uri, stroke_att, &colorspace, samples); if (stroke_opacity_att) samples[0] *= fz_atof(stroke_opacity_att); - xps_set_color(doc, colorspace, samples); + xps_set_color(ctx, doc, colorspace, samples); - fz_stroke_path(doc->dev, stroke_path, stroke, &local_ctm, + fz_stroke_path(ctx, dev, stroke_path, stroke, &local_ctm, doc->colorspace, doc->color, doc->alpha); } if (stroke_tag) { - fz_clip_stroke_path(doc->dev, stroke_path, &area, stroke, &local_ctm); - xps_parse_brush(doc, &local_ctm, &area, stroke_uri, dict, stroke_tag); - fz_pop_clip(doc->dev); + fz_clip_stroke_path(ctx, dev, stroke_path, &area, stroke, &local_ctm); + xps_parse_brush(ctx, doc, &local_ctm, &area, stroke_uri, dict, stroke_tag); + fz_pop_clip(ctx, dev); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (stroke_path != path) - fz_drop_path(doc->ctx, stroke_path); - fz_drop_path(doc->ctx, path); + fz_drop_path(ctx, stroke_path); + fz_drop_path(ctx, path); path = NULL; - fz_drop_stroke_state(doc->ctx, stroke); + fz_drop_stroke_state(ctx, stroke); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); } diff --git a/source/xps/xps-resource.c b/source/xps/xps-resource.c index 6600f7c6..712ed1cc 100644 --- a/source/xps/xps-resource.c +++ b/source/xps/xps-resource.c @@ -1,7 +1,7 @@ #include "mupdf/xps.h" static fz_xml * -xps_lookup_resource(xps_document *doc, xps_resource *dict, char *name, char **urip) +xps_lookup_resource(fz_context *ctx, xps_document *doc, xps_resource *dict, char *name, char **urip) { xps_resource *head, *node; for (head = dict; head; head = head->parent) @@ -20,7 +20,7 @@ xps_lookup_resource(xps_document *doc, xps_resource *dict, char *name, char **ur } static fz_xml * -xps_parse_resource_reference(xps_document *doc, xps_resource *dict, char *att, char **urip) +xps_parse_resource_reference(fz_context *ctx, xps_document *doc, xps_resource *dict, char *att, char **urip) { char name[1024]; char *s; @@ -33,16 +33,16 @@ xps_parse_resource_reference(xps_document *doc, xps_resource *dict, char *att, c if (s) *s = 0; - return xps_lookup_resource(doc, dict, name, urip); + return xps_lookup_resource(ctx, doc, dict, name, urip); } void -xps_resolve_resource_reference(xps_document *doc, xps_resource *dict, +xps_resolve_resource_reference(fz_context *ctx, xps_document *doc, xps_resource *dict, char **attp, fz_xml **tagp, char **urip) { if (*attp) { - fz_xml *rsrc = xps_parse_resource_reference(doc, dict, *attp, urip); + fz_xml *rsrc = xps_parse_resource_reference(ctx, doc, dict, *attp, urip); if (rsrc) { *attp = NULL; @@ -52,7 +52,7 @@ xps_resolve_resource_reference(xps_document *doc, xps_resource *dict, } static xps_resource * -xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *source_att) +xps_parse_remote_resource_dictionary(fz_context *ctx, xps_document *doc, char *base_uri, char *source_att) { char part_name[1024]; char part_uri[1024]; @@ -60,18 +60,17 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so xps_part *part; fz_xml *xml; char *s; - fz_context *ctx = doc->ctx; /* External resource dictionaries MUST NOT reference other resource dictionaries */ - xps_resolve_url(part_name, base_uri, source_att, sizeof part_name); - part = xps_read_part(doc, part_name); + xps_resolve_url(ctx, doc, part_name, base_uri, source_att, sizeof part_name); + part = xps_read_part(ctx, doc, part_name); fz_try(ctx) { - xml = fz_parse_xml(doc->ctx, part->data, part->size, 0); + xml = fz_parse_xml(ctx, part->data, part->size, 0); } fz_always(ctx) { - xps_drop_part(doc, part); + xps_drop_part(ctx, doc, part); } fz_catch(ctx) { @@ -84,8 +83,8 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so if (strcmp(fz_xml_tag(xml), "ResourceDictionary")) { - fz_drop_xml(doc->ctx, xml); - fz_throw(doc->ctx, FZ_ERROR_GENERIC, "expected ResourceDictionary element"); + fz_drop_xml(ctx, xml); + fz_throw(ctx, FZ_ERROR_GENERIC, "expected ResourceDictionary element"); } fz_strlcpy(part_uri, part_name, sizeof part_uri); @@ -93,7 +92,7 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so if (s) s[1] = 0; - dict = xps_parse_resource_dictionary(doc, part_uri, xml); + dict = xps_parse_resource_dictionary(ctx, doc, part_uri, xml); if (dict) dict->base_xml = xml; /* pass on ownership */ @@ -101,7 +100,7 @@ xps_parse_remote_resource_dictionary(xps_document *doc, char *base_uri, char *so } xps_resource * -xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) +xps_parse_resource_dictionary(fz_context *ctx, xps_document *doc, char *base_uri, fz_xml *root) { xps_resource *head; xps_resource *entry; @@ -111,7 +110,7 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) source = fz_xml_att(root, "Source"); if (source) - return xps_parse_remote_resource_dictionary(doc, base_uri, source); + return xps_parse_remote_resource_dictionary(ctx, doc, base_uri, source); head = NULL; @@ -120,7 +119,7 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) key = fz_xml_att(node, "x:Key"); if (key) { - entry = fz_malloc_struct(doc->ctx, xps_resource); + entry = fz_malloc_struct(ctx, xps_resource); entry->name = key; entry->base_uri = NULL; entry->base_xml = NULL; @@ -132,29 +131,29 @@ xps_parse_resource_dictionary(xps_document *doc, char *base_uri, fz_xml *root) } if (head) - head->base_uri = fz_strdup(doc->ctx, base_uri); + head->base_uri = fz_strdup(ctx, base_uri); return head; } void -xps_drop_resource_dictionary(xps_document *doc, xps_resource *dict) +xps_drop_resource_dictionary(fz_context *ctx, xps_document *doc, xps_resource *dict) { xps_resource *next; while (dict) { next = dict->next; if (dict->base_xml) - fz_drop_xml(doc->ctx, dict->base_xml); + fz_drop_xml(ctx, dict->base_xml); if (dict->base_uri) - fz_free(doc->ctx, dict->base_uri); - fz_free(doc->ctx, dict); + fz_free(ctx, dict->base_uri); + fz_free(ctx, dict); dict = next; } } void -xps_print_resource_dictionary(xps_resource *dict) +xps_print_resource_dictionary(fz_context *ctx, xps_document *doc, xps_resource *dict) { while (dict) { @@ -164,7 +163,7 @@ xps_print_resource_dictionary(xps_resource *dict) if (dict->parent) { printf("PARENT = {\n"); - xps_print_resource_dictionary(dict->parent); + xps_print_resource_dictionary(ctx, doc, dict->parent); printf("}\n"); } dict = dict->next; diff --git a/source/xps/xps-tile.c b/source/xps/xps-tile.c index b7e0ec19..a74ef562 100644 --- a/source/xps/xps-tile.c +++ b/source/xps/xps-tile.c @@ -15,58 +15,61 @@ struct closure xps_resource *dict; fz_xml *root; void *user; - void (*func)(xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*); + void (*func)(fz_context *ctx, xps_document*, const fz_matrix *, const fz_rect *, char*, xps_resource*, fz_xml*, void*); }; static void -xps_paint_tiling_brush_clipped(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c) +xps_paint_tiling_brush_clipped(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, struct closure *c) { - fz_path *path = fz_new_path(doc->ctx); - fz_moveto(doc->ctx, path, viewbox->x0, viewbox->y0); - fz_lineto(doc->ctx, path, viewbox->x0, viewbox->y1); - fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y1); - fz_lineto(doc->ctx, path, viewbox->x1, viewbox->y0); - fz_closepath(doc->ctx, path); - fz_clip_path(doc->dev, path, NULL, 0, ctm); - fz_drop_path(doc->ctx, path); - c->func(doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user); - fz_pop_clip(doc->dev); + fz_device *dev = doc->dev; + + fz_path *path = fz_new_path(ctx); + fz_moveto(ctx, path, viewbox->x0, viewbox->y0); + fz_lineto(ctx, path, viewbox->x0, viewbox->y1); + fz_lineto(ctx, path, viewbox->x1, viewbox->y1); + fz_lineto(ctx, path, viewbox->x1, viewbox->y0); + fz_closepath(ctx, path); + fz_clip_path(ctx, dev, path, NULL, 0, ctm); + fz_drop_path(ctx, path); + c->func(ctx, doc, ctm, viewbox, c->base_uri, c->dict, c->root, c->user); + fz_pop_clip(ctx, dev); } static void -xps_paint_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c) +xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c) { fz_matrix ttm; - xps_paint_tiling_brush_clipped(doc, ctm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, ctm, viewbox, c); if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, 0), -1, 1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, 0, viewbox->y1 * 2), 1, -1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } if (tile_mode == TILE_FLIP_X_Y) { ttm = *ctm; fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, viewbox->y1 * 2), -1, -1); - xps_paint_tiling_brush_clipped(doc, &ttm, viewbox, c); + xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c); } } void -xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, - void (*func)(xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user) + void (*func)(fz_context *ctx, xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user) { + fz_device *dev = doc->dev; fz_xml *node; struct closure c; @@ -105,27 +108,27 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a transform_tag = fz_xml_down(node); } - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); viewbox = fz_unit_rect; if (viewbox_att) - xps_parse_rectangle(doc, viewbox_att, &viewbox); + xps_parse_rectangle(ctx, doc, viewbox_att, &viewbox); viewport = fz_unit_rect; if (viewport_att) - xps_parse_rectangle(doc, viewport_att, &viewport); + xps_parse_rectangle(ctx, doc, viewport_att, &viewport); if (fabsf(viewport.x1 - viewport.x0) < 0.01f || fabsf(viewport.y1 - viewport.y0) < 0.01f) - fz_warn(doc->ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0); + fz_warn(ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0); else if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f || fabsf(viewbox.y1 - viewbox.y0) < 0.01f) - fz_warn(doc->ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0); + fz_warn(ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0); /* some sanity checks on the viewport/viewbox size */ if (fabsf(viewport.x1 - viewport.x0) < 0.01f) return; @@ -159,7 +162,7 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y) ystep *= 2; - xps_begin_opacity(doc, &transform, area, base_uri, dict, opacity_att, NULL); + xps_begin_opacity(ctx, doc, &transform, area, base_uri, dict, opacity_att, NULL); fz_pre_translate(&transform, viewport.x0, viewport.y0); fz_pre_scale(&transform, xscale, yscale); @@ -185,9 +188,9 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a fz_rect bigview = viewbox; bigview.x1 = bigview.x0 + xstep; bigview.y1 = bigview.y0 + ystep; - fz_begin_tile(doc->dev, &local_area, &bigview, xstep, ystep, &transform); - xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c); - fz_end_tile(doc->dev); + fz_begin_tile(ctx, dev, &local_area, &bigview, xstep, ystep, &transform); + xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c); + fz_end_tile(ctx, dev); } else { @@ -198,28 +201,28 @@ xps_parse_tiling_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a { fz_matrix ttm = transform; fz_pre_translate(&ttm, xstep * x, ystep * y); - xps_paint_tiling_brush(doc, &ttm, &viewbox, tile_mode, &c); + xps_paint_tiling_brush(ctx, doc, &ttm, &viewbox, tile_mode, &c); } } } } else { - xps_paint_tiling_brush(doc, &transform, &viewbox, tile_mode, &c); + xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c); } - xps_end_opacity(doc, base_uri, dict, opacity_att, NULL); + xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL); } static void -xps_paint_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_paint_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root, void *visual_tag) { - xps_parse_element(doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag); + xps_parse_element(ctx, doc, ctm, area, base_uri, dict, (fz_xml *)visual_tag); } void -xps_parse_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, +xps_parse_visual_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { fz_xml *node; @@ -237,18 +240,19 @@ xps_parse_visual_brush(xps_document *doc, const fz_matrix *ctm, const fz_rect *a } visual_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &visual_att, &visual_tag, &visual_uri); + xps_resolve_resource_reference(ctx, doc, dict, &visual_att, &visual_tag, &visual_uri); if (visual_tag) { - xps_parse_tiling_brush(doc, ctm, area, + xps_parse_tiling_brush(ctx, doc, ctm, area, visual_uri, dict, root, xps_paint_visual_brush, visual_tag); } } void -xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) +xps_parse_canvas(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area, char *base_uri, xps_resource *dict, fz_xml *root) { + fz_device *dev = doc->dev; xps_resource *new_dict = NULL; fz_xml *node; char *opacity_mask_uri; @@ -277,11 +281,11 @@ xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, c { if (new_dict) { - fz_warn(doc->ctx, "ignoring follow-up resource dictionaries"); + fz_warn(ctx, "ignoring follow-up resource dictionaries"); } else { - new_dict = xps_parse_resource_dictionary(doc, base_uri, fz_xml_down(node)); + new_dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node)); if (new_dict) { new_dict->parent = dict; @@ -299,41 +303,41 @@ xps_parse_canvas(xps_document *doc, const fz_matrix *ctm, const fz_rect *area, c } opacity_mask_uri = base_uri; - xps_resolve_resource_reference(doc, dict, &transform_att, &transform_tag, NULL); - xps_resolve_resource_reference(doc, dict, &clip_att, &clip_tag, NULL); - xps_resolve_resource_reference(doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); + xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &clip_att, &clip_tag, NULL); + xps_resolve_resource_reference(ctx, doc, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri); transform = fz_identity; if (transform_att) - xps_parse_render_transform(doc, transform_att, &transform); + xps_parse_render_transform(ctx, doc, transform_att, &transform); if (transform_tag) - xps_parse_matrix_transform(doc, transform_tag, &transform); + xps_parse_matrix_transform(ctx, doc, transform_tag, &transform); fz_concat(&transform, &transform, ctm); if (navigate_uri_att) - xps_add_link(doc, area, base_uri, navigate_uri_att); + xps_add_link(ctx, doc, area, base_uri, navigate_uri_att); if (clip_att || clip_tag) - xps_clip(doc, &transform, dict, clip_att, clip_tag); + xps_clip(ctx, doc, &transform, dict, clip_att, clip_tag); - xps_begin_opacity(doc, &transform, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_begin_opacity(ctx, doc, &transform, area, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); for (node = fz_xml_down(root); node; node = fz_xml_next(node)) { - xps_parse_element(doc, &transform, area, base_uri, dict, node); + xps_parse_element(ctx, doc, &transform, area, base_uri, dict, node); } - xps_end_opacity(doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); + xps_end_opacity(ctx, doc, opacity_mask_uri, dict, opacity_att, opacity_mask_tag); if (clip_att || clip_tag) - fz_pop_clip(doc->dev); + fz_pop_clip(ctx, dev); if (new_dict) - xps_drop_resource_dictionary(doc, new_dict); + xps_drop_resource_dictionary(ctx, doc, new_dict); } void -xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) +xps_parse_fixed_page(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, xps_page *page) { fz_xml *node; xps_resource *dict; @@ -342,7 +346,7 @@ xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) char *s; fz_matrix scm; - fz_strlcpy(base_uri, page->name, sizeof base_uri); + fz_strlcpy(base_uri, page->fix->name, sizeof base_uri); s = strrchr(base_uri, '/'); if (s) s[1] = 0; @@ -356,35 +360,36 @@ xps_parse_fixed_page(xps_document *doc, const fz_matrix *ctm, xps_page *page) return; area = fz_unit_rect; - fz_transform_rect(&area, fz_scale(&scm, page->width, page->height)); + fz_transform_rect(&area, fz_scale(&scm, page->fix->width, page->fix->height)); for (node = fz_xml_down(page->root); node; node = fz_xml_next(node)) { if (fz_xml_is_tag(node, "FixedPage.Resources") && fz_xml_down(node)) { if (dict) - fz_warn(doc->ctx, "ignoring follow-up resource dictionaries"); + fz_warn(ctx, "ignoring follow-up resource dictionaries"); else - dict = xps_parse_resource_dictionary(doc, base_uri, fz_xml_down(node)); + dict = xps_parse_resource_dictionary(ctx, doc, base_uri, fz_xml_down(node)); } - xps_parse_element(doc, ctm, &area, base_uri, dict, node); + xps_parse_element(ctx, doc, ctm, &area, base_uri, dict, node); } if (dict) - xps_drop_resource_dictionary(doc, dict); + xps_drop_resource_dictionary(ctx, doc, dict); } void -xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) +xps_run_page(fz_context *ctx, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie) { + xps_document *doc = page->doc; fz_matrix page_ctm = *ctm; fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f); doc->cookie = cookie; doc->dev = dev; - xps_parse_fixed_page(doc, &page_ctm, page); + xps_parse_fixed_page(ctx, doc, &page_ctm, page); doc->cookie = NULL; doc->dev = NULL; - page->links_resolved = 1; + page->fix->links_resolved = 1; } diff --git a/source/xps/xps-util.c b/source/xps/xps-util.c index a74dc30f..5d708eaa 100644 --- a/source/xps/xps-util.c +++ b/source/xps/xps-util.c @@ -81,7 +81,7 @@ skip_authority(char *path) #define SEP(x) ((x)=='/' || (x) == 0) static char * -xps_clean_path(char *name) +clean_path(char *name) { char *p, *q, *dotdot, *start; int rooted; @@ -138,7 +138,7 @@ xps_clean_path(char *name) } void -xps_resolve_url(char *output, char *base_uri, char *path, int output_size) +xps_resolve_url(fz_context *ctx, xps_document *doc, char *output, char *base_uri, char *path, int output_size) { char *p = skip_authority(skip_scheme(path)); @@ -153,13 +153,11 @@ xps_resolve_url(char *output, char *base_uri, char *path, int output_size) fz_strlcat(output, "/", output_size); fz_strlcat(output, path, output_size); } - xps_clean_path(output); + clean_path(output); } int -xps_url_is_remote(char *path) +xps_url_is_remote(fz_context *ctx, xps_document *doc, char *path) { - char *p = skip_authority(skip_scheme(path)); - - return p != path; + return path != skip_authority(skip_scheme(path)); } diff --git a/source/xps/xps-zip.c b/source/xps/xps-zip.c index a8f25114..ab8c60d7 100644 --- a/source/xps/xps-zip.c +++ b/source/xps/xps-zip.c @@ -1,45 +1,44 @@ #include "mupdf/xps.h" -static void xps_init_document(xps_document *doc); +static void xps_init_document(fz_context *ctx, xps_document *doc); xps_part * -xps_new_part(xps_document *doc, char *name, unsigned char *data, int size) +xps_new_part(fz_context *ctx, xps_document *doc, char *name, unsigned char *data, int size) { xps_part *part; - part = fz_malloc_struct(doc->ctx, xps_part); - fz_try(doc->ctx) + part = fz_malloc_struct(ctx, xps_part); + fz_try(ctx) { - part->name = fz_strdup(doc->ctx, name); + part->name = fz_strdup(ctx, name); part->data = data; part->size = size; } - fz_catch(doc->ctx) + fz_catch(ctx) { - fz_free(doc->ctx, part->name); - fz_free(doc->ctx, part->data); - fz_free(doc->ctx, part); - fz_rethrow(doc->ctx); + fz_free(ctx, part->name); + fz_free(ctx, part->data); + fz_free(ctx, part); + fz_rethrow(ctx); } return part; } void -xps_drop_part(xps_document *doc, xps_part *part) +xps_drop_part(fz_context *ctx, xps_document *doc, xps_part *part) { - fz_free(doc->ctx, part->name); - fz_free(doc->ctx, part->data); - fz_free(doc->ctx, part); + fz_free(ctx, part->name); + fz_free(ctx, part->data); + fz_free(ctx, part); } /* * Read and interleave split parts from a ZIP file. */ xps_part * -xps_read_part(xps_document *doc, char *partname) +xps_read_part(fz_context *ctx, xps_document *doc, char *partname) { - fz_context *ctx = doc->ctx; fz_archive *zip = doc->zip; fz_buffer *buf, *tmp; char path[2048]; @@ -100,22 +99,22 @@ xps_read_part(xps_document *doc, char *partname) size = buf->len - 1; fz_free(ctx, buf); - return xps_new_part(doc, partname, data, size); + return xps_new_part(ctx, doc, partname, data, size); } int -xps_has_part(xps_document *doc, char *name) +xps_has_part(fz_context *ctx, xps_document *doc, char *name) { char buf[2048]; if (name[0] == '/') name++; - if (fz_has_archive_entry(doc->ctx, doc->zip, name)) + if (fz_has_archive_entry(ctx, doc->zip, name)) return 1; sprintf(buf, "%s/[0].piece", name); - if (fz_has_archive_entry(doc->ctx, doc->zip, buf)) + if (fz_has_archive_entry(ctx, doc->zip, buf)) return 1; sprintf(buf, "%s/[0].last.piece", name); - if (fz_has_archive_entry(doc->ctx, doc->zip, buf)) + if (fz_has_archive_entry(ctx, doc->zip, buf)) return 1; return 0; } @@ -126,17 +125,16 @@ xps_open_document_with_directory(fz_context *ctx, const char *directory) xps_document *doc; doc = fz_malloc_struct(ctx, xps_document); - xps_init_document(doc); - doc->ctx = ctx; + xps_init_document(ctx, doc); doc->zip = fz_open_directory(ctx, directory); fz_try(ctx) { - xps_read_page_list(doc); + xps_read_page_list(ctx, doc); } fz_catch(ctx) { - xps_close_document(doc); + xps_close_document(ctx, doc); fz_rethrow(ctx); } @@ -149,17 +147,16 @@ xps_open_document_with_stream(fz_context *ctx, fz_stream *file) xps_document *doc; doc = fz_malloc_struct(ctx, xps_document); - xps_init_document(doc); - doc->ctx = ctx; + xps_init_document(ctx, doc); fz_try(ctx) { doc->zip = fz_open_archive_with_stream(ctx, file); - xps_read_page_list(doc); + xps_read_page_list(ctx, doc); } fz_catch(ctx) { - xps_close_document(doc); + xps_close_document(ctx, doc); fz_rethrow(ctx); } @@ -194,7 +191,7 @@ xps_open_document(fz_context *ctx, const char *filename) } fz_always(ctx) { - fz_drop_stream(file); + fz_drop_stream(ctx, file); } fz_catch(ctx) { @@ -204,7 +201,7 @@ xps_open_document(fz_context *ctx, const char *filename) } void -xps_close_document(xps_document *doc) +xps_close_document(fz_context *ctx, xps_document *doc) { xps_font_cache *font, *next; @@ -212,26 +209,26 @@ xps_close_document(xps_document *doc) return; if (doc->zip) - fz_drop_archive(doc->ctx, doc->zip); + fz_drop_archive(ctx, doc->zip); font = doc->font_table; while (font) { next = font->next; - fz_drop_font(doc->ctx, font->font); - fz_free(doc->ctx, font->name); - fz_free(doc->ctx, font); + fz_drop_font(ctx, font->font); + fz_free(ctx, font->name); + fz_free(ctx, font); font = next; } - xps_drop_page_list(doc); + xps_drop_page_list(ctx, doc); - fz_free(doc->ctx, doc->start_part); - fz_free(doc->ctx, doc); + fz_free(ctx, doc->start_part); + fz_free(ctx, doc); } static int -xps_meta(xps_document *doc, int key, void *ptr, int size) +xps_meta(fz_context *ctx, xps_document *doc, int key, void *ptr, int size) { switch (key) { @@ -244,25 +241,12 @@ xps_meta(xps_document *doc, int key, void *ptr, int size) } static void -xps_rebind(xps_document *doc, fz_context *ctx) -{ - doc->ctx = ctx; - fz_rebind_archive(doc->zip, ctx); - fz_rebind_device(doc->dev, ctx); -} - -static void -xps_init_document(xps_document *doc) +xps_init_document(fz_context *ctx, xps_document *doc) { doc->super.refs = 1; doc->super.close = (fz_document_close_fn *)xps_close_document; doc->super.load_outline = (fz_document_load_outline_fn *)xps_load_outline; doc->super.count_pages = (fz_document_count_pages_fn *)xps_count_pages; doc->super.load_page = (fz_document_load_page_fn *)xps_load_page; - doc->super.load_links = (fz_document_load_links_fn *)xps_load_links; - doc->super.bound_page = (fz_document_bound_page_fn *)xps_bound_page; - doc->super.run_page_contents = (fz_document_run_page_contents_fn *)xps_run_page; - doc->super.free_page = (fz_document_free_page_fn *)xps_drop_page; doc->super.meta = (fz_document_meta_fn *)xps_meta; - doc->super.rebind = (fz_document_rebind_fn *)xps_rebind; } |