summaryrefslogtreecommitdiff
path: root/Build/source/texk/web2c/luatexdir/image/writeimg.c
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/texk/web2c/luatexdir/image/writeimg.c')
-rw-r--r--Build/source/texk/web2c/luatexdir/image/writeimg.c959
1 files changed, 0 insertions, 959 deletions
diff --git a/Build/source/texk/web2c/luatexdir/image/writeimg.c b/Build/source/texk/web2c/luatexdir/image/writeimg.c
deleted file mode 100644
index f570fd46996..00000000000
--- a/Build/source/texk/web2c/luatexdir/image/writeimg.c
+++ /dev/null
@@ -1,959 +0,0 @@
-/* writeimg.c
-
- Copyright 1996-2006 Han The Thanh <thanh@pdftex.org>
- Copyright 2006-2009 Taco Hoekwater <taco@luatex.org>
-
- This file is part of LuaTeX.
-
- LuaTeX is free software; you can redistribute it and/or modify it under
- the terms of the GNU General Public License as published by the Free
- Software Foundation; either version 2 of the License, or (at your
- option) any later version.
-
- LuaTeX is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
- License for more details.
-
- You should have received a copy of the GNU General Public License along
- with LuaTeX; if not, see <http://www.gnu.org/licenses/>. */
-
-#include <assert.h>
-#include "ptexlib.h"
-#include <kpathsea/c-auto.h>
-#include <kpathsea/c-memstr.h>
-
-#include "image.h"
-#include "writejpg.h"
-#include "writepng.h"
-#include "writejbig2.h"
-#include "pdftoepdf.h"
-
-#include <../lua51/lua.h>
-#include <../lua51/lauxlib.h>
-
-static const char _svn_version[] =
- "$Id: writeimg.c 2448 2009-06-08 07:43:50Z taco $ "
- "$URL: http://foundry.supelec.fr/svn/luatex/tags/beta-0.40.6/source/texk/web2c/luatexdir/image/writeimg.c $";
-
-/**********************************************************************/
-/*
- Patch ImageTypeDetection 2003/02/08 by Heiko Oberdiek.
-
- Function "readimage" performs some basic initializations.
- Then it looks at the file extension to determine the
- image type and calls specific code/functions.
- The main disadvantage is that standard file extensions
- have to be used, otherwise pdfTeX is not able to detect
- the correct image type.
-
- The patch now looks at the file header first regardless of
- the file extension. This is implemented in function
- "check_type_by_header". If this check fails, the traditional
- test of standard file extension is tried, done in function
- "check_type_by_extension".
-
- Magic headers:
-
- * "PNG (Portable Network Graphics) Specification", Version 1.2
- (http://www.libpng.org/pub/png):
-
- | 3.1. PNG file signature
- |
- | The first eight bytes of a PNG file always contain the following
- | (decimal) values:
- |
- | 137 80 78 71 13 10 26 10
-
- Translation to C: "\x89PNG\r\n\x1A\n"
-
- * "JPEG File Interchange Format", Version 1.02:
-
- | o you can identify a JFIF file by looking for the following
- | sequence: X'FF', SOI X'FF', APP0, <2 bytes to be skipped>,
- | "JFIF", X'00'.
-
- Function "check_type_by_header" only looks at the first two bytes:
- "\xFF\xD8"
-
- * ISO/IEC JTC 1/SC 29/WG 1
- (ITU-T SG8)
- Coding of Still Pictures
- Title: 14492 FCD
- Source: JBIG Committee
- Project: JTC 1.29.10
- Status: Final Committee Draft
-
- | D.4.1, ID string
- |
- | This is an 8-byte sequence containing 0x97 0x4A 0x42 0x32 0x0D 0x0A
- | 0x1A 0x0A.
-
- * "PDF Reference", third edition:
- * The first line should contain "%PDF-1.0" until "%PDF-1.4"
- (section 3.4.1 "File Header").
- * The "implementation notes" say:
-
- | 3.4.1, File Header
- | 12. Acrobat viewers require only that the header appear
- | somewhere within the first 1024 bytes of the file.
- | 13. Acrobat viewers will also accept a header of the form
- | %!PS-Adobe-N.n PDF-M.m
-
- The check in function "check_type_by_header" only implements
- the first issue. The implementation notes are not considered.
- Therefore files with garbage at start of file must have the
- standard extension.
-
- Functions "check_type_by_header" and "check_type_by_extension":
- img_type(img) is set to IMG_TYPE_NONE by new_image_dict().
- Both functions try to detect a type and set img_type(img).
- Thus a value other than IMG_TYPE_NONE indicates that a
- type has been found.
-*/
-
-#define HEADER_JPG "\xFF\xD8"
-#define HEADER_PNG "\x89PNG\r\n\x1A\n"
-#define HEADER_JBIG2 "\x97\x4A\x42\x32\x0D\x0A\x1A\x0A"
-#define HEADER_PDF "%PDF-1."
-#define MAX_HEADER (sizeof(HEADER_PNG)-1)
-
-integer epdf_lastGroupObjectNum;
-
-static void check_type_by_header(image_dict * idict)
-{
- int i;
- FILE *file = NULL;
- char header[MAX_HEADER];
-
- assert(idict != NULL);
- if (img_type(idict) != IMG_TYPE_NONE) /* nothing to do */
- return;
- /* read the header */
- file = xfopen(img_filepath(idict), FOPEN_RBIN_MODE);
- for (i = 0; (unsigned) i < MAX_HEADER; i++) {
- header[i] = xgetc(file);
- if (feof(file))
- pdftex_fail("reading image file failed");
- }
- xfclose(file, img_filepath(idict));
- /* tests */
- if (strncmp(header, HEADER_JPG, sizeof(HEADER_JPG) - 1) == 0)
- img_type(idict) = IMG_TYPE_JPG;
- else if (strncmp(header, HEADER_PNG, sizeof(HEADER_PNG) - 1) == 0)
- img_type(idict) = IMG_TYPE_PNG;
- else if (strncmp(header, HEADER_JBIG2, sizeof(HEADER_JBIG2) - 1) == 0)
- img_type(idict) = IMG_TYPE_JBIG2;
- else if (strncmp(header, HEADER_PDF, sizeof(HEADER_PDF) - 1) == 0)
- img_type(idict) = IMG_TYPE_PDF;
-}
-
-static void check_type_by_extension(image_dict * idict)
-{
- char *image_suffix;
-
- assert(idict != NULL);
- if (img_type(idict) != IMG_TYPE_NONE) /* nothing to do */
- return;
- /* tests */
- if ((image_suffix = strrchr(img_filename(idict), '.')) == 0)
- img_type(idict) = IMG_TYPE_NONE;
- else if (strcasecmp(image_suffix, ".png") == 0)
- img_type(idict) = IMG_TYPE_PNG;
- else if (strcasecmp(image_suffix, ".jpg") == 0 ||
- strcasecmp(image_suffix, ".jpeg") == 0)
- img_type(idict) = IMG_TYPE_JPG;
- else if (strcasecmp(image_suffix, ".jbig2") == 0 ||
- strcasecmp(image_suffix, ".jb2") == 0)
- img_type(idict) = IMG_TYPE_JBIG2;
- else if (strcasecmp(image_suffix, ".pdf") == 0)
- img_type(idict) = IMG_TYPE_PDF;
-}
-
-/**********************************************************************/
-
-void new_img_pdfstream_struct(image_dict * p)
-{
- assert(p != NULL);
- assert(img_pdfstream_ptr(p) == NULL);
- img_pdfstream_ptr(p) = xtalloc(1, pdf_stream_struct);
- img_pdfstream_stream(p) = NULL;
-}
-
-/**********************************************************************/
-
-void init_image(image * p)
-{
- assert(p != NULL);
- set_wd_running(p);
- set_ht_running(p);
- set_dp_running(p);
- img_transform(p) = 0;
- img_flags(p) = 0;
- img_unset_scaled(p);
- img_dict(p) = NULL;
- img_arrayidx(p) = -1; /* -1 = unused, used count from 0 */
- img_dictref(p) = LUA_NOREF;
-}
-
-image *new_image(void)
-{
- image *p = xtalloc(1, image);
- init_image(p);
- return p;
-}
-
-void init_image_dict(image_dict * p)
-{
- assert(p != NULL);
- img_objnum(p) = 0;
- img_index(p) = 0;
- img_xsize(p) = 0;
- img_ysize(p) = 0;
- img_xorig(p) = 0;
- img_yorig(p) = 0;
- img_xres(p) = 0;
- img_yres(p) = 0;
- img_rotation(p) = 0;
- img_colorspace(p) = 0;
- img_group_ref(p) = 0;
- img_totalpages(p) = 0;
- img_pagenum(p) = 1;
- img_pagename(p) = NULL;
- img_filename(p) = NULL;
- img_filepath(p) = NULL;
- img_attr(p) = NULL;
- img_file(p) = NULL;
- img_type(p) = IMG_TYPE_NONE;
- img_color(p) = 0;
- img_colordepth(p) = 0;
- img_pagebox(p) = PDF_BOX_SPEC_MEDIA;
- img_bbox(p)[0] = 0;
- img_bbox(p)[1] = 0;
- img_bbox(p)[2] = 0;
- img_bbox(p)[3] = 0;
- img_unset_bbox(p);
- img_state(p) = DICT_NEW;
- img_png_ptr(p) = NULL; /* union */
-}
-
-image_dict *new_image_dict(void)
-{
- image_dict *p = xtalloc(1, image_dict);
- init_image_dict(p);
- return p;
-}
-
-static void free_dict_strings(image_dict * p)
-{
- if (img_filename(p) != NULL)
- xfree(img_filename(p));
- img_filename(p) = NULL;
- if (img_filepath(p) != NULL)
- xfree(img_filepath(p));
- img_filepath(p) = NULL;
- if (img_attr(p) != NULL)
- xfree(img_attr(p));
- img_attr(p) = NULL;
- if (img_pagename(p) != NULL)
- xfree(img_pagename(p));
- img_pagename(p) = NULL;
-}
-
-void free_image_dict(image_dict * p)
-{
- if (ini_version)
- return; /* The image may be \dump{}ed to a format */
- /* called from limglib.c */
- assert(img_state(p) < DICT_REFERED);
- switch (img_type(p)) {
- case IMG_TYPE_PDF:
- unrefPdfDocument(img_filepath(p));
- break;
- case IMG_TYPE_PNG: /* assuming IMG_CLOSEINBETWEEN */
- assert(img_png_ptr(p) == NULL);
- break;
- case IMG_TYPE_JPG: /* assuming IMG_CLOSEINBETWEEN */
- assert(img_jpg_ptr(p) == NULL);
- break;
- case IMG_TYPE_JBIG2: /* todo: writejbig2.c cleanup */
- break;
- case IMG_TYPE_PDFSTREAM:
- if (img_pdfstream_ptr(p) != NULL) {
- if (img_pdfstream_stream(p) != NULL)
- xfree(img_pdfstream_stream(p));
- xfree(img_pdfstream_ptr(p));
- }
- break;
- case IMG_TYPE_NONE:
- break;
- default:
- assert(0);
- }
- free_dict_strings(p);
- assert(img_file(p) == NULL);
- xfree(p);
-}
-
-/**********************************************************************/
-
-void pdf_print_resname_prefix(void)
-{
- if (pdf_resname_prefix != 0)
- pdf_printf(makecstring(pdf_resname_prefix));
-}
-
-void read_img(image_dict * idict, integer pdf_minor_version,
- integer pdf_inclusion_errorlevel)
-{
- char *filepath;
- int callback_id;
- assert(idict != NULL);
- if (img_filename(idict) == NULL)
- pdftex_fail("image file name missing");
- callback_id = callback_defined(find_image_file_callback);
- if (img_filepath(idict) == NULL) {
- if (callback_id > 0
- && run_callback(callback_id, "S->S", img_filename(idict),
- &filepath)) {
- if (filepath && (strlen(filepath) > 0))
- img_filepath(idict) = strdup(filepath);
- } else
- img_filepath(idict) =
- kpse_find_file(img_filename(idict), kpse_tex_format, true);
- }
- if (img_filepath(idict) == NULL)
- pdftex_fail("cannot find image file");
- recorder_record_input(img_filename(idict));
- /* type checks */
- check_type_by_header(idict);
- check_type_by_extension(idict);
- /* read image */
- switch (img_type(idict)) {
- case IMG_TYPE_PDF:
- read_pdf_info(idict, pdf_minor_version, pdf_inclusion_errorlevel);
- img_group_ref(idict) = epdf_lastGroupObjectNum;
- break;
- case IMG_TYPE_PNG:
- read_png_info(idict, IMG_CLOSEINBETWEEN);
- break;
- case IMG_TYPE_JPG:
- read_jpg_info(idict, IMG_CLOSEINBETWEEN);
- break;
- case IMG_TYPE_JBIG2:
- if (pdf_minor_version < 4) {
- pdftex_fail
- ("JBIG2 images only possible with at least PDF 1.4; you are generating PDF 1.%i",
- (int) pdf_minor_version);
- }
- read_jbig2_info(idict);
- break;
- default:
- pdftex_fail("internal error: unknown image type (2)");
- }
- cur_file_name = NULL;
- if (img_state(idict) < DICT_FILESCANNED)
- img_state(idict) = DICT_FILESCANNED;
-}
-
-// Within scale_img() only image width and height matter;
-// the offsets and positioning are not interesting here.
-// But one needs rotation info to swap width and height.
-// img_rotation() comes from the optional /Rotate key in the PDF file.
-
-void scale_img(image * img)
-{
- integer x, y, xr, yr, tmp; /* size and resolution of image */
- scaled w = 0, h = 0; /* indeed size corresponds to image resolution */
- integer default_res;
- image_dict *idict;
- assert(img != NULL);
- idict = img_dict(img);
- assert(idict != NULL);
- if ((img_type(idict) == IMG_TYPE_PDF
- || img_type(idict) == IMG_TYPE_PDFSTREAM) && img_is_bbox(idict)) {
- x = img_xsize(idict) = img_bbox(idict)[2] - img_bbox(idict)[0]; /* dimensions from image.bbox */
- y = img_ysize(idict) = img_bbox(idict)[3] - img_bbox(idict)[1];
- img_xorig(idict) = img_bbox(idict)[0];
- img_yorig(idict) = img_bbox(idict)[1];
- } else {
- x = img_xsize(idict); /* dimensions, resolutions from image file */
- y = img_ysize(idict);
- }
- xr = img_xres(idict);
- yr = img_yres(idict);
- if (x <= 0 || y <= 0 || xr < 0 || yr < 0)
- pdftex_fail("ext1: invalid image dimensions");
- if (xr > 65535 || yr > 65535) {
- xr = 0;
- yr = 0;
- pdftex_warn("ext1: too large image resolution ignored");
- }
- if (((img_transform(img) - img_rotation(idict)) & 1) == 1) {
- tmp = x;
- x = y;
- y = tmp;
- tmp = xr;
- xr = yr;
- yr = tmp;
- }
- if (img_type(idict) == IMG_TYPE_PDF
- || img_type(idict) == IMG_TYPE_PDFSTREAM) {
- w = x;
- h = y;
- } else {
- default_res = fix_int(get_pdf_image_resolution(), 0, 65535);
- if (default_res > 0 && (xr == 0 || yr == 0)) {
- xr = default_res;
- yr = default_res;
- }
- if (is_wd_running(img) && is_ht_running(img)) {
- if (xr > 0 && yr > 0) {
- w = ext_xn_over_d(one_hundred_inch, x, 100 * xr);
- h = ext_xn_over_d(one_hundred_inch, y, 100 * yr);
- } else {
- w = ext_xn_over_d(one_hundred_inch, x, 7200);
- h = ext_xn_over_d(one_hundred_inch, y, 7200);
- }
- }
- }
- if (is_wd_running(img) && is_ht_running(img) && is_dp_running(img)) {
- img_width(img) = w;
- img_height(img) = h;
- img_depth(img) = 0;
- } else if (is_wd_running(img)) {
- /* image depth or height is explicitly specified */
- if (is_ht_running(img)) {
- /* image depth is explicitly specified */
- img_width(img) = ext_xn_over_d(h, x, y);
- img_height(img) = h - img_depth(img);
- } else if (is_dp_running(img)) {
- /* image height is explicitly specified */
- img_width(img) = ext_xn_over_d(img_height(img), x, y);
- img_depth(img) = 0;
- } else {
- /* both image depth and height are explicitly specified */
- img_width(img) =
- ext_xn_over_d(img_height(img) + img_depth(img), x, y);
- }
- } else {
- /* image width is explicitly specified */
- if (is_ht_running(img) && is_dp_running(img)) {
- /* both image depth and height are not specified */
- img_height(img) = ext_xn_over_d(img_width(img), y, x);
- img_depth(img) = 0;
- }
- /* image depth is explicitly specified */
- else if (is_ht_running(img)) {
- img_height(img) =
- ext_xn_over_d(img_width(img), y, x) - img_depth(img);
- }
- /* image height is explicitly specified */
- else if (is_dp_running(img)) {
- img_depth(img) = 0;
- }
- /* else both image depth and height are explicitly specified */
- }
- img_set_scaled(img);
-}
-
-static void out_img(image * img, pdfstructure * p, scaledpos * pos)
-{
- float a[6]; /* transformation matrix */
- float xoff, yoff, tmp;
- int r; /* number of digits after the decimal point */
- int k;
- scaled wd, ht, dp;
- scaledpos tmppos;
- pdffloat cm[6];
- image_dict *idict;
- integer groupref; /* added from web for 1.40.8 */
- assert(img != 0);
- idict = img_dict(img);
- assert(idict != 0);
- wd = img_width(img);
- ht = img_height(img);
- dp = img_depth(img);
- a[0] = a[3] = 1.0e6;
- a[1] = a[2] = 0;
- if (img_type(idict) == IMG_TYPE_PDF
- || img_type(idict) == IMG_TYPE_PDFSTREAM) {
- a[0] /= img_xsize(idict);
- a[3] /= img_ysize(idict);
- xoff = (float) img_xorig(idict) / img_xsize(idict);
- yoff = (float) img_yorig(idict) / img_ysize(idict);
- r = 6;
- } else {
- /* added from web for 1.40.8 */
- if (img_type(idict) == IMG_TYPE_PNG) {
- groupref = img_group_ref(idict);
- if ((groupref > 0) && (pdf_page_group_val < 1))
- pdf_page_group_val = groupref;
- }
- /* /added from web */
- a[0] /= one_hundred_bp;
- a[3] = a[0];
- xoff = yoff = 0;
- r = 4;
- }
- if ((img_transform(img) & 7) > 3) { // mirror cases
- a[0] *= -1;
- xoff *= -1;
- }
- switch ((img_transform(img) + img_rotation(idict)) & 3) {
- case 0: /* no transform */
- break;
- case 1: /* rot. 90 deg. (counterclockwise) */
- a[1] = a[0];
- a[2] = -a[3];
- a[3] = a[0] = 0;
- tmp = yoff;
- yoff = xoff;
- xoff = -tmp;
- break;
- case 2: /* rot. 180 deg. (counterclockwise) */
- a[0] *= -1;
- a[3] *= -1;
- xoff *= -1;
- yoff *= -1;
- break;
- case 3: /* rot. 270 deg. (counterclockwise) */
- a[1] = -a[0];
- a[2] = a[3];
- a[3] = a[0] = 0;
- tmp = yoff;
- yoff = -xoff;
- xoff = tmp;
- break;
- default:;
- }
- xoff *= wd;
- yoff *= ht + dp;
- a[0] *= wd;
- a[1] *= ht + dp;
- a[2] *= wd;
- a[3] *= ht + dp;
- a[4] = pos->h - xoff;
- a[5] = pos->v - yoff;
- k = img_transform(img) + img_rotation(idict);
- if ((img_transform(img) & 7) > 3)
- k++;
- switch (k & 3) {
- case 0: /* no transform */
- break;
- case 1: /* rot. 90 deg. (counterclockwise) */
- a[4] += wd;
- break;
- case 2: /* rot. 180 deg. */
- a[4] += wd;
- a[5] += ht + dp;
- break;
- case 3: /* rot. 270 deg. */
- a[5] += ht + dp;
- break;
- default:;
- }
- /* the following is a kludge, TODO: use pdfpage.c functions */
- setpdffloat(cm[0], round(a[0]), r);
- setpdffloat(cm[1], round(a[1]), r);
- setpdffloat(cm[2], round(a[2]), r);
- setpdffloat(cm[3], round(a[3]), r);
- tmppos.h = round(a[4]);
- tmppos.v = round(a[5]);
- (void) calc_pdfpos(p, &tmppos);
- cm[4] = p->cm[4];
- cm[5] = p->cm[5];
- pdf_goto_pagemode();
- if (pdf_page_group_val < 1)
- pdf_page_group_val = img_group_ref(idict); /* added from web for 1.40.8 */
- pdf_printf("q\n");
- pdf_print_cm(cm);
- pdf_printf("/Im");
- pdf_print_int(img_index(idict));
- pdf_print_resname_prefix();
- pdf_printf(" Do\nQ\n");
- if (img_state(idict) < DICT_OUTIMG)
- img_state(idict) = DICT_OUTIMG;
-}
-
-void write_img(image_dict * idict)
-{
- assert(idict != NULL);
- if (img_state(idict) < DICT_WRITTEN) {
- if (tracefilenames)
- tex_printf(" <%s", img_filepath(idict));
- switch (img_type(idict)) {
- case IMG_TYPE_PNG:
- write_png(idict);
- break;
- case IMG_TYPE_JPG:
- write_jpg(idict);
- break;
- case IMG_TYPE_JBIG2:
- write_jbig2(idict);
- break;
- case IMG_TYPE_PDF:
- write_epdf(idict);
- epdf_lastGroupObjectNum = img_group_ref(idict);
- break;
- case IMG_TYPE_PDFSTREAM:
- write_pdfstream(idict);
- break;
- default:
- pdftex_fail("internal error: unknown image type (1)");
- }
- if (tracefilenames)
- tex_printf(">");
- if (img_type(idict) == IMG_TYPE_PDF) {
- write_additional_epdf_objects();
- } else {
- if (img_type(idict) == IMG_TYPE_PNG) {
- write_additional_png_objects();
- }
- }
- }
- if (img_state(idict) < DICT_WRITTEN)
- img_state(idict) = DICT_WRITTEN;
-}
-
-/**********************************************************************/
-
-void check_pdfstream_dict(image_dict * idict)
-{
- if (!img_is_bbox(idict))
- pdftex_fail("image.stream: no bbox given");
- if (img_state(idict) < DICT_FILESCANNED)
- img_state(idict) = DICT_FILESCANNED;
-}
-
-void write_pdfstream(image_dict * idict)
-{
- char s[256];
- assert(img_pdfstream_ptr(idict) != NULL);
- assert(img_is_bbox(idict));
- pdf_puts("/Type /XObject\n/Subtype /Form\n");
- if (img_attr(idict) != NULL && strlen(img_attr(idict)) > 0)
- pdf_printf("%s\n", img_attr(idict));
- pdf_puts("/FormType 1\n");
- sprintf(s, "/BBox [%.8f %.8f %.8f %.8f]\n", int2bp(img_bbox(idict)[0]),
- int2bp(img_bbox(idict)[1]), int2bp(img_bbox(idict)[2]),
- int2bp(img_bbox(idict)[3]));
- pdf_printf(stripzeros(s));
- pdf_begin_stream();
- if (img_pdfstream_stream(idict) != NULL)
- pdf_puts(img_pdfstream_stream(idict));
- pdf_end_stream();
-}
-
-/**********************************************************************/
-
-typedef image *img_entry;
-/* define img_ptr, img_array, & img_limit */
-/* avoid use of size_t */
-img_entry *img_ptr, *img_array = NULL;
-size_t img_limit;
-
-integer img_to_array(image * img)
-{
- assert(img != NULL);
- alloc_array(img, 1, SMALL_BUF_SIZE);
- *img_ptr = img;
- return img_ptr++ - img_array; /* now img is read-only */
-}
-
-/**********************************************************************/
-
-/* To allow the use of \pdfrefximage inside saved boxes in -ini mode,
- * the information in the array has to be (un)dumped with the format.
- * The next two routines take care of that.
- *
- * Most of the work involved in setting up the images is simply
- * executed again. This solves the many possible errors resulting from
- * the split in two separate runs.
-
- * There was only one problem remaining: The pdfversion and
- * pdfinclusionerrorlevel can have changed inbetween the call to
- * readimage() and dump time. That is why they are passed as arguments
- * to undumpimagemeta once more.
- */
-
-/* some of the dumped values are really type int, not integer,
- * but since the macro falls back to generic_dump anyway, that
- * does not matter.
- */
-
-#define dumpinteger generic_dump
-#define undumpinteger generic_undump
-
-/* (un)dumping a string means dumping the allocation size, followed
- * by the bytes. The trailing \0 is dumped as well, because that
- * makes the code simpler.
- */
-
-#define dumpcharptr(a) \
- do { \
- integer x; \
- if (a!=NULL) { \
- x = strlen(a)+1; \
- dumpinteger(x); dump_things(*a, x); \
- } else { \
- x = 0; dumpinteger(x); \
- } \
- } while (0)
-
-#define undumpcharptr(s) \
- do { \
- integer x; \
- char *a; \
- undumpinteger (x); \
- if (x>0) { \
- a = malloc(x); \
- undump_things(*a,x); \
- s = a ; \
- } else { s = NULL; } \
- } while (0)
-
-void dumpimagemeta(void)
-{
- int cur_image, i;
- image *img;
- image_dict *idict;
-
- dumpinteger(img_limit);
- cur_image = (img_ptr - img_array);
- dumpinteger(cur_image);
-
- for (i = 0; i < cur_image; i++) {
- img = img_array[i];
- assert(img != NULL);
- idict = img_dict(img);
- dumpcharptr(img_filename(idict));
- dumpinteger(img_type(idict));
- dumpinteger(img_color(idict));
- dumpinteger(img_width(img));
- dumpinteger(img_height(img));
- dumpinteger(img_xres(idict));
- dumpinteger(img_yres(idict));
- dumpinteger(img_totalpages(idict));
- dumpinteger(img_colorspace(idict));
- dumpinteger(img_group_ref(idict));
-
- /* the image_struct is not dumped at all, except for a few
- variables that are needed to restore the contents */
-
- if (img_type(idict) == IMG_TYPE_PDF) {
- dumpinteger(img_pagebox(idict));
- dumpinteger(img_pagenum(idict));
- } else if (img_type(idict) == IMG_TYPE_JBIG2) {
- dumpinteger(img_pagenum(idict));
- }
-
- }
-}
-
-void undumpimagemeta(integer pdfversion, integer pdfinclusionerrorlevel)
-{
- int cur_image, i;
- image *img;
- image_dict *idict;
-
- undumpinteger(img_limit);
-
- img_array = xtalloc(img_limit, img_entry);
- undumpinteger(cur_image);
- img_ptr = img_array + cur_image;
-
- for (i = 0; i < cur_image; i++) {
- img = new_image();
- assert(img_arrayidx(img) == -1);
- img_arrayidx(img) = img_to_array(img);
- idict = img_dict(img) = new_image_dict();
- assert(idict != NULL);
- undumpcharptr(img_filename(idict));
- undumpinteger(img_type(idict));
- undumpinteger(img_color(idict));
- undumpinteger(img_width(img));
- undumpinteger(img_height(img));
- undumpinteger(img_xres(idict));
- undumpinteger(img_yres(idict));
- undumpinteger(img_totalpages(idict));
- undumpinteger(img_colorspace(idict));
- undumpinteger(img_group_ref(idict));
-
- switch (img_type(idict)) {
- case IMG_TYPE_PDF:
- undumpinteger(img_pagebox(idict));
- undumpinteger(img_pagenum(idict));
- break;
- case IMG_TYPE_PNG:
- break;
- case IMG_TYPE_JPG:
- break;
- case IMG_TYPE_JBIG2:
- if (pdfversion < 4) {
- pdftex_fail
- ("JBIG2 images only possible with at least PDF 1.4; you are generating PDF 1.%i",
- (int) pdfversion);
- }
- undumpinteger(img_pagenum(idict));
- break;
- default:
- pdftex_fail("unknown type of image");
- }
- read_img(idict, pdfversion, pdfinclusionerrorlevel);
- }
-}
-
-/**********************************************************************/
-/* stuff to be accessible from TeX */
-
-integer read_image(integer objnum, integer index, str_number filename,
- integer page_num, str_number page_name, str_number attr,
- integer colorspace, integer page_box,
- integer pdf_minor_version, integer pdf_inclusion_errorlevel)
-{
- image_dict *idict;
- image *a = new_image();
- assert(img_arrayidx(a) == -1);
- img_arrayidx(a) = img_to_array(a);
- idict = img_dict(a) = new_image_dict();
- assert(idict != NULL);
- img_objnum(idict) = objnum;
- img_index(idict) = index;
- /* img_xsize, img_ysize, img_xres, img_yres set by read_img() */
- img_colorspace(idict) = colorspace;
- img_pagenum(idict) = page_num;
- /* img_totalpages set by read_img() */
- if (page_name != 0)
- img_pagename(idict) = xstrdup(makecstring(page_name));
- cur_file_name = makecfilename(filename);
- assert(cur_file_name != NULL);
- img_filename(idict) = xstrdup(cur_file_name);
- if (attr != 0)
- img_attr(idict) = xstrdup(makecstring(attr));
- img_pagebox(idict) = page_box;
- read_img(idict, pdf_minor_version, pdf_inclusion_errorlevel);
- img_unset_scaled(a);
- return img_arrayidx(a);
-}
-
-void set_image_dimensions(integer ref, integer wd, integer ht, integer dp)
-{
- image *a = img_array[ref];
- img_width(a) = wd;
- img_height(a) = ht;
- img_depth(a) = dp;
-}
-
-void scale_image(integer ref)
-{
- scale_img(img_array[ref]);
-}
-
-void out_image(integer ref, scaled hpos, scaled vpos)
-{
- image *a = img_array[ref];
- scaledpos pos;
- pos.h = hpos;
- pos.v = vpos;
- out_img(a, pstruct, &pos);
-}
-
-void write_image(integer ref)
-{
- write_img(img_dict(img_array[ref]));
-}
-
-integer image_pages(integer ref)
-{
- return img_totalpages(img_dict(img_array[ref]));
-}
-
-integer image_colordepth(integer ref)
-{
- return img_colordepth(img_dict(img_array[ref]));
-}
-
-#if 0 /* unused */
-static integer image_group_ref(integer ref)
-{
- return img_group_ref(img_dict(img_array[ref]));
-}
-#endif
-
-/* The following five functions are for \pdfximagebbox */
-
-integer epdf_xsize(integer ref)
-{
- return img_xsize(img_dict(img_array[ref]));
-}
-
-integer epdf_ysize(integer ref)
-{
- return img_ysize(img_dict(img_array[ref]));
-}
-
-integer epdf_orig_x(integer ref)
-{
- return img_xorig(img_dict(img_array[ref]));
-}
-
-integer epdf_orig_y(integer ref)
-{
- return img_yorig(img_dict(img_array[ref]));
-}
-
-boolean is_pdf_image(integer ref)
-{
- return img_type(img_dict(img_array[ref])) == IMG_TYPE_PDF;
-}
-
-boolean is_png_image(integer ref)
-{
- return img_type(img_dict(img_array[ref])) == IMG_TYPE_PNG;
-}
-
-integer image_objnum(integer ref)
-{
- return img_objnum(img_dict(img_array[ref]));
-}
-
-integer image_index(integer ref)
-{
- return img_index(img_dict(img_array[ref]));
-}
-
-integer image_width(integer ref)
-{
- return img_width(img_array[ref]);
-}
-
-integer image_height(integer ref)
-{
- return img_height(img_array[ref]);
-}
-
-integer image_depth(integer ref)
-{
- return img_depth(img_array[ref]);
-}
-
-void update_image_procset(integer ref)
-{
- pdf_image_procset |= img_color(img_dict(img_array[ref]));
-}
-
-boolean check_image_b(integer procset)
-{
- return procset & IMAGE_COLOR_B;
-}
-
-boolean check_image_c(integer procset)
-{
- return procset & IMAGE_COLOR_C;
-}
-
-boolean check_image_i(integer procset)
-{
- return procset & IMAGE_COLOR_I;
-}