1 /*
2 Copyright 1996-2014 Han The Thanh, <thanh@pdftex.org>
3
4 This file is part of pdfTeX.
5
6 pdfTeX is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 pdfTeX is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License along
17 with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "ptexlib.h"
21 #include "image.h"
22 #include <kpathsea/c-auto.h>
23 #include <kpathsea/c-memstr.h>
24
25 #define bp2int(p) round(p*(onehundredbp/100.0))
26
27 /* define image_ptr, image_array & image_limit */
28 /* define_array(image); */
29
30 /* avoid use of size_t */
31 image_entry *image_ptr, *image_array = NULL;
32 integer image_limit;
33
34 float epdf_width;
35 float epdf_height;
36 float epdf_orig_x;
37 float epdf_orig_y;
38 float epdf_rotate;
39 int epdf_selected_page;
40 int epdf_num_pages;
41 int epdf_page_box;
42 void *epdf_doc;
43 int epdf_has_page_group;
44
new_image_entry(void)45 static integer new_image_entry(void)
46 {
47 alloc_array(image, 1, SMALL_BUF_SIZE);
48 image_ptr->image_type = IMAGE_TYPE_NONE;
49 image_ptr->color_type = 0;
50 image_ptr->num_pages = 0;
51 image_ptr->x_res = 0;
52 image_ptr->y_res = 0;
53 image_ptr->width = 0;
54 image_ptr->height = 0;
55 image_ptr->rotate = 0;
56 image_ptr->colorspace_ref = 0;
57 image_ptr->group_ref = 0;
58 return image_ptr++ - image_array;
59 }
60
imagecolor(integer img)61 integer imagecolor(integer img)
62 {
63 return img_color(img);
64 }
65
imagewidth(integer img)66 integer imagewidth(integer img)
67 {
68 return img_width(img);
69 }
70
imageheight(integer img)71 integer imageheight(integer img)
72 {
73 return img_height(img);
74 }
75
imagerotate(integer img)76 integer imagerotate(integer img)
77 {
78 return img_rotate(img);
79 }
80
imagexres(integer img)81 integer imagexres(integer img)
82 {
83 return img_xres(img);
84 }
85
imageyres(integer img)86 integer imageyres(integer img)
87 {
88 return img_yres(img);
89 }
90
ispdfimage(integer img)91 boolean ispdfimage(integer img)
92 {
93 return img_type(img) == IMAGE_TYPE_PDF;
94 }
95
ispngimage(integer img)96 boolean ispngimage(integer img)
97 {
98 return img_type(img) == IMAGE_TYPE_PNG;
99 }
100
checkimageb(integer procset)101 boolean checkimageb(integer procset)
102 {
103 return procset & IMAGE_COLOR_B;
104 }
105
checkimagec(integer procset)106 boolean checkimagec(integer procset)
107 {
108 return procset & IMAGE_COLOR_C;
109 }
110
checkimagei(integer procset)111 boolean checkimagei(integer procset)
112 {
113 return procset & IMAGE_COLOR_I;
114 }
115
updateimageprocset(integer img)116 void updateimageprocset(integer img)
117 {
118 pdfimageprocset |= img_color(img);
119 }
120
epdforigx(integer img)121 integer epdforigx(integer img)
122 {
123 return pdf_ptr(img)->orig_x;
124 }
125
epdforigy(integer img)126 integer epdforigy(integer img)
127 {
128 return pdf_ptr(img)->orig_y;
129 }
130
imagepages(integer img)131 integer imagepages(integer img)
132 {
133 return img_pages(img);
134 }
135
imagecolordepth(integer img)136 integer imagecolordepth(integer img)
137 {
138 switch (img_type(img)) {
139 case IMAGE_TYPE_PNG:
140 return png_get_bit_depth(png_ptr(img), png_info(img));
141 case IMAGE_TYPE_JPG:
142 return jpg_ptr(img)->bits_per_component;
143 case IMAGE_TYPE_JBIG2:
144 return 0;
145 case IMAGE_TYPE_PDF:
146 return 0;
147 default:
148 pdftex_fail("unknown type of image");
149 return -1; /* to make the compiler happy */
150 }
151 }
152
getimagegroupref(integer img)153 integer getimagegroupref(integer img)
154 {
155 return img_group_ref(img);
156 }
157
setimagegroupref(integer img,integer value)158 void setimagegroupref(integer img, integer value)
159 {
160 img_group_ref(img) = value;
161 }
162
163 /*
164 Patch ImageTypeDetection 2003/02/08 by Heiko Oberdiek.
165
166 Function "readimage" performs some basic initializations.
167 Then it looks at the file extension to determine the
168 image type and calls specific code/functions.
169 The main disadvantage is that standard file extensions
170 have to be used, otherwise pdfTeX is not able to detect
171 the correct image type.
172
173 The patch now looks at the file header first regardless of
174 the file extension. This is implemented in function
175 "checktypebyheader". If this check fails, the traditional
176 test of standard file extension is tried, done in function
177 "checktypebyextension".
178
179 Magic headers:
180
181 * "PNG (Portable Network Graphics) Specification", Version 1.2
182 (http://www.libpng.org/pub/png):
183
184 | 3.1. PNG file signature
185 |
186 | The first eight bytes of a PNG file always contain the following
187 | (decimal) values:
188 |
189 | 137 80 78 71 13 10 26 10
190
191 Translation to C: "\x89PNG\r\n\x1A\n"
192
193 * "JPEG File Interchange Format", Version 1.02:
194
195 | o you can identify a JFIF file by looking for the following
196 | sequence: X'FF', SOI X'FF', APP0, <2 bytes to be skipped>,
197 | "JFIF", X'00'.
198
199 Function "checktypebyheader" only looks at the first two bytes:
200 "\xFF\xD8"
201
202 * ISO/IEC JTC 1/SC 29/WG 1
203 (ITU-T SG8)
204 Coding of Still Pictures
205 Title: 14492 FCD
206 Source: JBIG Committee
207 Project: JTC 1.29.10
208 Status: Final Committee Draft
209
210 | D.4.1, ID string
211 |
212 | This is an 8-byte sequence containing 0x97 0x4A 0x42 0x32 0x0D 0x0A
213 | 0x1A 0x0A.
214
215 * "PDF Reference", third edition:
216 * The first line should contain "%PDF-1.0" until "%PDF-1.4"
217 (section 3.4.1 "File Header").
218 * The "implementation notes" say:
219
220 | 3.4.1, File Header
221 | 12. Acrobat viewers require only that the header appear
222 | somewhere within the first 1024 bytes of the file.
223 | 13. Acrobat viewers will also accept a header of the form
224 | %!PS-Adobe-N.n PDF-M.m
225
226 The check in function "checktypebyheader" only implements
227 the first issue. The implementation notes are not considered.
228 Therefore files with garbage at start of file must have the
229 standard extension.
230
231 Functions "checktypebyheader" and "checktypebyextension":
232 img_type(img) is set to IMAGE_TYPE_NONE by new_image_entry().
233 Both functions tries to detect a type and set img_type(img).
234 Thus a value other than IMAGE_TYPE_NONE indicates that a
235 type is found.
236 */
237
238 #define HEADER_JPG "\xFF\xD8"
239 #define HEADER_PNG "\x89PNG\r\n\x1A\n"
240 #define HEADER_JBIG2 "\x97\x4A\x42\x32\x0D\x0A\x1A\x0A"
241 #define HEADER_PDF "%PDF-1."
242 #define MAX_HEADER (sizeof(HEADER_PNG)-1)
checktypebyheader(integer img)243 static void checktypebyheader(integer img)
244 {
245 int i;
246 FILE *file = NULL;
247 char header[MAX_HEADER];
248
249 if (img_type(img) != IMAGE_TYPE_NONE) /* nothing to do */
250 return;
251
252 /* read the header */
253 file = xfopen(img_name(img), FOPEN_RBIN_MODE);
254 for (i = 0; (unsigned) i < MAX_HEADER; i++) {
255 header[i] = xgetc(file);
256 if (feof(file))
257 pdftex_fail("reading image file failed");
258 }
259 xfclose(file, img_name(img));
260
261 /* tests */
262 if (strncmp(header, HEADER_JPG, sizeof(HEADER_JPG) - 1) == 0)
263 img_type(img) = IMAGE_TYPE_JPG;
264 else if (strncmp(header, HEADER_PNG, sizeof(HEADER_PNG) - 1) == 0)
265 img_type(img) = IMAGE_TYPE_PNG;
266 else if (strncmp(header, HEADER_JBIG2, sizeof(HEADER_JBIG2) - 1) == 0)
267 img_type(img) = IMAGE_TYPE_JBIG2;
268 else if (strncmp(header, HEADER_PDF, sizeof(HEADER_PDF) - 1) == 0)
269 img_type(img) = IMAGE_TYPE_PDF;
270 }
271
checktypebyextension(integer img)272 static void checktypebyextension(integer img)
273 {
274 char *image_suffix;
275
276 if (img_type(img) != IMAGE_TYPE_NONE) /* nothing to do */
277 return;
278 /* tests */
279 if ((image_suffix = strrchr(cur_file_name, '.')) == 0)
280 img_type(img) = IMAGE_TYPE_NONE;
281 else if (strcasecmp(image_suffix, ".png") == 0)
282 img_type(img) = IMAGE_TYPE_PNG;
283 else if (strcasecmp(image_suffix, ".jpg") == 0 ||
284 strcasecmp(image_suffix, ".jpeg") == 0)
285 img_type(img) = IMAGE_TYPE_JPG;
286 else if (strcasecmp(image_suffix, ".jbig2") == 0 ||
287 strcasecmp(image_suffix, ".jb2") == 0)
288 img_type(img) = IMAGE_TYPE_JBIG2;
289 else if (strcasecmp(image_suffix, ".pdf") == 0)
290 img_type(img) = IMAGE_TYPE_PDF;
291 }
292
readimage(strnumber s,integer page_num,strnumber page_name,integer colorspace,integer pagebox,integer pdfversion,integer pdfinclusionerrorlevel)293 integer readimage(strnumber s, integer page_num, strnumber page_name,
294 integer colorspace, integer pagebox,
295 integer pdfversion, integer pdfinclusionerrorlevel)
296 {
297 char *dest = NULL;
298 integer img = new_image_entry();
299 img_colorspace_ref(img) = colorspace;
300
301 /* need to allocate new string as makecstring's buffer is
302 already used by cur_file_name */
303 if (page_name != 0)
304 dest = xstrdup(makecstring(page_name));
305 cur_file_name = makecfilename(s);
306 img_name(img) = kpse_find_file(cur_file_name, kpse_tex_format, true);
307 if (img_name(img) == NULL)
308 pdftex_fail("cannot find image file");
309 /* kpse_find_file perhaps changed the file name */
310 cur_file_name = img_name(img);
311 recorder_record_input(cur_file_name);
312 /* type checks */
313 checktypebyheader(img);
314 checktypebyextension(img);
315 /* read image */
316 switch (img_type(img)) {
317 case IMAGE_TYPE_PDF:
318 pdf_ptr(img) = xtalloc(1, pdf_image_struct);
319 pdf_ptr(img)->page_box = pagebox;
320 page_num = read_pdf_info(img_name(img), dest, page_num, pagebox,
321 pdfversion, pdfinclusionerrorlevel);
322 img_width(img) = bp2int(epdf_width);
323 img_height(img) = bp2int(epdf_height);
324 img_rotate(img) = epdf_rotate;
325 img_pages(img) = epdf_num_pages;
326 pdf_ptr(img)->orig_x = bp2int(epdf_orig_x);
327 pdf_ptr(img)->orig_y = bp2int(epdf_orig_y);
328 pdf_ptr(img)->selected_page = page_num;
329 pdf_ptr(img)->doc = epdf_doc;
330 if (epdf_has_page_group == 1)
331 img_group_ref(img) = -1; // page group present, but new object
332 // number not set yet
333 else
334 img_group_ref(img) = 0; // no page group present
335 break;
336 case IMAGE_TYPE_PNG:
337 img_pages(img) = 1;
338 read_png_info(img);
339 break;
340 case IMAGE_TYPE_JPG:
341 jpg_ptr(img) = xtalloc(1, JPG_IMAGE_INFO);
342 img_pages(img) = 1;
343 read_jpg_info(img);
344 break;
345 case IMAGE_TYPE_JBIG2:
346 if (pdfversion < 4) {
347 pdftex_fail
348 ("JBIG2 images only possible with at least PDF 1.4; you are generating PDF 1.%i",
349 (int) pdfversion);
350 }
351 jbig2_ptr(img) = xtalloc(1, JBIG2_IMAGE_INFO);
352 img_type(img) = IMAGE_TYPE_JBIG2;
353 jbig2_ptr(img)->selected_page = page_num;
354 read_jbig2_info(img);
355 break;
356 default:
357 pdftex_fail("unknown type of image");
358 }
359 xfree(dest);
360 cur_file_name = NULL;
361 return img;
362 }
363
writeimage(integer img)364 void writeimage(integer img)
365 {
366 cur_file_name = img_name(img);
367 tex_printf(" <%s", img_name(img));
368 switch (img_type(img)) {
369 case IMAGE_TYPE_PNG:
370 write_png(img);
371 break;
372 case IMAGE_TYPE_JPG:
373 write_jpg(img);
374 break;
375 case IMAGE_TYPE_JBIG2:
376 write_jbig2(img);
377 break;
378 case IMAGE_TYPE_PDF:
379 epdf_doc = pdf_ptr(img)->doc;
380 epdf_selected_page = pdf_ptr(img)->selected_page;
381 epdf_page_box = pdf_ptr(img)->page_box;
382 write_epdf();
383 break;
384 default:
385 pdftex_fail("unknown type of image");
386 }
387
388 tex_printf(">");
389 cur_file_name = NULL;
390 }
391
deleteimage(integer img)392 void deleteimage(integer img)
393 {
394 if (iniversion)
395 return; // The image may be \dump{}ed to a format
396 switch (img_type(img)) {
397 case IMAGE_TYPE_PDF:
398 epdf_doc = pdf_ptr(img)->doc;
399 epdf_delete();
400 break;
401 case IMAGE_TYPE_PNG:
402 xfclose((FILE *) png_get_io_ptr(png_ptr(img)), cur_file_name);
403 png_destroy_read_struct(&(png_ptr(img)), &(png_info(img)), NULL);
404 break;
405 case IMAGE_TYPE_JPG:
406 xfclose(jpg_ptr(img)->file, cur_file_name);
407 break;
408 case IMAGE_TYPE_JBIG2:
409 break;
410 default:
411 pdftex_fail("unknown type of image");
412 }
413 xfree(img_name(img));
414 return;
415 }
416
img_free(void)417 void img_free(void)
418 {
419 xfree(image_array);
420 }
421
422
423 /* To allow the use of \pdfrefximage inside saved boxes in -ini mode,
424 * the information in the array has to be (un)dumped with the format.
425 * The next two routines take care of that.
426 *
427 * Most of the work involved in setting up the images is simply
428 * executed again. This solves the many possible errors resulting from
429 * the split in two separate runs.
430
431 * There was only one problem remaining: The pdfversion and
432 * pdfinclusionerrorlevel can have changed inbetween the call to
433 * readimage() and dump time. That is why they are passed as arguments
434 * to undumpimagemeta once more.
435 */
436
437 /* some of the dumped values are really type int, not integer,
438 * but since the macro falls back to generic_dump anyway, that
439 * does not matter.
440 */
441
442 /* #define dumpsizet generic_dump */
443 #define dumpinteger generic_dump
444
445 /* #define undumpsizet generic_undump */
446 #define undumpinteger generic_undump
447
448 /* (un)dumping a string means dumping the allocation size, followed
449 * by the bytes. The trailing \0 is dumped as well, because that
450 * makes the code simpler.
451 */
452
453 #define dumpcharptr(a) \
454 do { \
455 integer x; \
456 if (a!=NULL) { \
457 x = strlen(a)+1; \
458 dumpinteger(x); dumpthings(*a, x); \
459 } else { \
460 x = 0; dumpinteger(x); \
461 } \
462 } while (0)
463
464 #define undumpcharptr(s) \
465 do { \
466 integer x; \
467 char *a; \
468 undumpinteger (x); \
469 if (x>0) { \
470 a = malloc(x); \
471 undumpthings(*a,x); \
472 s = a ; \
473 } else { s = NULL; } \
474 } while (0)
475
476
477
dumpimagemeta(void)478 void dumpimagemeta(void)
479 {
480 int cur_image, img;
481
482 dumpinteger(image_limit);
483 cur_image = (image_ptr - image_array);
484 dumpinteger(cur_image);
485
486 for (img = 0; img < cur_image; img++) {
487
488 dumpcharptr(img_name(img));
489 dumpinteger(img_type(img));
490 dumpinteger(img_color(img));
491 dumpinteger(img_width(img));
492 dumpinteger(img_height(img));
493 dumpinteger(img_xres(img));
494 dumpinteger(img_yres(img));
495 dumpinteger(img_pages(img));
496 dumpinteger(img_colorspace_ref(img));
497 dumpinteger(img_group_ref(img));
498
499 /* the image_struct is not dumped at all, except for a few
500 variables that are needed to restore the contents */
501
502 if (img_type(img) == IMAGE_TYPE_PDF) {
503 dumpinteger(pdf_ptr(img)->page_box);
504 dumpinteger(pdf_ptr(img)->selected_page);
505 } else if (img_type(img) == IMAGE_TYPE_JBIG2) {
506 dumpinteger(jbig2_ptr(img)->selected_page);
507 }
508
509 }
510 }
511
undumpimagemeta(integer pdfversion,integer pdfinclusionerrorlevel)512 void undumpimagemeta(integer pdfversion, integer pdfinclusionerrorlevel)
513 {
514 int cur_image, img;
515
516 undumpinteger(image_limit);
517
518 image_array = xtalloc(image_limit, image_entry);
519 undumpinteger(cur_image);
520 image_ptr = image_array + cur_image;
521
522 for (img = 0; img < cur_image; img++) {
523 undumpcharptr(img_name(img));
524 undumpinteger(img_type(img));
525 undumpinteger(img_color(img));
526 undumpinteger(img_width(img));
527 undumpinteger(img_height(img));
528 undumpinteger(img_xres(img));
529 undumpinteger(img_yres(img));
530 undumpinteger(img_pages(img));
531 undumpinteger(img_colorspace_ref(img));
532 undumpinteger(img_group_ref(img));
533
534 /* if img_name(img)==NULL -- which it shouldn't be -- the next line
535 will trigger an assertion failure. */
536 if (kpse_find_file(img_name(img), kpse_tex_format, true) == NULL)
537 pdftex_fail("cannot find image file %s", img_name(img));
538
539 switch (img_type(img)) {
540 case IMAGE_TYPE_PDF:
541 pdf_ptr(img) = xtalloc(1, pdf_image_struct);
542
543 undumpinteger(pdf_ptr(img)->page_box);
544 undumpinteger(pdf_ptr(img)->selected_page);
545
546 read_pdf_info(img_name(img), NULL, pdf_ptr(img)->selected_page,
547 pdf_ptr(img)->page_box, pdfversion,
548 pdfinclusionerrorlevel);
549
550 img_width(img) = bp2int(epdf_width);
551 img_height(img) = bp2int(epdf_height);
552 img_pages(img) = epdf_num_pages;
553 pdf_ptr(img)->orig_x = bp2int(epdf_orig_x);
554 pdf_ptr(img)->orig_y = bp2int(epdf_orig_y);
555 pdf_ptr(img)->doc = epdf_doc;
556 break;
557 case IMAGE_TYPE_PNG:
558 img_pages(img) = 1;
559 read_png_info(img);
560 break;
561 case IMAGE_TYPE_JPG:
562 jpg_ptr(img) = xtalloc(1, JPG_IMAGE_INFO);
563 img_pages(img) = 1;
564 read_jpg_info(img);
565 break;
566 case IMAGE_TYPE_JBIG2:
567 if (pdfversion < 4) {
568 pdftex_fail
569 ("JBIG2 images only possible with at least PDF 1.4; you are generating PDF 1.%i",
570 (int) pdfversion);
571 }
572 jbig2_ptr(img) = xtalloc(1, JBIG2_IMAGE_INFO);
573 img_type(img) = IMAGE_TYPE_JBIG2;
574 undumpinteger(jbig2_ptr(img)->selected_page);
575 read_jbig2_info(img);
576 break;
577 default:
578 pdftex_fail("unknown type of image");
579 }
580 }
581 }
582