Mercurial > hgrepos > Python2 > PyMuPDF

comparison mupdf-source/thirdparty/jbig2dec/jbig2_halftone.c @ 2:b50eed0cc0ef upstream

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
ADD: MuPDF v1.26.7: the MuPDF source as downloaded by a default build of PyMuPDF 1.26.4. The directory name has changed: no version number in the expanded directory now.
author Franz Glasner <fzglas.hg@dom66.de>
date Mon, 15 Sep 2025 11:43:07 +0200
parents
children
comparison
equal deleted inserted replaced
1:1d09e1dec1d9 2:b50eed0cc0ef
1 /* Copyright (C) 2001-2023 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 /*
17 jbig2dec
18 */
19
20 /* JBIG2 Pattern Dictionary and Halftone Region decoding */
21
22 #ifdef HAVE_CONFIG_H
23 #include "config.h"
24 #endif
25 #include "os_types.h"
26
27 #include <string.h> /* memset() */
28
29 #include "jbig2.h"
30 #include "jbig2_priv.h"
31 #include "jbig2_arith.h"
32 #include "jbig2_generic.h"
33 #include "jbig2_image.h"
34 #include "jbig2_halftone.h"
35 #include "jbig2_mmr.h"
36 #include "jbig2_page.h"
37 #include "jbig2_segment.h"
38
39 /**
40 * jbig2_hd_new: create a new dictionary from a collective bitmap
41 */
42 static Jbig2PatternDict *
43 jbig2_hd_new(Jbig2Ctx *ctx, const Jbig2PatternDictParams *params, Jbig2Image *image)
44 {
45 Jbig2PatternDict *new;
46 const uint32_t N = params->GRAYMAX + 1;
47 const uint32_t HPW = params->HDPW;
48 const uint32_t HPH = params->HDPH;
49 int code;
50 uint32_t i, j;
51
52 if (N == 0) {
53 /* We've wrapped. */
54 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, JBIG2_UNKNOWN_SEGMENT_NUMBER, "params->GRAYMAX out of range");
55 return NULL;
56 }
57
58 /* allocate a new struct */
59 new = jbig2_new(ctx, Jbig2PatternDict, 1);
60 if (new != NULL) {
61 new->patterns = jbig2_new(ctx, Jbig2Image *, N);
62 if (new->patterns == NULL) {
63 jbig2_error(ctx, JBIG2_SEVERITY_FATAL, JBIG2_UNKNOWN_SEGMENT_NUMBER, "failed to allocate pattern in collective bitmap dictionary");
64 jbig2_free(ctx->allocator, new);
65 return NULL;
66 }
67 new->n_patterns = N;
68 new->HPW = HPW;
69 new->HPH = HPH;
70
71 /* 6.7.5(4) - copy out the individual pattern images */
72 for (i = 0; i < N; i++) {
73 new->patterns[i] = jbig2_image_new(ctx, HPW, HPH);
74 if (new->patterns[i] == NULL) {
75 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, JBIG2_UNKNOWN_SEGMENT_NUMBER, "failed to allocate pattern element image");
76 /* new->patterns[i] above did not succeed, so releasing patterns 0..i-1 is enough */
77 for (j = 0; j < i; j++)
78 jbig2_image_release(ctx, new->patterns[j]);
79 jbig2_free(ctx->allocator, new->patterns);
80 jbig2_free(ctx->allocator, new);
81 return NULL;
82 }
83 /* compose with the REPLACE operator; the source
84 will be clipped to the destination, selecting the
85 proper sub image */
86 code = jbig2_image_compose(ctx, new->patterns[i], image, -i * (int32_t) HPW, 0, JBIG2_COMPOSE_REPLACE);
87 if (code < 0) {
88 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, JBIG2_UNKNOWN_SEGMENT_NUMBER, "failed to compose image into collective bitmap dictionary");
89 /* new->patterns[i] above succeeded, so release all patterns 0..i */
90 for (j = 0; j <= i; j++)
91 jbig2_image_release(ctx, new->patterns[j]);
92 jbig2_free(ctx->allocator, new->patterns);
93 jbig2_free(ctx->allocator, new);
94 return NULL;
95 }
96 }
97 } else {
98 jbig2_error(ctx, JBIG2_SEVERITY_FATAL, JBIG2_UNKNOWN_SEGMENT_NUMBER, "failed to allocate collective bitmap dictionary");
99 }
100
101 return new;
102 }
103
104 /**
105 * jbig2_hd_release: release a pattern dictionary
106 */
107 void
108 jbig2_hd_release(Jbig2Ctx *ctx, Jbig2PatternDict *dict)
109 {
110 int i;
111
112 if (dict == NULL)
113 return;
114 if (dict->patterns != NULL)
115 for (i = 0; i < dict->n_patterns; i++)
116 jbig2_image_release(ctx, dict->patterns[i]);
117 jbig2_free(ctx->allocator, dict->patterns);
118 jbig2_free(ctx->allocator, dict);
119 }
120
121 /**
122 * jbig2_decode_pattern_dict: decode pattern dictionary data
123 *
124 * @ctx: jbig2 decoder context
125 * @segment: jbig2 segment (header) structure
126 * @params: parameters from the pattern dictionary header
127 * @data: pointer to text region data to be decoded
128 * @size: length of text region data
129 * @GB_stats: arithmetic coding context to use
130 *
131 * Implements the pattern dictionary decoding procedure
132 * described in section 6.7 of the JBIG2 spec.
133 *
134 * returns: a pointer to the resulting dictionary on success
135 * returns: 0 on failure
136 **/
137 static Jbig2PatternDict *
138 jbig2_decode_pattern_dict(Jbig2Ctx *ctx, Jbig2Segment *segment,
139 const Jbig2PatternDictParams *params, const byte *data, const size_t size, Jbig2ArithCx *GB_stats)
140 {
141 Jbig2PatternDict *hd = NULL;
142 Jbig2Image *image = NULL;
143 Jbig2GenericRegionParams rparams;
144 int code = 0;
145
146 /* allocate the collective image */
147 image = jbig2_image_new(ctx, params->HDPW * (params->GRAYMAX + 1), params->HDPH);
148 if (image == NULL) {
149 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate collective bitmap for halftone dictionary");
150 return NULL;
151 }
152
153 /* fill out the generic region decoder parameters */
154 rparams.MMR = params->HDMMR;
155 rparams.GBTEMPLATE = params->HDTEMPLATE;
156 rparams.TPGDON = 0; /* not used if HDMMR = 1 */
157 rparams.USESKIP = 0;
158 rparams.gbat[0] = -(int8_t) params->HDPW;
159 rparams.gbat[1] = 0;
160 rparams.gbat[2] = -3;
161 rparams.gbat[3] = -1;
162 rparams.gbat[4] = 2;
163 rparams.gbat[5] = -2;
164 rparams.gbat[6] = -2;
165 rparams.gbat[7] = -2;
166
167 if (params->HDMMR) {
168 code = jbig2_decode_generic_mmr(ctx, segment, &rparams, data, size, image);
169 } else {
170 Jbig2WordStream *ws = jbig2_word_stream_buf_new(ctx, data, size);
171
172 if (ws != NULL) {
173 Jbig2ArithState *as = jbig2_arith_new(ctx, ws);
174
175 if (as != NULL) {
176 code = jbig2_decode_generic_region(ctx, segment, &rparams, as, image, GB_stats);
177 } else {
178 code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate arithmetic coding state when handling halftone dictionary");
179 }
180
181 jbig2_free(ctx->allocator, as);
182 jbig2_word_stream_buf_free(ctx, ws);
183 } else {
184 code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate word stream when handling halftone dictionary");
185 }
186 }
187
188 if (code == 0)
189 hd = jbig2_hd_new(ctx, params, image);
190 else
191 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to decode immediate generic region");
192 jbig2_image_release(ctx, image);
193
194 return hd;
195 }
196
197 /* 7.4.4 */
198 int
199 jbig2_pattern_dictionary(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data)
200 {
201 Jbig2PatternDictParams params;
202 Jbig2ArithCx *GB_stats = NULL;
203 byte flags;
204 int offset = 0;
205
206 /* 7.4.4.1 - Data header */
207 if (segment->data_length < 7) {
208 return jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "segment too short");
209 }
210 flags = segment_data[0];
211 params.HDMMR = flags & 1;
212 params.HDTEMPLATE = (flags & 6) >> 1;
213 params.HDPW = segment_data[1];
214 params.HDPH = segment_data[2];
215 params.GRAYMAX = jbig2_get_uint32(segment_data + 3);
216 offset += 7;
217
218 jbig2_error(ctx, JBIG2_SEVERITY_INFO, segment->number,
219 "pattern dictionary, flags=%02x, %d grays (%dx%d cell)", flags, params.GRAYMAX + 1, params.HDPW, params.HDPH);
220
221 if (params.HDMMR && params.HDTEMPLATE) {
222 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "HDTEMPLATE is %d when HDMMR is %d, contrary to spec", params.HDTEMPLATE, params.HDMMR);
223 }
224 if (flags & 0xf8) {
225 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "reserved flag bits non-zero");
226 }
227
228 /* 7.4.4.2 */
229 if (!params.HDMMR) {
230 /* allocate and zero arithmetic coding stats */
231 int stats_size = jbig2_generic_stats_size(ctx, params.HDTEMPLATE);
232
233 GB_stats = jbig2_new(ctx, Jbig2ArithCx, stats_size);
234 if (GB_stats == NULL)
235 return jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate arithmetic coding state when handling pattern dictionary");
236 memset(GB_stats, 0, stats_size);
237 }
238
239 segment->result = jbig2_decode_pattern_dict(ctx, segment, &params, segment_data + offset, segment->data_length - offset, GB_stats);
240
241 /* todo: retain GB_stats? */
242 if (!params.HDMMR) {
243 jbig2_free(ctx->allocator, GB_stats);
244 }
245
246 return (segment->result != NULL) ? 0 : -1;
247 }
248
249 /**
250 * jbig2_decode_gray_scale_image: decode gray-scale image
251 *
252 * @ctx: jbig2 decoder context
253 * @segment: jbig2 segment (header) structure
254 * @data: pointer to text region data to be decoded
255 * @size: length of text region data
256 * @GSMMR: if MMR is used
257 * @GSW: width of gray-scale image
258 * @GSH: height of gray-scale image
259 * @GSBPP: number of bitplanes/Jbig2Images to use
260 * @GSKIP: mask indicating which values should be skipped
261 * @GSTEMPLATE: template used to code the gray-scale bitplanes
262 * @GB_stats: arithmetic coding context to use
263 *
264 * Implements the decoding a gray-scale image described in
265 * annex C.5. This is part of the halftone region decoding.
266 *
267 * returns: array of gray-scale values with GSW x GSH width/height
268 * 0 on failure
269 **/
270 static uint16_t **
271 jbig2_decode_gray_scale_image(Jbig2Ctx *ctx, Jbig2Segment *segment,
272 const byte *data, const size_t size,
273 bool GSMMR, uint32_t GSW, uint32_t GSH,
274 uint32_t GSBPP, bool GSUSESKIP, Jbig2Image *GSKIP, int GSTEMPLATE, Jbig2ArithCx *GB_stats)
275 {
276 uint16_t **GSVALS = NULL;
277 size_t consumed_bytes = 0;
278 uint32_t i, j, stride, x, y;
279 int code;
280 Jbig2Image **GSPLANES;
281 Jbig2GenericRegionParams rparams;
282 Jbig2WordStream *ws = NULL;
283 Jbig2ArithState *as = NULL;
284
285 /* allocate GSPLANES */
286 GSPLANES = jbig2_new(ctx, Jbig2Image *, GSBPP);
287 if (GSPLANES == NULL) {
288 jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate %d bytes for GSPLANES", GSBPP);
289 return NULL;
290 }
291
292 for (i = 0; i < GSBPP; ++i) {
293 GSPLANES[i] = jbig2_image_new(ctx, GSW, GSH);
294 if (GSPLANES[i] == NULL) {
295 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate %dx%d image for GSPLANES", GSW, GSH);
296 /* free already allocated */
297 for (j = i; j > 0;)
298 jbig2_image_release(ctx, GSPLANES[--j]);
299 jbig2_free(ctx->allocator, GSPLANES);
300 return NULL;
301 }
302 }
303
304 /* C.5 step 1. Decode GSPLANES[GSBPP-1] */
305 /* fill generic region decoder parameters */
306 rparams.MMR = GSMMR;
307 rparams.GBTEMPLATE = GSTEMPLATE;
308 rparams.TPGDON = 0;
309 rparams.USESKIP = GSUSESKIP;
310 rparams.SKIP = GSKIP;
311 rparams.gbat[0] = (GSTEMPLATE <= 1 ? 3 : 2);
312 rparams.gbat[1] = -1;
313 rparams.gbat[2] = -3;
314 rparams.gbat[3] = -1;
315 rparams.gbat[4] = 2;
316 rparams.gbat[5] = -2;
317 rparams.gbat[6] = -2;
318 rparams.gbat[7] = -2;
319
320 if (GSMMR) {
321 code = jbig2_decode_halftone_mmr(ctx, &rparams, data, size, GSPLANES[GSBPP - 1], &consumed_bytes);
322 } else {
323 ws = jbig2_word_stream_buf_new(ctx, data, size);
324 if (ws == NULL) {
325 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate word stream when decoding gray scale image");
326 goto cleanup;
327 }
328
329 as = jbig2_arith_new(ctx, ws);
330 if (as == NULL) {
331 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate arithmetic coding state when decoding gray scale image");
332 goto cleanup;
333 }
334
335 code = jbig2_decode_generic_region(ctx, segment, &rparams, as, GSPLANES[GSBPP - 1], GB_stats);
336 }
337 if (code < 0) {
338 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "error decoding GSPLANES for halftone image");
339 goto cleanup;
340 }
341
342 /* C.5 step 2. Set j = GSBPP-2 */
343 j = GSBPP - 1;
344 /* C.5 step 3. decode loop */
345 while (j > 0) {
346 j--;
347 /* C.5 step 3. (a) */
348 if (GSMMR) {
349 code = jbig2_decode_halftone_mmr(ctx, &rparams, data + consumed_bytes, size - consumed_bytes, GSPLANES[j], &consumed_bytes);
350 } else {
351 code = jbig2_decode_generic_region(ctx, segment, &rparams, as, GSPLANES[j], GB_stats);
352 }
353 if (code < 0) {
354 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to decode GSPLANES for halftone image");
355 goto cleanup;
356 }
357
358 /* C.5 step 3. (b):
359 * for each [x,y]
360 * GSPLANES[j][x][y] = GSPLANES[j+1][x][y] XOR GSPLANES[j][x][y] */
361 stride = GSPLANES[j]->stride;
362 for (i = 0; i < stride * GSH; ++i)
363 GSPLANES[j]->data[i] ^= GSPLANES[j + 1]->data[i];
364
365 /* C.5 step 3. (c) */
366 }
367
368 /* allocate GSVALS */
369 GSVALS = jbig2_new(ctx, uint16_t *, GSW);
370 if (GSVALS == NULL) {
371 jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate GSVALS: %d bytes", GSW);
372 goto cleanup;
373 }
374 for (i = 0; i < GSW; ++i) {
375 GSVALS[i] = jbig2_new(ctx, uint16_t, GSH);
376 if (GSVALS[i] == NULL) {
377 jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate GSVALS: %d bytes", GSH * GSW);
378 /* free already allocated */
379 for (j = i; j > 0;)
380 jbig2_free(ctx->allocator, GSVALS[--j]);
381 jbig2_free(ctx->allocator, GSVALS);
382 GSVALS = NULL;
383 goto cleanup;
384 }
385 }
386
387 /* C.5 step 4. */
388 for (x = 0; x < GSW; ++x) {
389 for (y = 0; y < GSH; ++y) {
390 GSVALS[x][y] = 0;
391
392 for (j = 0; j < GSBPP; ++j)
393 GSVALS[x][y] += jbig2_image_get_pixel(GSPLANES[j], x, y) << j;
394 }
395 }
396
397 cleanup:
398 /* free memory */
399 if (!GSMMR) {
400 jbig2_free(ctx->allocator, as);
401 jbig2_word_stream_buf_free(ctx, ws);
402 }
403 for (i = 0; i < GSBPP; ++i)
404 jbig2_image_release(ctx, GSPLANES[i]);
405
406 jbig2_free(ctx->allocator, GSPLANES);
407
408 return GSVALS;
409 }
410
411 /**
412 * jbig2_decode_ht_region_get_hpats: get pattern dictionary
413 *
414 * @ctx: jbig2 decoder context
415 * @segment: jbig2 halftone region segment
416 *
417 * Returns the first referred pattern dictionary of segment
418 *
419 * returns: pattern dictionary
420 * 0 if search failed
421 **/
422 static Jbig2PatternDict *
423 jbig2_decode_ht_region_get_hpats(Jbig2Ctx *ctx, Jbig2Segment *segment)
424 {
425 int index = 0;
426 Jbig2PatternDict *pattern_dict = NULL;
427 Jbig2Segment *rsegment = NULL;
428
429 /* loop through all referred segments */
430 while (!pattern_dict && segment->referred_to_segment_count > index) {
431 rsegment = jbig2_find_segment(ctx, segment->referred_to_segments[index]);
432 if (rsegment) {
433 /* segment type is pattern dictionary and result is not empty */
434 if ((rsegment->flags & 0x3f) == 16 && rsegment->result) {
435 pattern_dict = (Jbig2PatternDict *) rsegment->result;
436 return pattern_dict;
437 }
438 }
439 index++;
440 }
441 return pattern_dict;
442 }
443
444 /**
445 * jbig2_decode_halftone_region: decode a halftone region
446 *
447 * @ctx: jbig2 decoder context
448 * @segment: jbig2 halftone region segment
449 * @params: parameters
450 * @data: pointer to halftone region data to be decoded
451 * @size: length of halftone region data
452 * @GB_stats: arithmetic coding context to use
453 *
454 * Implements the halftone region decoding procedure
455 * described in section 6.6.5 of the JBIG2 spec.
456 *
457 * returns: 0 on success
458 * <0 on failure
459 **/
460 static int
461 jbig2_decode_halftone_region(Jbig2Ctx *ctx, Jbig2Segment *segment,
462 Jbig2HalftoneRegionParams *params, const byte *data, const size_t size, Jbig2Image *image, Jbig2ArithCx *GB_stats)
463 {
464 uint32_t HBPP;
465 uint32_t HNUMPATS;
466 uint16_t **GI = NULL;
467 Jbig2Image *HSKIP = NULL;
468 Jbig2PatternDict *HPATS;
469 uint32_t i;
470 uint32_t mg, ng;
471 uint16_t gray_val;
472 int code = 0;
473
474 /* We need the patterns used in this region, get them from the referred pattern dictionary */
475 HPATS = jbig2_decode_ht_region_get_hpats(ctx, segment);
476 if (!HPATS) {
477 code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "no pattern dictionary found, skipping halftone image");
478 goto cleanup;
479 }
480
481 /* 6.6.5 point 1. Fill bitmap with HDEFPIXEL */
482 memset(image->data, params->HDEFPIXEL, image->stride * image->height);
483
484 /* 6.6.5 point 2. compute HSKIP according to 6.6.5.1 */
485 if (params->HENABLESKIP == 1) {
486 HSKIP = jbig2_image_new(ctx, params->HGW, params->HGH);
487 if (HSKIP == NULL)
488 return jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate skip image");
489
490 for (mg = 0; mg < params->HGH; ++mg) {
491 for (ng = 0; ng < params->HGW; ++ng) {
492 int64_t x = ((int64_t) params->HGX + mg * params->HRY + ng * params->HRX) >> 8;
493 int64_t y = ((int64_t) params->HGY + mg * params->HRX - ng * params->HRY) >> 8;
494
495 if (x + HPATS->HPW <= 0 || x >= image->width || y + HPATS->HPH <= 0 || y >= image->height) {
496 jbig2_image_set_pixel(HSKIP, ng, mg, 1);
497 } else {
498 jbig2_image_set_pixel(HSKIP, ng, mg, 0);
499 }
500 }
501 }
502 }
503
504 /* 6.6.5 point 3. set HBPP to ceil(log2(HNUMPATS)): */
505 HNUMPATS = HPATS->n_patterns;
506 HBPP = 0;
507 while (HNUMPATS > (1U << ++HBPP));
508 if (HBPP > 16) {
509 code = jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "HBPP is larger than supported (%u)", HBPP);
510 goto cleanup;
511 }
512
513 /* 6.6.5 point 4. decode gray-scale image as mentioned in annex C */
514 GI = jbig2_decode_gray_scale_image(ctx, segment, data, size,
515 params->HMMR, params->HGW, params->HGH, HBPP, params->HENABLESKIP, HSKIP, params->HTEMPLATE, GB_stats);
516 if (!GI) {
517 code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "unable to acquire gray-scale image, skipping halftone image");
518 goto cleanup;
519 }
520
521 /* 6.6.5 point 5. place patterns with procedure mentioned in 6.6.5.2 */
522 for (mg = 0; mg < params->HGH; ++mg) {
523 for (ng = 0; ng < params->HGW; ++ng) {
524 int64_t x = ((int64_t) params->HGX + mg * params->HRY + ng * params->HRX) >> 8;
525 int64_t y = ((int64_t) params->HGY + mg * params->HRX - ng * params->HRY) >> 8;
526
527 /* prevent pattern index >= HNUMPATS */
528 gray_val = GI[ng][mg];
529 if (gray_val >= HNUMPATS) {
530 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "gray-scale index %d out of range, using largest index", gray_val);
531 /* use highest available pattern */
532 gray_val = HNUMPATS - 1;
533 }
534 code = jbig2_image_compose(ctx, image, HPATS->patterns[gray_val], x, y, params->HCOMBOP);
535 if (code < 0) {
536 code = jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to compose pattern with gray-scale image");
537 goto cleanup;
538 }
539 }
540 }
541
542 cleanup:
543 if (GI) {
544 for (i = 0; i < params->HGW; ++i) {
545 jbig2_free(ctx->allocator, GI[i]);
546 }
547 }
548 jbig2_free(ctx->allocator, GI);
549 jbig2_image_release(ctx, HSKIP);
550
551 return code;
552 }
553
554 /**
555 * jbig2_halftone_region: read a halftone region segment header
556 **/
557 int
558 jbig2_halftone_region(Jbig2Ctx *ctx, Jbig2Segment *segment, const byte *segment_data)
559 {
560 int offset = 0;
561 Jbig2RegionSegmentInfo region_info;
562 Jbig2HalftoneRegionParams params;
563 Jbig2Image *image = NULL;
564 Jbig2ArithCx *GB_stats = NULL;
565 int code = 0;
566
567 /* 7.4.5.1 */
568 if (segment->data_length < 17)
569 goto too_short;
570 jbig2_get_region_segment_info(&region_info, segment_data);
571 offset += 17;
572
573 if (segment->data_length < 18)
574 goto too_short;
575
576 /* 7.4.5.1.1 Figure 42 */
577 params.flags = segment_data[offset];
578 params.HMMR = params.flags & 1;
579 params.HTEMPLATE = (params.flags & 6) >> 1;
580 params.HENABLESKIP = (params.flags & 8) >> 3;
581 params.HCOMBOP = (Jbig2ComposeOp)((params.flags & 0x70) >> 4);
582 params.HDEFPIXEL = (params.flags & 0x80) >> 7;
583 offset += 1;
584
585 jbig2_error(ctx, JBIG2_SEVERITY_INFO, segment->number,
586 "halftone region: %u x %u @ (%u, %u), flags = %02x", region_info.width, region_info.height, region_info.x, region_info.y, params.flags);
587
588 if (params.HMMR && params.HTEMPLATE) {
589 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "HTEMPLATE is %d when HMMR is %d, contrary to spec", params.HTEMPLATE, params.HMMR);
590 }
591 if (params.HMMR && params.HENABLESKIP) {
592 jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "HENABLESKIP is %d when HMMR is %d, contrary to spec", params.HENABLESKIP, params.HMMR);
593 }
594
595 /* 7.4.5.1.2 Figure 43 */
596 if (segment->data_length - offset < 16)
597 goto too_short;
598 params.HGW = jbig2_get_uint32(segment_data + offset);
599 params.HGH = jbig2_get_uint32(segment_data + offset + 4);
600 params.HGX = jbig2_get_int32(segment_data + offset + 8);
601 params.HGY = jbig2_get_int32(segment_data + offset + 12);
602 offset += 16;
603
604 /* 7.4.5.1.3 Figure 44 */
605 if (segment->data_length - offset < 4)
606 goto too_short;
607 params.HRX = jbig2_get_uint16(segment_data + offset);
608 params.HRY = jbig2_get_uint16(segment_data + offset + 2);
609 offset += 4;
610
611 jbig2_error(ctx, JBIG2_SEVERITY_INFO, segment->number,
612 "grid %d x %d @ (%d.%d,%d.%d) vector (%d.%d,%d.%d)",
613 params.HGW, params.HGH,
614 params.HGX >> 8, params.HGX & 0xff,
615 params.HGY >> 8, params.HGY & 0xff,
616 params.HRX >> 8, params.HRX & 0xff,
617 params.HRY >> 8, params.HRY & 0xff);
618
619 /* 7.4.5.2 */
620 if (!params.HMMR) {
621 /* allocate and zero arithmetic coding stats */
622 int stats_size = jbig2_generic_stats_size(ctx, params.HTEMPLATE);
623
624 GB_stats = jbig2_new(ctx, Jbig2ArithCx, stats_size);
625 if (GB_stats == NULL) {
626 return jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "failed to allocate arithmetic decoder states in halftone region");
627 }
628 memset(GB_stats, 0, stats_size);
629 }
630
631 image = jbig2_image_new(ctx, region_info.width, region_info.height);
632 if (image == NULL) {
633 jbig2_free(ctx->allocator, GB_stats);
634 return jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to allocate halftone image");
635 }
636
637 code = jbig2_decode_halftone_region(ctx, segment, &params, segment_data + offset, segment->data_length - offset, image, GB_stats);
638 if (code < 0) {
639 jbig2_image_release(ctx, image);
640 jbig2_free(ctx->allocator, GB_stats);
641 return jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "failed to decode halftone region");
642 }
643
644 /* todo: retain GB_stats? */
645 if (!params.HMMR) {
646 jbig2_free(ctx->allocator, GB_stats);
647 }
648
649 code = jbig2_page_add_result(ctx, &ctx->pages[ctx->current_page], image, region_info.x, region_info.y, region_info.op);
650 if (code < 0) {
651 jbig2_image_release(ctx, image);
652 return jbig2_error(ctx, JBIG2_SEVERITY_WARNING, segment->number, "unable to add halftone region to page");
653 }
654
655 jbig2_image_release(ctx, image);
656
657 return code;
658
659 too_short:
660 return jbig2_error(ctx, JBIG2_SEVERITY_FATAL, segment->number, "segment too short");
661 }