/src/ghostpdl/pdf/pdf_array.c
Line | Count | Source (jump to first uncovered line) |
1 | | /* Copyright (C) 2018-2025 Artifex Software, Inc. |
2 | | All Rights Reserved. |
3 | | |
4 | | This software is provided AS-IS with no warranty, either express or |
5 | | implied. |
6 | | |
7 | | This software is distributed under license and may not be copied, |
8 | | modified or distributed except as expressly authorized under the terms |
9 | | of the license contained in the file LICENSE in this distribution. |
10 | | |
11 | | Refer to licensing information at http://www.artifex.com or contact |
12 | | Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco, |
13 | | CA 94129, USA, for further information. |
14 | | */ |
15 | | |
16 | | /* array handling for the PDF interpreter */ |
17 | | |
18 | | #include "ghostpdf.h" |
19 | | #include "pdf_types.h" |
20 | | #include "pdf_stack.h" |
21 | | #include "pdf_deref.h" |
22 | | #include "pdf_array.h" |
23 | | #include "pdf_loop_detect.h" |
24 | | |
25 | | /* NOTE: I think this should take a pdf_context param, but it's not available where it's |
26 | | * called, would require some surgery. |
27 | | */ |
28 | | void pdfi_free_array(pdf_obj *o) |
29 | 14.8M | { |
30 | 14.8M | pdf_array *a = (pdf_array *)o; |
31 | 14.8M | int i; |
32 | | |
33 | 165M | for (i=0;i < a->size;i++) { |
34 | 150M | if (a->values[i] != NULL) |
35 | 150M | pdfi_countdown(a->values[i]); |
36 | 150M | } |
37 | 14.8M | gs_free_object(OBJ_MEMORY(a), a->values, "pdf interpreter free array contents"); |
38 | 14.8M | gs_free_object(OBJ_MEMORY(a), a, "pdf interpreter free array"); |
39 | 14.8M | } |
40 | | |
41 | | int pdfi_array_alloc(pdf_context *ctx, uint64_t size, pdf_array **a) |
42 | 14.7M | { |
43 | 14.7M | int code, i; |
44 | | |
45 | 14.7M | *a = NULL; |
46 | 14.7M | code = pdfi_object_alloc(ctx, PDF_ARRAY, size, (pdf_obj **)a); |
47 | 14.7M | if (code < 0) |
48 | 0 | return code; |
49 | | |
50 | 14.7M | (*a)->size = size; |
51 | | |
52 | 14.7M | if (size > 0) { |
53 | | /* Start all the array entries pointing to null. |
54 | | * array_put will replace tehm. This ensures we always have a valid |
55 | | * object for every entry. pdfi_array_from_stack() doesn't do this |
56 | | * initialisation because we know how many obejcts there are in the array |
57 | | * and we have valid objects for each entry on the stack already created. |
58 | | */ |
59 | 161M | for (i=0;i<size;i++){ |
60 | 147M | (*a)->values[i] = PDF_NULL_OBJ; |
61 | 147M | } |
62 | 13.8M | } |
63 | 14.7M | return 0; |
64 | 14.7M | } |
65 | | |
66 | | /* This was defined in pdf_int.c until we moved the equivalent pdfi_dict_from_stack() into |
67 | | * pdf_dict.c, because we needed to be able to create dictionaries for images. We don't have |
68 | | * that need, but its less confusing to have the array_from_stack function defined in |
69 | | * here, similarly to the dictionary routine. |
70 | | */ |
71 | | int pdfi_array_from_stack(pdf_context *ctx, uint32_t indirect_num, uint32_t indirect_gen) |
72 | 14.8M | { |
73 | 14.8M | uint64_t index = 0; |
74 | 14.8M | pdf_array *a = NULL; |
75 | 14.8M | pdf_obj *o; |
76 | 14.8M | int code; |
77 | | |
78 | 14.8M | code = pdfi_count_to_mark(ctx, &index); |
79 | 14.8M | if (code < 0) |
80 | 242k | return code; |
81 | | |
82 | 14.5M | code = pdfi_array_alloc(ctx, index, &a); |
83 | 14.5M | if (code < 0) |
84 | 0 | return code; |
85 | | |
86 | 122M | while (index) { |
87 | 107M | o = ctx->stack_top[-1]; |
88 | 107M | code = pdfi_array_put(ctx, a, --index, o); |
89 | 107M | if (code < 0) { |
90 | 0 | (void)pdfi_clear_to_mark(ctx); |
91 | 0 | return code; |
92 | 0 | } |
93 | 107M | pdfi_pop(ctx, 1); |
94 | 107M | } |
95 | | |
96 | 14.5M | code = pdfi_clear_to_mark(ctx); |
97 | 14.5M | if (code < 0) |
98 | 0 | return code; |
99 | | |
100 | 14.5M | if (ctx->args.pdfdebug) |
101 | 0 | outprintf (ctx->memory, " ]\n"); |
102 | | |
103 | 14.5M | a->indirect_num = indirect_num; |
104 | 14.5M | a->indirect_gen = indirect_gen; |
105 | | |
106 | 14.5M | code = pdfi_push(ctx, (pdf_obj *)a); |
107 | 14.5M | if (code < 0) |
108 | 0 | pdfi_free_array((pdf_obj *)a); |
109 | | |
110 | 14.5M | return code; |
111 | 14.5M | } |
112 | | |
113 | | int pdfi_array_fetch_recursing(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o, bool setref, bool cache) |
114 | 709k | { |
115 | 709k | int code; |
116 | 709k | pdf_obj *obj; |
117 | | |
118 | 709k | *o = NULL; |
119 | | |
120 | 709k | if (pdfi_type_of(a) != PDF_ARRAY) |
121 | 0 | return_error(gs_error_typecheck); |
122 | | |
123 | 709k | if (index >= a->size) |
124 | 0 | return_error(gs_error_rangecheck); |
125 | 709k | obj = a->values[index]; |
126 | | |
127 | 709k | if (pdfi_type_of(obj) == PDF_INDIRECT) { |
128 | 1.62k | pdf_obj *o1 = NULL; |
129 | 1.62k | pdf_indirect_ref *r = (pdf_indirect_ref *)obj; |
130 | | |
131 | 1.62k | if (r->ref_object_num == a->object_num) |
132 | 9 | return_error(gs_error_circular_reference); |
133 | | |
134 | 1.62k | if (cache) |
135 | 1.62k | code = pdfi_deref_loop_detect(ctx, r->ref_object_num, r->ref_generation_num, &o1); |
136 | 0 | else |
137 | 0 | code = pdfi_deref_loop_detect_nocache(ctx, r->ref_object_num, r->ref_generation_num, &o1); |
138 | 1.62k | if (code < 0) |
139 | 295 | return code; |
140 | | |
141 | 1.32k | if (setref) |
142 | 1.32k | (void)pdfi_array_put(ctx, a, index, o1); |
143 | 1.32k | obj = o1; |
144 | 707k | } else { |
145 | 707k | if (ctx->loop_detection != NULL && (uintptr_t)obj > TOKEN__LAST_KEY && obj->object_num != 0) |
146 | 742 | if (pdfi_loop_detector_check_object(ctx, obj->object_num)) |
147 | 0 | return gs_note_error(gs_error_circular_reference); |
148 | 707k | pdfi_countup(obj); |
149 | 707k | } |
150 | | |
151 | 709k | *o = obj; |
152 | 709k | return 0; |
153 | 709k | } |
154 | | |
155 | | /* Fetch object from array, resolving indirect reference if needed |
156 | | * setref -- indicates whether to replace indirect ref with the object |
157 | | */ |
158 | | int pdfi_array_fetch(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o, bool setref, bool cache) |
159 | 346M | { |
160 | 346M | int code; |
161 | 346M | pdf_obj *obj; |
162 | | |
163 | 346M | *o = NULL; |
164 | | |
165 | 346M | if (pdfi_type_of(a) != PDF_ARRAY) |
166 | 20 | return_error(gs_error_typecheck); |
167 | | |
168 | 346M | if (index >= a->size) |
169 | 7.62k | return_error(gs_error_rangecheck); |
170 | 346M | obj = a->values[index]; |
171 | | |
172 | 346M | if (pdfi_type_of(obj) == PDF_INDIRECT) { |
173 | 1.00M | pdf_obj *o1 = NULL; |
174 | 1.00M | pdf_indirect_ref *r = (pdf_indirect_ref *)obj; |
175 | | |
176 | 1.00M | if (r->ref_object_num == a->object_num) |
177 | 153 | return_error(gs_error_circular_reference); |
178 | | |
179 | 1.00M | if (cache) |
180 | 964k | code = pdfi_deref_loop_detect(ctx, r->ref_object_num, r->ref_generation_num, &o1); |
181 | 41.9k | else |
182 | 41.9k | code = pdfi_deref_loop_detect_nocache(ctx, r->ref_object_num, r->ref_generation_num, &o1); |
183 | 1.00M | if (code < 0) |
184 | 437k | return code; |
185 | | |
186 | 568k | if (setref) |
187 | 563k | (void)pdfi_array_put(ctx, a, index, o1); |
188 | 568k | obj = o1; |
189 | 345M | } else { |
190 | 345M | pdfi_countup(obj); |
191 | 345M | } |
192 | | |
193 | 345M | *o = obj; |
194 | 345M | return 0; |
195 | 346M | } |
196 | | |
197 | | /* Get element from array without resolving PDF_INDIRECT dereferences. |
198 | | * It looks to me like some usages need to do the checking themselves to |
199 | | * avoid circular references? Can remove this if not really needed. |
200 | | */ |
201 | | int pdfi_array_get_no_deref(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o) |
202 | 776k | { |
203 | 776k | if (pdfi_type_of(a) != PDF_ARRAY) |
204 | 0 | return_error(gs_error_typecheck); |
205 | | |
206 | 776k | if (index >= a->size) |
207 | 0 | return_error(gs_error_rangecheck); |
208 | | |
209 | 776k | *o = a->values[index]; |
210 | 776k | pdfi_countup(*o); |
211 | 776k | return 0; |
212 | 776k | } |
213 | | |
214 | | /* Same as pdfi_array_get() but doesn't replace indirect ref with a new object. |
215 | | */ |
216 | | int pdfi_array_get_no_store_R(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj **o) |
217 | 677k | { |
218 | 677k | int code; |
219 | | |
220 | 677k | code = pdfi_array_fetch(ctx, a, index, o, false, false); |
221 | 677k | if (code < 0) return code; |
222 | | |
223 | 674k | return 0; |
224 | 677k | } |
225 | | |
226 | | /* Get value from pdfi_array. |
227 | | * Handles type-checking and resolving indirect references. |
228 | | */ |
229 | | int pdfi_array_get_type(pdf_context *ctx, pdf_array *a, uint64_t index, |
230 | | pdf_obj_type type, pdf_obj **o) |
231 | 96.0M | { |
232 | 96.0M | int code; |
233 | | |
234 | 96.0M | code = pdfi_array_get(ctx, a, index, o); |
235 | 96.0M | if (code < 0) |
236 | 218k | return code; |
237 | | |
238 | 95.7M | if (pdfi_type_of(*o) != type) { |
239 | 21.3k | pdfi_countdown(*o); |
240 | 21.3k | *o = NULL; |
241 | 21.3k | return_error(gs_error_typecheck); |
242 | 21.3k | } |
243 | 95.7M | return 0; |
244 | 95.7M | } |
245 | | |
246 | | int pdfi_array_get_int(pdf_context *ctx, pdf_array *a, uint64_t index, int64_t *i) |
247 | 77.0k | { |
248 | 77.0k | int code; |
249 | 77.0k | pdf_obj *n; |
250 | | |
251 | 77.0k | code = pdfi_array_get(ctx, a, index, &n); |
252 | 77.0k | if (code < 0) |
253 | 64 | return code; |
254 | 77.0k | code = pdfi_obj_to_int(ctx, n, i); |
255 | 77.0k | pdfi_countdown(n); |
256 | 77.0k | return code; |
257 | 77.0k | } |
258 | | |
259 | | int pdfi_array_get_number(pdf_context *ctx, pdf_array *a, uint64_t index, double *d) |
260 | 19.7M | { |
261 | 19.7M | int code; |
262 | 19.7M | pdf_obj *n; |
263 | | |
264 | 19.7M | code = pdfi_array_get(ctx, a, index, &n); |
265 | 19.7M | if (code < 0) |
266 | 63 | return code; |
267 | | |
268 | 19.7M | code = pdfi_obj_to_real(ctx, n, d); |
269 | 19.7M | pdfi_countdown(n); |
270 | | |
271 | 19.7M | return code; |
272 | 19.7M | } |
273 | | |
274 | | /* Check whether a particular object is in an array. |
275 | | * If index is not NULL, fill it in with the index of the object. |
276 | | * Note that this will resolve indirect references if needed. |
277 | | */ |
278 | | bool pdfi_array_known(pdf_context *ctx, pdf_array *a, pdf_obj *o, int *index) |
279 | 64.0k | { |
280 | 64.0k | int i; |
281 | | |
282 | 64.0k | if (pdfi_type_of(a) != PDF_ARRAY) |
283 | 0 | return_error(gs_error_typecheck); |
284 | | |
285 | 28.5M | for (i=0; i < a->size; i++) { |
286 | 28.5M | pdf_obj *val; |
287 | 28.5M | int code; |
288 | | |
289 | 28.5M | code = pdfi_array_fetch(ctx, a, i, &val, true, true); |
290 | 28.5M | if (code < 0) |
291 | 195k | continue; |
292 | 28.3M | if (pdf_object_num(val) == pdf_object_num(o)) { |
293 | 61.9k | if (index != NULL) *index = i; |
294 | 61.9k | pdfi_countdown(val); |
295 | 61.9k | return true; |
296 | 61.9k | } |
297 | 28.2M | pdfi_countdown(val); |
298 | 28.2M | } |
299 | 2.14k | return false; |
300 | 64.0k | } |
301 | | |
302 | | int pdfi_array_put(pdf_context *ctx, pdf_array *a, uint64_t index, pdf_obj *o) |
303 | 152M | { |
304 | 152M | if (pdfi_type_of(a) != PDF_ARRAY) |
305 | 0 | return_error(gs_error_typecheck); |
306 | | |
307 | 152M | if (index >= a->size) |
308 | 0 | return_error(gs_error_rangecheck); |
309 | | |
310 | 152M | pdfi_countdown(a->values[index]); |
311 | 152M | a->values[index] = o; |
312 | 152M | pdfi_countup(o); |
313 | 152M | return 0; |
314 | 152M | } |
315 | | |
316 | | int pdfi_array_put_int(pdf_context *ctx, pdf_array *a, uint64_t index, int64_t val) |
317 | 9 | { |
318 | 9 | int code; |
319 | 9 | pdf_num *obj; |
320 | | |
321 | 9 | if (pdfi_type_of(a) != PDF_ARRAY) |
322 | 0 | return_error(gs_error_typecheck); |
323 | | |
324 | 9 | code = pdfi_object_alloc(ctx, PDF_INT, 0, (pdf_obj **)&obj); |
325 | 9 | if (code < 0) |
326 | 0 | return code; |
327 | 9 | obj->value.i = val; |
328 | | |
329 | 9 | return pdfi_array_put(ctx, a, index, (pdf_obj *)obj); |
330 | 9 | } |
331 | | |
332 | | int pdfi_array_put_real(pdf_context *ctx, pdf_array *a, uint64_t index, double val) |
333 | 3.93k | { |
334 | 3.93k | int code; |
335 | 3.93k | pdf_num *obj; |
336 | | |
337 | 3.93k | if (pdfi_type_of(a) != PDF_ARRAY) |
338 | 0 | return_error(gs_error_typecheck); |
339 | | |
340 | 3.93k | code = pdfi_object_alloc(ctx, PDF_REAL, 0, (pdf_obj **)&obj); |
341 | 3.93k | if (code < 0) |
342 | 0 | return code; |
343 | 3.93k | obj->value.d = val; |
344 | | |
345 | 3.93k | return pdfi_array_put(ctx, a, index, (pdf_obj *)obj); |
346 | 3.93k | } |
347 | | |
348 | | /* Strictly speaking the normalize_rect isn't really part of the PDF array |
349 | | * processing, but its very likely that any time we want to use it, the |
350 | | * rectangle will have come from a PDF array in a PDF file so it makes |
351 | | * sense to have it here. |
352 | | */ |
353 | | |
354 | | /* Normalize rectangle */ |
355 | | void pdfi_normalize_rect(pdf_context *ctx, gs_rect *rect) |
356 | 256k | { |
357 | 256k | double temp; |
358 | | |
359 | | /* Normalize the rectangle */ |
360 | 256k | if (rect->p.x > rect->q.x) { |
361 | 1.77k | temp = rect->p.x; |
362 | 1.77k | rect->p.x = rect->q.x; |
363 | 1.77k | rect->q.x = temp; |
364 | 1.77k | } |
365 | 256k | if (rect->p.y > rect->q.y) { |
366 | 243 | temp = rect->p.y; |
367 | 243 | rect->p.y = rect->q.y; |
368 | 243 | rect->q.y = temp; |
369 | 243 | } |
370 | 256k | } |
371 | | |
372 | | /* |
373 | | * Turn an Array into a gs_rect. If Array is NULL, makes a tiny rect |
374 | | */ |
375 | | int pdfi_array_to_gs_rect(pdf_context *ctx, pdf_array *array, gs_rect *rect) |
376 | 614k | { |
377 | 614k | double number; |
378 | 614k | int code = 0; |
379 | | |
380 | | /* Init to tiny rect to allow sane continuation on errors */ |
381 | 614k | rect->p.x = 0.0; |
382 | 614k | rect->p.y = 0.0; |
383 | 614k | rect->q.x = 1.0; |
384 | 614k | rect->q.y = 1.0; |
385 | | |
386 | | /* Identity matrix if no array */ |
387 | 614k | if (array == NULL || pdfi_type_of(array) != PDF_ARRAY) { |
388 | 3.67k | return 0; |
389 | 3.67k | } |
390 | 611k | if (pdfi_array_size(array) != 4) { |
391 | 458 | return_error(gs_error_rangecheck); |
392 | 458 | } |
393 | 610k | code = pdfi_array_get_number(ctx, array, 0, &number); |
394 | 610k | if (code < 0) goto errorExit; |
395 | 610k | rect->p.x = (float)number; |
396 | 610k | code = pdfi_array_get_number(ctx, array, 1, &number); |
397 | 610k | if (code < 0) goto errorExit; |
398 | 610k | rect->p.y = (float)number; |
399 | 610k | code = pdfi_array_get_number(ctx, array, 2, &number); |
400 | 610k | if (code < 0) goto errorExit; |
401 | 610k | rect->q.x = (float)number; |
402 | 610k | code = pdfi_array_get_number(ctx, array, 3, &number); |
403 | 610k | if (code < 0) goto errorExit; |
404 | 610k | rect->q.y = (float)number; |
405 | | |
406 | 610k | return 0; |
407 | | |
408 | 86 | errorExit: |
409 | 86 | return code; |
410 | 610k | } |
411 | | |
412 | | /* Create a new PDF array object with 4 entires, and store the values from a |
413 | | * gs_rect to it. |
414 | | */ |
415 | | int pdfi_gs_rect_to_array(pdf_context *ctx, gs_rect *rect, pdf_array **new_array) |
416 | 2.24k | { |
417 | 2.24k | pdf_num *num = NULL; |
418 | 2.24k | int code = 0; |
419 | | |
420 | 2.24k | code = pdfi_array_alloc(ctx, 4, new_array); |
421 | 2.24k | if (code < 0) |
422 | 0 | return code; |
423 | | |
424 | 2.24k | pdfi_countup(*new_array); |
425 | | |
426 | 2.24k | code = pdfi_num_alloc(ctx, rect->p.x, &num); |
427 | 2.24k | if (code < 0) |
428 | 0 | goto error; |
429 | | |
430 | 2.24k | code = pdfi_array_put(ctx, *new_array, 0, (pdf_obj *)num); |
431 | 2.24k | if (code < 0) |
432 | 0 | goto error; |
433 | | |
434 | 2.24k | code = pdfi_num_alloc(ctx, rect->p.y, &num); |
435 | 2.24k | if (code < 0) |
436 | 0 | goto error; |
437 | | |
438 | 2.24k | code = pdfi_array_put(ctx, *new_array, 1, (pdf_obj *)num); |
439 | 2.24k | if (code < 0) |
440 | 0 | goto error; |
441 | | |
442 | 2.24k | code = pdfi_num_alloc(ctx, rect->q.x, &num); |
443 | 2.24k | if (code < 0) |
444 | 0 | goto error; |
445 | | |
446 | 2.24k | code = pdfi_array_put(ctx, *new_array, 2, (pdf_obj *)num); |
447 | 2.24k | if (code < 0) |
448 | 0 | goto error; |
449 | | |
450 | 2.24k | code = pdfi_num_alloc(ctx, rect->q.y, &num); |
451 | 2.24k | if (code < 0) |
452 | 0 | goto error; |
453 | | |
454 | 2.24k | code = pdfi_array_put(ctx, *new_array, 3, (pdf_obj *)num); |
455 | 2.24k | if (code < 0) |
456 | 0 | goto error; |
457 | | |
458 | 2.24k | return 0; |
459 | | |
460 | 0 | error: |
461 | 0 | pdfi_countdown(new_array); |
462 | 0 | return code; |
463 | 2.24k | } |
464 | | |
465 | | /* Turn a /Matrix Array into a gs_matrix. If Array is NULL, makes an identity matrix */ |
466 | | int pdfi_array_to_gs_matrix(pdf_context *ctx, pdf_array *array, gs_matrix *mat) |
467 | 376k | { |
468 | 376k | double number; |
469 | 376k | int code = 0; |
470 | | |
471 | | /* Init to identity matrix to allow sane continuation on errors */ |
472 | 376k | mat->xx = 1.0; |
473 | 376k | mat->xy = 0.0; |
474 | 376k | mat->yx = 0.0; |
475 | 376k | mat->yy = 1.0; |
476 | 376k | mat->tx = 0.0; |
477 | 376k | mat->ty = 0.0; |
478 | | |
479 | | /* Identity matrix if no array */ |
480 | 376k | if (array == NULL || pdfi_type_of(array) != PDF_ARRAY) { |
481 | 224k | return 0; |
482 | 224k | } |
483 | 151k | if (pdfi_array_size(array) != 6) { |
484 | 190 | return_error(gs_error_rangecheck); |
485 | 190 | } |
486 | 151k | code = pdfi_array_get_number(ctx, array, 0, &number); |
487 | 151k | if (code < 0) goto errorExit; |
488 | 151k | mat->xx = (float)number; |
489 | 151k | code = pdfi_array_get_number(ctx, array, 1, &number); |
490 | 151k | if (code < 0) goto errorExit; |
491 | 151k | mat->xy = (float)number; |
492 | 151k | code = pdfi_array_get_number(ctx, array, 2, &number); |
493 | 151k | if (code < 0) goto errorExit; |
494 | 151k | mat->yx = (float)number; |
495 | 151k | code = pdfi_array_get_number(ctx, array, 3, &number); |
496 | 151k | if (code < 0) goto errorExit; |
497 | 151k | mat->yy = (float)number; |
498 | 151k | code = pdfi_array_get_number(ctx, array, 4, &number); |
499 | 151k | if (code < 0) goto errorExit; |
500 | 151k | mat->tx = (float)number; |
501 | 151k | code = pdfi_array_get_number(ctx, array, 5, &number); |
502 | 151k | if (code < 0) goto errorExit; |
503 | 151k | mat->ty = (float)number; |
504 | 151k | return 0; |
505 | | |
506 | 33 | errorExit: |
507 | 33 | return code; |
508 | 151k | } |
509 | | |
510 | | /* Turn a pdf_array into a double array of specified size */ |
511 | | int pdfi_array_to_num_array(pdf_context *ctx, pdf_array *array, double *out, int offset, int size) |
512 | 19.6k | { |
513 | 19.6k | int i; |
514 | 19.6k | int code; |
515 | 19.6k | double num; |
516 | | |
517 | 142k | for (i=0; i<size; i++) { |
518 | 122k | code = pdfi_array_get_number(ctx, array, offset+i, &num); |
519 | 122k | if (code < 0) |
520 | 101 | return code; |
521 | 122k | out[i] = num; |
522 | 122k | } |
523 | 19.5k | return 0; |
524 | 19.6k | } |
525 | | |
526 | | /* Transform a BBox by a matrix (from zmatrix.c/zbbox_transform())*/ |
527 | | void |
528 | | pdfi_bbox_transform(pdf_context *ctx, gs_rect *bbox, gs_matrix *matrix) |
529 | 131k | { |
530 | 131k | gs_point aa, az, za, zz; |
531 | 131k | double temp; |
532 | | |
533 | 131k | gs_point_transform(bbox->p.x, bbox->p.y, matrix, &aa); |
534 | 131k | gs_point_transform(bbox->p.x, bbox->q.y, matrix, &az); |
535 | 131k | gs_point_transform(bbox->q.x, bbox->p.y, matrix, &za); |
536 | 131k | gs_point_transform(bbox->q.x, bbox->q.y, matrix, &zz); |
537 | | |
538 | 131k | if ( aa.x > az.x) |
539 | 1.52k | temp = aa.x, aa.x = az.x, az.x = temp; |
540 | 131k | if ( za.x > zz.x) |
541 | 1.52k | temp = za.x, za.x = zz.x, zz.x = temp; |
542 | 131k | if ( za.x < aa.x) |
543 | 69 | aa.x = za.x; /* min */ |
544 | 131k | if ( az.x > zz.x) |
545 | 69 | zz.x = az.x; /* max */ |
546 | | |
547 | 131k | if ( aa.y > az.y) |
548 | 3.25k | temp = aa.y, aa.y = az.y, az.y = temp; |
549 | 131k | if ( za.y > zz.y) |
550 | 3.25k | temp = za.y, za.y = zz.y, zz.y = temp; |
551 | 131k | if ( za.y < aa.y) |
552 | 73 | aa.y = za.y; /* min */ |
553 | 131k | if ( az.y > zz.y) |
554 | 73 | zz.y = az.y; /* max */ |
555 | | |
556 | 131k | bbox->p.x = aa.x; |
557 | 131k | bbox->p.y = aa.y; |
558 | 131k | bbox->q.x = zz.x; |
559 | 131k | bbox->q.y = zz.y; |
560 | 131k | } |