path: root/libavcodec/jpeg2000dec.c (plain)
blob: e9f5f51af326f8dde50dae5b29361b3daf0376fc

1	/*
2	* JPEG 2000 image decoder
3	* Copyright (c) 2007 Kamil Nowosad
4	* Copyright (c) 2013 Nicolas Bertrand <nicoinattendu@gmail.com>
5	*
6	* This file is part of FFmpeg.
7	*
8	* FFmpeg is free software; you can redistribute it and/or
9	* modify it under the terms of the GNU Lesser General Public
10	* License as published by the Free Software Foundation; either
11	* version 2.1 of the License, or (at your option) any later version.
12	*
13	* FFmpeg is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16	* Lesser General Public License for more details.
17	*
18	* You should have received a copy of the GNU Lesser General Public
19	* License along with FFmpeg; if not, write to the Free Software
20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21	*/
22
23	/**
24	* @file
25	* JPEG 2000 image decoder
26	*/
27
28	#include <inttypes.h>
29
30	#include "libavutil/attributes.h"
31	#include "libavutil/avassert.h"
32	#include "libavutil/common.h"
33	#include "libavutil/imgutils.h"
34	#include "libavutil/opt.h"
35	#include "libavutil/pixdesc.h"
36	#include "avcodec.h"
37	#include "bytestream.h"
38	#include "internal.h"
39	#include "thread.h"
40	#include "jpeg2000.h"
41	#include "jpeg2000dsp.h"
42	#include "profiles.h"
43
44	#define JP2_SIG_TYPE 0x6A502020
45	#define JP2_SIG_VALUE 0x0D0A870A
46	#define JP2_CODESTREAM 0x6A703263
47	#define JP2_HEADER 0x6A703268
48
49	#define HAD_COC 0x01
50	#define HAD_QCC 0x02
51
52	#define MAX_POCS 32
53
54	typedef struct Jpeg2000POCEntry {
55	uint16_t LYEpoc;
56	uint16_t CSpoc;
57	uint16_t CEpoc;
58	uint8_t RSpoc;
59	uint8_t REpoc;
60	uint8_t Ppoc;
61	} Jpeg2000POCEntry;
62
63	typedef struct Jpeg2000POC {
64	Jpeg2000POCEntry poc[MAX_POCS];
65	int nb_poc;
66	int is_default;
67	} Jpeg2000POC;
68
69	typedef struct Jpeg2000TilePart {
70	uint8_t tile_index; // Tile index who refers the tile-part
71	const uint8_t *tp_end;
72	GetByteContext tpg; // bit stream in tile-part
73	} Jpeg2000TilePart;
74
75	/* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
76	* one per component, so tile_part elements have a size of 3 */
77	typedef struct Jpeg2000Tile {
78	Jpeg2000Component *comp;
79	uint8_t properties[4];
80	Jpeg2000CodingStyle codsty[4];
81	Jpeg2000QuantStyle qntsty[4];
82	Jpeg2000POC poc;
83	Jpeg2000TilePart tile_part[256];
84	uint16_t tp_idx; // Tile-part index
85	int coord[2][2]; // border coordinates {{x0, x1}, {y0, y1}}
86	} Jpeg2000Tile;
87
88	typedef struct Jpeg2000DecoderContext {
89	AVClass *class;
90	AVCodecContext *avctx;
91	GetByteContext g;
92
93	int width, height;
94	int image_offset_x, image_offset_y;
95	int tile_offset_x, tile_offset_y;
96	uint8_t cbps[4]; // bits per sample in particular components
97	uint8_t sgnd[4]; // if a component is signed
98	uint8_t properties[4];
99	int cdx[4], cdy[4];
100	int precision;
101	int ncomponents;
102	int colour_space;
103	uint32_t palette[256];
104	int8_t pal8;
105	int cdef[4];
106	int tile_width, tile_height;
107	unsigned numXtiles, numYtiles;
108	int maxtilelen;
109
110	Jpeg2000CodingStyle codsty[4];
111	Jpeg2000QuantStyle qntsty[4];
112	Jpeg2000POC poc;
113
114	int bit_index;
115
116	int curtileno;
117
118	Jpeg2000Tile *tile;
119	Jpeg2000DSPContext dsp;
120
121	/*options parameters*/
122	int reduction_factor;
123	} Jpeg2000DecoderContext;
124
125	/* get_bits functions for JPEG2000 packet bitstream
126	* It is a get_bit function with a bit-stuffing routine. If the value of the
127	* byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
128	* cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
129	static int get_bits(Jpeg2000DecoderContext *s, int n)
130	{
131	int res = 0;
132
133	while (--n >= 0) {
134	res <<= 1;
135	if (s->bit_index == 0) {
136	s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
137	}
138	s->bit_index--;
139	res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
140	}
141	return res;
142	}
143
144	static void jpeg2000_flush(Jpeg2000DecoderContext *s)
145	{
146	if (bytestream2_get_byte(&s->g) == 0xff)
147	bytestream2_skip(&s->g, 1);
148	s->bit_index = 8;
149	}
150
151	/* decode the value stored in node */
152	static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
153	int threshold)
154	{
155	Jpeg2000TgtNode *stack[30];
156	int sp = -1, curval = 0;
157
158	if (!node) {
159	av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
160	return AVERROR_INVALIDDATA;
161	}
162
163	while (node && !node->vis) {
164	stack[++sp] = node;
165	node = node->parent;
166	}
167
168	if (node)
169	curval = node->val;
170	else
171	curval = stack[sp]->val;
172
173	while (curval < threshold && sp >= 0) {
174	if (curval < stack[sp]->val)
175	curval = stack[sp]->val;
176	while (curval < threshold) {
177	int ret;
178	if ((ret = get_bits(s, 1)) > 0) {
179	stack[sp]->vis++;
180	break;
181	} else if (!ret)
182	curval++;
183	else
184	return ret;
185	}
186	stack[sp]->val = curval;
187	sp--;
188	}
189	return curval;
190	}
191
192	static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
193	int bpc, uint32_t log2_chroma_wh, int pal8)
194	{
195	int match = 1;
196	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
197
198	av_assert2(desc);
199
200	if (desc->nb_components != components) {
201	return 0;
202	}
203
204	switch (components) {
205	case 4:
206	match = match && desc->comp[3].depth >= bpc &&
207	(log2_chroma_wh >> 14 & 3) == 0 &&
208	(log2_chroma_wh >> 12 & 3) == 0;
209	case 3:
210	match = match && desc->comp[2].depth >= bpc &&
211	(log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
212	(log2_chroma_wh >> 8 & 3) == desc->log2_chroma_h;
213	case 2:
214	match = match && desc->comp[1].depth >= bpc &&
215	(log2_chroma_wh >> 6 & 3) == desc->log2_chroma_w &&
216	(log2_chroma_wh >> 4 & 3) == desc->log2_chroma_h;
217
218	case 1:
219	match = match && desc->comp[0].depth >= bpc &&
220	(log2_chroma_wh >> 2 & 3) == 0 &&
221	(log2_chroma_wh & 3) == 0 &&
222	(desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
223	}
224	return match;
225	}
226
227	// pix_fmts with lower bpp have to be listed before
228	// similar pix_fmts with higher bpp.
229	#define RGB_PIXEL_FORMATS AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
230	#define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
231	#define YUV_PIXEL_FORMATS AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
232	AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
233	AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
234	AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
235	AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
236	AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
237	AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
238	AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
239	AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
240	AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
241	AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
242	#define XYZ_PIXEL_FORMATS AV_PIX_FMT_XYZ12
243
244	static const enum AVPixelFormat rgb_pix_fmts[] = {RGB_PIXEL_FORMATS};
245	static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
246	static const enum AVPixelFormat yuv_pix_fmts[] = {YUV_PIXEL_FORMATS};
247	static const enum AVPixelFormat xyz_pix_fmts[] = {XYZ_PIXEL_FORMATS,
248	YUV_PIXEL_FORMATS};
249	static const enum AVPixelFormat all_pix_fmts[] = {RGB_PIXEL_FORMATS,
250	GRAY_PIXEL_FORMATS,
251	YUV_PIXEL_FORMATS,
252	XYZ_PIXEL_FORMATS};
253
254	/* marker segments */
255	/* get sizes and offsets of image, tiles; number of components */
256	static int get_siz(Jpeg2000DecoderContext *s)
257	{
258	int i;
259	int ncomponents;
260	uint32_t log2_chroma_wh = 0;
261	const enum AVPixelFormat *possible_fmts = NULL;
262	int possible_fmts_nb = 0;
263
264	if (bytestream2_get_bytes_left(&s->g) < 36) {
265	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
266	return AVERROR_INVALIDDATA;
267	}
268
269	s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
270	s->width = bytestream2_get_be32u(&s->g); // Width
271	s->height = bytestream2_get_be32u(&s->g); // Height
272	s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
273	s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
274	s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
275	s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
276	s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
277	s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
278	ncomponents = bytestream2_get_be16u(&s->g); // CSiz
279
280	if (s->image_offset_x || s->image_offset_y) {
281	avpriv_request_sample(s->avctx, "Support for image offsets");
282	return AVERROR_PATCHWELCOME;
283	}
284	if (av_image_check_size(s->width, s->height, 0, s->avctx)) {
285	avpriv_request_sample(s->avctx, "Large Dimensions");
286	return AVERROR_PATCHWELCOME;
287	}
288
289	if (ncomponents <= 0) {
290	av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
291	s->ncomponents);
292	return AVERROR_INVALIDDATA;
293	}
294
295	if (ncomponents > 4) {
296	avpriv_request_sample(s->avctx, "Support for %d components",
297	ncomponents);
298	return AVERROR_PATCHWELCOME;
299	}
300
301	s->ncomponents = ncomponents;
302
303	if (s->tile_width <= 0 || s->tile_height <= 0) {
304	av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
305	s->tile_width, s->tile_height);
306	return AVERROR_INVALIDDATA;
307	}
308
309	if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
310	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
311	return AVERROR_INVALIDDATA;
312	}
313
314	for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
315	uint8_t x = bytestream2_get_byteu(&s->g);
316	s->cbps[i] = (x & 0x7f) + 1;
317	s->precision = FFMAX(s->cbps[i], s->precision);
318	s->sgnd[i] = !!(x & 0x80);
319	s->cdx[i] = bytestream2_get_byteu(&s->g);
320	s->cdy[i] = bytestream2_get_byteu(&s->g);
321	if ( !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
322	|| !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
323	av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
324	return AVERROR_INVALIDDATA;
325	}
326	log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
327	}
328
329	s->numXtiles = ff_jpeg2000_ceildiv(s->width - s->tile_offset_x, s->tile_width);
330	s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
331
332	if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile)) {
333	s->numXtiles = s->numYtiles = 0;
334	return AVERROR(EINVAL);
335	}
336
337	s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
338	if (!s->tile) {
339	s->numXtiles = s->numYtiles = 0;
340	return AVERROR(ENOMEM);
341	}
342
343	for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
344	Jpeg2000Tile *tile = s->tile + i;
345
346	tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
347	if (!tile->comp)
348	return AVERROR(ENOMEM);
349	}
350
351	/* compute image size with reduction factor */
352	s->avctx->width = ff_jpeg2000_ceildivpow2(s->width - s->image_offset_x,
353	s->reduction_factor);
354	s->avctx->height = ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
355	s->reduction_factor);
356
357	if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
358	s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
359	possible_fmts = xyz_pix_fmts;
360	possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
361	} else {
362	switch (s->colour_space) {
363	case 16:
364	possible_fmts = rgb_pix_fmts;
365	possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
366	break;
367	case 17:
368	possible_fmts = gray_pix_fmts;
369	possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
370	break;
371	case 18:
372	possible_fmts = yuv_pix_fmts;
373	possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
374	break;
375	default:
376	possible_fmts = all_pix_fmts;
377	possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
378	break;
379	}
380	}
381	for (i = 0; i < possible_fmts_nb; ++i) {
382	if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
383	s->avctx->pix_fmt = possible_fmts[i];
384	break;
385	}
386	}
387
388	if (i == possible_fmts_nb) {
389	if (ncomponents == 4 &&
390	s->cdy[0] == 1 && s->cdx[0] == 1 &&
391	s->cdy[1] == 1 && s->cdx[1] == 1 &&
392	s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
393	if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
394	s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
395	s->cdef[0] = 0;
396	s->cdef[1] = 1;
397	s->cdef[2] = 2;
398	s->cdef[3] = 3;
399	i = 0;
400	}
401	}
402	}
403
404
405	if (i == possible_fmts_nb) {
406	av_log(s->avctx, AV_LOG_ERROR,
407	"Unknown pix_fmt, profile: %d, colour_space: %d, "
408	"components: %d, precision: %d\n"
409	"cdx[0]: %d, cdy[0]: %d\n"
410	"cdx[1]: %d, cdy[1]: %d\n"
411	"cdx[2]: %d, cdy[2]: %d\n"
412	"cdx[3]: %d, cdy[3]: %d\n",
413	s->avctx->profile, s->colour_space, ncomponents, s->precision,
414	s->cdx[0],
415	s->cdy[0],
416	ncomponents > 1 ? s->cdx[1] : 0,
417	ncomponents > 1 ? s->cdy[1] : 0,
418	ncomponents > 2 ? s->cdx[2] : 0,
419	ncomponents > 2 ? s->cdy[2] : 0,
420	ncomponents > 3 ? s->cdx[3] : 0,
421	ncomponents > 3 ? s->cdy[3] : 0);
422	return AVERROR_PATCHWELCOME;
423	}
424	s->avctx->bits_per_raw_sample = s->precision;
425	return 0;
426	}
427
428	/* get common part for COD and COC segments */
429	static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
430	{
431	uint8_t byte;
432
433	if (bytestream2_get_bytes_left(&s->g) < 5) {
434	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
435	return AVERROR_INVALIDDATA;
436	}
437
438	/* nreslevels = number of resolution levels
439	= number of decomposition level +1 */
440	c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
441	if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
442	av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
443	return AVERROR_INVALIDDATA;
444	}
445
446	if (c->nreslevels <= s->reduction_factor) {
447	/* we are forced to update reduction_factor as its requested value is
448	not compatible with this bitstream, and as we might have used it
449	already in setup earlier we have to fail this frame until
450	reinitialization is implemented */
451	av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
452	s->reduction_factor = c->nreslevels - 1;
453	return AVERROR(EINVAL);
454	}
455
456	/* compute number of resolution levels to decode */
457	c->nreslevels2decode = c->nreslevels - s->reduction_factor;
458
459	c->log2_cblk_width = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
460	c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
461
462	if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
463	c->log2_cblk_width + c->log2_cblk_height > 12) {
464	av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
465	return AVERROR_INVALIDDATA;
466	}
467
468	c->cblk_style = bytestream2_get_byteu(&s->g);
469	if (c->cblk_style != 0) { // cblk style
470	av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
471	if (c->cblk_style & JPEG2000_CBLK_BYPASS)
472	av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
473	}
474	c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
475	/* set integer 9/7 DWT in case of BITEXACT flag */
476	if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
477	c->transform = FF_DWT97_INT;
478	else if (c->transform == FF_DWT53) {
479	s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
480	}
481
482	if (c->csty & JPEG2000_CSTY_PREC) {
483	int i;
484	for (i = 0; i < c->nreslevels; i++) {
485	byte = bytestream2_get_byte(&s->g);
486	c->log2_prec_widths[i] = byte & 0x0F; // precinct PPx
487	c->log2_prec_heights[i] = (byte >> 4) & 0x0F; // precinct PPy
488	if (i)
489	if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
490	av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
491	c->log2_prec_widths[i], c->log2_prec_heights[i]);
492	c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
493	return AVERROR_INVALIDDATA;
494	}
495	}
496	} else {
497	memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
498	memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
499	}
500	return 0;
501	}
502
503	/* get coding parameters for a particular tile or whole image*/
504	static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
505	uint8_t *properties)
506	{
507	Jpeg2000CodingStyle tmp;
508	int compno, ret;
509
510	if (bytestream2_get_bytes_left(&s->g) < 5) {
511	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
512	return AVERROR_INVALIDDATA;
513	}
514
515	tmp.csty = bytestream2_get_byteu(&s->g);
516
517	// get progression order
518	tmp.prog_order = bytestream2_get_byteu(&s->g);
519
520	tmp.nlayers = bytestream2_get_be16u(&s->g);
521	tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
522
523	if (tmp.mct && s->ncomponents < 3) {
524	av_log(s->avctx, AV_LOG_ERROR,
525	"MCT %"PRIu8" with too few components (%d)\n",
526	tmp.mct, s->ncomponents);
527	return AVERROR_INVALIDDATA;
528	}
529
530	if ((ret = get_cox(s, &tmp)) < 0)
531	return ret;
532
533	for (compno = 0; compno < s->ncomponents; compno++)
534	if (!(properties[compno] & HAD_COC))
535	memcpy(c + compno, &tmp, sizeof(tmp));
536	return 0;
537	}
538
539	/* Get coding parameters for a component in the whole image or a
540	* particular tile. */
541	static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
542	uint8_t *properties)
543	{
544	int compno, ret;
545
546	if (bytestream2_get_bytes_left(&s->g) < 2) {
547	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
548	return AVERROR_INVALIDDATA;
549	}
550
551	compno = bytestream2_get_byteu(&s->g);
552
553	if (compno >= s->ncomponents) {
554	av_log(s->avctx, AV_LOG_ERROR,
555	"Invalid compno %d. There are %d components in the image.\n",
556	compno, s->ncomponents);
557	return AVERROR_INVALIDDATA;
558	}
559
560	c += compno;
561	c->csty = bytestream2_get_byteu(&s->g);
562
563	if ((ret = get_cox(s, c)) < 0)
564	return ret;
565
566	properties[compno] |= HAD_COC;
567	return 0;
568	}
569
570	/* Get common part for QCD and QCC segments. */
571	static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
572	{
573	int i, x;
574
575	if (bytestream2_get_bytes_left(&s->g) < 1)
576	return AVERROR_INVALIDDATA;
577
578	x = bytestream2_get_byteu(&s->g); // Sqcd
579
580	q->nguardbits = x >> 5;
581	q->quantsty = x & 0x1f;
582
583	if (q->quantsty == JPEG2000_QSTY_NONE) {
584	n -= 3;
585	if (bytestream2_get_bytes_left(&s->g) < n ||
586	n > JPEG2000_MAX_DECLEVELS*3)
587	return AVERROR_INVALIDDATA;
588	for (i = 0; i < n; i++)
589	q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
590	} else if (q->quantsty == JPEG2000_QSTY_SI) {
591	if (bytestream2_get_bytes_left(&s->g) < 2)
592	return AVERROR_INVALIDDATA;
593	x = bytestream2_get_be16u(&s->g);
594	q->expn[0] = x >> 11;
595	q->mant[0] = x & 0x7ff;
596	for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
597	int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
598	q->expn[i] = curexpn;
599	q->mant[i] = q->mant[0];
600	}
601	} else {
602	n = (n - 3) >> 1;
603	if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
604	n > JPEG2000_MAX_DECLEVELS*3)
605	return AVERROR_INVALIDDATA;
606	for (i = 0; i < n; i++) {
607	x = bytestream2_get_be16u(&s->g);
608	q->expn[i] = x >> 11;
609	q->mant[i] = x & 0x7ff;
610	}
611	}
612	return 0;
613	}
614
615	/* Get quantization parameters for a particular tile or a whole image. */
616	static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
617	uint8_t *properties)
618	{
619	Jpeg2000QuantStyle tmp;
620	int compno, ret;
621
622	memset(&tmp, 0, sizeof(tmp));
623
624	if ((ret = get_qcx(s, n, &tmp)) < 0)
625	return ret;
626	for (compno = 0; compno < s->ncomponents; compno++)
627	if (!(properties[compno] & HAD_QCC))
628	memcpy(q + compno, &tmp, sizeof(tmp));
629	return 0;
630	}
631
632	/* Get quantization parameters for a component in the whole image
633	* on in a particular tile. */
634	static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
635	uint8_t *properties)
636	{
637	int compno;
638
639	if (bytestream2_get_bytes_left(&s->g) < 1)
640	return AVERROR_INVALIDDATA;
641
642	compno = bytestream2_get_byteu(&s->g);
643
644	if (compno >= s->ncomponents) {
645	av_log(s->avctx, AV_LOG_ERROR,
646	"Invalid compno %d. There are %d components in the image.\n",
647	compno, s->ncomponents);
648	return AVERROR_INVALIDDATA;
649	}
650
651	properties[compno] |= HAD_QCC;
652	return get_qcx(s, n - 1, q + compno);
653	}
654
655	static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
656	{
657	int i;
658	int elem_size = s->ncomponents <= 257 ? 7 : 9;
659	Jpeg2000POC tmp = {{{0}}};
660
661	if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
662	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
663	return AVERROR_INVALIDDATA;
664	}
665
666	if (elem_size > 7) {
667	avpriv_request_sample(s->avctx, "Fat POC not supported");
668	return AVERROR_PATCHWELCOME;
669	}
670
671	tmp.nb_poc = (size - 2) / elem_size;
672	if (tmp.nb_poc > MAX_POCS) {
673	avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
674	return AVERROR_PATCHWELCOME;
675	}
676
677	for (i = 0; i<tmp.nb_poc; i++) {
678	Jpeg2000POCEntry *e = &tmp.poc[i];
679	e->RSpoc = bytestream2_get_byteu(&s->g);
680	e->CSpoc = bytestream2_get_byteu(&s->g);
681	e->LYEpoc = bytestream2_get_be16u(&s->g);
682	e->REpoc = bytestream2_get_byteu(&s->g);
683	e->CEpoc = bytestream2_get_byteu(&s->g);
684	e->Ppoc = bytestream2_get_byteu(&s->g);
685	if (!e->CEpoc)
686	e->CEpoc = 256;
687	if (e->CEpoc > s->ncomponents)
688	e->CEpoc = s->ncomponents;
689	if ( e->RSpoc >= e->REpoc || e->REpoc > 33
690	|| e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
691	|| !e->LYEpoc) {
692	av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
693	e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
694	);
695	return AVERROR_INVALIDDATA;
696	}
697	}
698
699	if (!p->nb_poc || p->is_default) {
700	*p = tmp;
701	} else {
702	if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
703	av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
704	return AVERROR_INVALIDDATA;
705	}
706	memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
707	p->nb_poc += tmp.nb_poc;
708	}
709
710	p->is_default = 0;
711
712	return 0;
713	}
714
715
716	/* Get start of tile segment. */
717	static int get_sot(Jpeg2000DecoderContext *s, int n)
718	{
719	Jpeg2000TilePart *tp;
720	uint16_t Isot;
721	uint32_t Psot;
722	unsigned TPsot;
723
724	if (bytestream2_get_bytes_left(&s->g) < 8)
725	return AVERROR_INVALIDDATA;
726
727	s->curtileno = 0;
728	Isot = bytestream2_get_be16u(&s->g); // Isot
729	if (Isot >= s->numXtiles * s->numYtiles)
730	return AVERROR_INVALIDDATA;
731
732	s->curtileno = Isot;
733	Psot = bytestream2_get_be32u(&s->g); // Psot
734	TPsot = bytestream2_get_byteu(&s->g); // TPsot
735
736	/* Read TNSot but not used */
737	bytestream2_get_byteu(&s->g); // TNsot
738
739	if (!Psot)
740	Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
741
742	if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
743	av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
744	return AVERROR_INVALIDDATA;
745	}
746
747	av_assert0(TPsot < FF_ARRAY_ELEMS(s->tile[Isot].tile_part));
748
749	s->tile[Isot].tp_idx = TPsot;
750	tp = s->tile[Isot].tile_part + TPsot;
751	tp->tile_index = Isot;
752	tp->tp_end = s->g.buffer + Psot - n - 2;
753
754	if (!TPsot) {
755	Jpeg2000Tile *tile = s->tile + s->curtileno;
756
757	/* copy defaults */
758	memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
759	memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
760	memcpy(&tile->poc , &s->poc , sizeof(tile->poc));
761	tile->poc.is_default = 1;
762	}
763
764	return 0;
765	}
766
767	/* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
768	* Used to know the number of tile parts and lengths.
769	* There may be multiple TLMs in the header.
770	* TODO: The function is not used for tile-parts management, nor anywhere else.
771	* It can be useful to allocate memory for tile parts, before managing the SOT
772	* markers. Parsing the TLM header is needed to increment the input header
773	* buffer.
774	* This marker is mandatory for DCI. */
775	static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
776	{
777	uint8_t Stlm, ST, SP, tile_tlm, i;
778	bytestream2_get_byte(&s->g); /* Ztlm: skipped */
779	Stlm = bytestream2_get_byte(&s->g);
780
781	// too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
782	ST = (Stlm >> 4) & 0x03;
783	// TODO: Manage case of ST = 0b11 --> raise error
784	SP = (Stlm >> 6) & 0x01;
785	tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
786	for (i = 0; i < tile_tlm; i++) {
787	switch (ST) {
788	case 0:
789	break;
790	case 1:
791	bytestream2_get_byte(&s->g);
792	break;
793	case 2:
794	bytestream2_get_be16(&s->g);
795	break;
796	case 3:
797	bytestream2_get_be32(&s->g);
798	break;
799	}
800	if (SP == 0) {
801	bytestream2_get_be16(&s->g);
802	} else {
803	bytestream2_get_be32(&s->g);
804	}
805	}
806	return 0;
807	}
808
809	static uint8_t get_plt(Jpeg2000DecoderContext *s, int n)
810	{
811	int i;
812
813	av_log(s->avctx, AV_LOG_DEBUG,
814	"PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
815
816	/*Zplt =*/ bytestream2_get_byte(&s->g);
817
818	for (i = 0; i < n - 3; i++) {
819	bytestream2_get_byte(&s->g);
820	}
821
822	return 0;
823	}
824
825	static int init_tile(Jpeg2000DecoderContext *s, int tileno)
826	{
827	int compno;
828	int tilex = tileno % s->numXtiles;
829	int tiley = tileno / s->numXtiles;
830	Jpeg2000Tile *tile = s->tile + tileno;
831
832	if (!tile->comp)
833	return AVERROR(ENOMEM);
834
835	tile->coord[0][0] = av_clip(tilex * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
836	tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width + s->tile_offset_x, s->image_offset_x, s->width);
837	tile->coord[1][0] = av_clip(tiley * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
838	tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
839
840	for (compno = 0; compno < s->ncomponents; compno++) {
841	Jpeg2000Component *comp = tile->comp + compno;
842	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
843	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
844	int ret; // global bandno
845
846	comp->coord_o[0][0] = tile->coord[0][0];
847	comp->coord_o[0][1] = tile->coord[0][1];
848	comp->coord_o[1][0] = tile->coord[1][0];
849	comp->coord_o[1][1] = tile->coord[1][1];
850	if (compno) {
851	comp->coord_o[0][0] /= s->cdx[compno];
852	comp->coord_o[0][1] /= s->cdx[compno];
853	comp->coord_o[1][0] /= s->cdy[compno];
854	comp->coord_o[1][1] /= s->cdy[compno];
855	}
856
857	comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
858	comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
859	comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
860	comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
861
862	if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
863	s->cbps[compno], s->cdx[compno],
864	s->cdy[compno], s->avctx))
865	return ret;
866	}
867	return 0;
868	}
869
870	/* Read the number of coding passes. */
871	static int getnpasses(Jpeg2000DecoderContext *s)
872	{
873	int num;
874	if (!get_bits(s, 1))
875	return 1;
876	if (!get_bits(s, 1))
877	return 2;
878	if ((num = get_bits(s, 2)) != 3)
879	return num < 0 ? num : 3 + num;
880	if ((num = get_bits(s, 5)) != 31)
881	return num < 0 ? num : 6 + num;
882	num = get_bits(s, 7);
883	return num < 0 ? num : 37 + num;
884	}
885
886	static int getlblockinc(Jpeg2000DecoderContext *s)
887	{
888	int res = 0, ret;
889	while (ret = get_bits(s, 1)) {
890	if (ret < 0)
891	return ret;
892	res++;
893	}
894	return res;
895	}
896
897	static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
898	Jpeg2000CodingStyle *codsty,
899	Jpeg2000ResLevel *rlevel, int precno,
900	int layno, uint8_t *expn, int numgbits)
901	{
902	int bandno, cblkno, ret, nb_code_blocks;
903	int cwsno;
904
905	if (layno < rlevel->band[0].prec[precno].decoded_layers)
906	return 0;
907	rlevel->band[0].prec[precno].decoded_layers = layno + 1;
908
909	if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
910	if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
911	s->g = tile->tile_part[++(*tp_index)].tpg;
912	}
913	}
914
915	if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
916	bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
917
918	if (!(ret = get_bits(s, 1))) {
919	jpeg2000_flush(s);
920	return 0;
921	} else if (ret < 0)
922	return ret;
923
924	for (bandno = 0; bandno < rlevel->nbands; bandno++) {
925	Jpeg2000Band *band = rlevel->band + bandno;
926	Jpeg2000Prec *prec = band->prec + precno;
927
928	if (band->coord[0][0] == band->coord[0][1] ||
929	band->coord[1][0] == band->coord[1][1])
930	continue;
931	nb_code_blocks = prec->nb_codeblocks_height *
932	prec->nb_codeblocks_width;
933	for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
934	Jpeg2000Cblk *cblk = prec->cblk + cblkno;
935	int incl, newpasses, llen;
936
937	if (cblk->npasses)
938	incl = get_bits(s, 1);
939	else
940	incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
941	if (!incl)
942	continue;
943	else if (incl < 0)
944	return incl;
945
946	if (!cblk->npasses) {
947	int v = expn[bandno] + numgbits - 1 -
948	tag_tree_decode(s, prec->zerobits + cblkno, 100);
949	if (v < 0) {
950	av_log(s->avctx, AV_LOG_ERROR,
951	"nonzerobits %d invalid\n", v);
952	return AVERROR_INVALIDDATA;
953	}
954	cblk->nonzerobits = v;
955	}
956	if ((newpasses = getnpasses(s)) < 0)
957	return newpasses;
958	av_assert2(newpasses > 0);
959	if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
960	avpriv_request_sample(s->avctx, "Too many passes");
961	return AVERROR_PATCHWELCOME;
962	}
963	if ((llen = getlblockinc(s)) < 0)
964	return llen;
965	if (cblk->lblock + llen + av_log2(newpasses) > 16) {
966	avpriv_request_sample(s->avctx,
967	"Block with length beyond 16 bits");
968	return AVERROR_PATCHWELCOME;
969	}
970
971	cblk->lblock += llen;
972
973	cblk->nb_lengthinc = 0;
974	cblk->nb_terminationsinc = 0;
975	do {
976	int newpasses1 = 0;
977
978	while (newpasses1 < newpasses) {
979	newpasses1 ++;
980	if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
981	cblk->nb_terminationsinc ++;
982	break;
983	}
984	}
985
986	if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
987	return ret;
988	if (ret > sizeof(cblk->data)) {
989	avpriv_request_sample(s->avctx,
990	"Block with lengthinc greater than %"SIZE_SPECIFIER"",
991	sizeof(cblk->data));
992	return AVERROR_PATCHWELCOME;
993	}
994	cblk->lengthinc[cblk->nb_lengthinc++] = ret;
995	cblk->npasses += newpasses1;
996	newpasses -= newpasses1;
997	} while(newpasses);
998	}
999	}
1000	jpeg2000_flush(s);
1001
1002	if (codsty->csty & JPEG2000_CSTY_EPH) {
1003	if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1004	bytestream2_skip(&s->g, 2);
1005	else
1006	av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1007	}
1008
1009	for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1010	Jpeg2000Band *band = rlevel->band + bandno;
1011	Jpeg2000Prec *prec = band->prec + precno;
1012
1013	nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1014	for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1015	Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1016	for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1017	if ( bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1018	|| sizeof(cblk->data) < cblk->length + cblk->lengthinc[cwsno] + 4
1019	) {
1020	av_log(s->avctx, AV_LOG_ERROR,
1021	"Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1022	cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1023	return AVERROR_INVALIDDATA;
1024	}
1025
1026	bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1027	cblk->length += cblk->lengthinc[cwsno];
1028	cblk->lengthinc[cwsno] = 0;
1029	if (cblk->nb_terminationsinc) {
1030	cblk->nb_terminationsinc--;
1031	cblk->nb_terminations++;
1032	cblk->data[cblk->length++] = 0xFF;
1033	cblk->data[cblk->length++] = 0xFF;
1034	cblk->data_start[cblk->nb_terminations] = cblk->length;
1035	}
1036	}
1037	}
1038	}
1039	return 0;
1040	}
1041
1042	static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1043	int RSpoc, int CSpoc,
1044	int LYEpoc, int REpoc, int CEpoc,
1045	int Ppoc, int *tp_index)
1046	{
1047	int ret = 0;
1048	int layno, reslevelno, compno, precno, ok_reslevel;
1049	int x, y;
1050	int step_x, step_y;
1051
1052	switch (Ppoc) {
1053	case JPEG2000_PGOD_RLCP:
1054	av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1055	ok_reslevel = 1;
1056	for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1057	ok_reslevel = 0;
1058	for (layno = 0; layno < LYEpoc; layno++) {
1059	for (compno = CSpoc; compno < CEpoc; compno++) {
1060	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1061	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1062	if (reslevelno < codsty->nreslevels) {
1063	Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1064	reslevelno;
1065	ok_reslevel = 1;
1066	for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1067	if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1068	codsty, rlevel,
1069	precno, layno,
1070	qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1071	qntsty->nguardbits)) < 0)
1072	return ret;
1073	}
1074	}
1075	}
1076	}
1077	break;
1078
1079	case JPEG2000_PGOD_LRCP:
1080	av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1081	for (layno = 0; layno < LYEpoc; layno++) {
1082	ok_reslevel = 1;
1083	for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1084	ok_reslevel = 0;
1085	for (compno = CSpoc; compno < CEpoc; compno++) {
1086	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1087	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1088	if (reslevelno < codsty->nreslevels) {
1089	Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1090	reslevelno;
1091	ok_reslevel = 1;
1092	for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1093	if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1094	codsty, rlevel,
1095	precno, layno,
1096	qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1097	qntsty->nguardbits)) < 0)
1098	return ret;
1099	}
1100	}
1101	}
1102	}
1103	break;
1104
1105	case JPEG2000_PGOD_CPRL:
1106	av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1107	for (compno = CSpoc; compno < CEpoc; compno++) {
1108	Jpeg2000Component *comp = tile->comp + compno;
1109	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1110	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1111	step_x = 32;
1112	step_y = 32;
1113
1114	for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1115	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1116	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1117	step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1118	step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1119	}
1120	av_assert0(step_x < 32 && step_y < 32);
1121	step_x = 1<<step_x;
1122	step_y = 1<<step_y;
1123
1124	for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1125	for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1126	for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1127	unsigned prcx, prcy;
1128	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1129	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1130	int xc = x / s->cdx[compno];
1131	int yc = y / s->cdy[compno];
1132
1133	if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1134	continue;
1135
1136	if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1137	continue;
1138
1139	// check if a precinct exists
1140	prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1141	prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1142	prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1143	prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1144
1145	precno = prcx + rlevel->num_precincts_x * prcy;
1146
1147	if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1148	av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1149	prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1150	continue;
1151	}
1152
1153	for (layno = 0; layno < LYEpoc; layno++) {
1154	if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1155	precno, layno,
1156	qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1157	qntsty->nguardbits)) < 0)
1158	return ret;
1159	}
1160	}
1161	}
1162	}
1163	}
1164	break;
1165
1166	case JPEG2000_PGOD_RPCL:
1167	av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1168	ok_reslevel = 1;
1169	for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1170	ok_reslevel = 0;
1171	step_x = 30;
1172	step_y = 30;
1173	for (compno = CSpoc; compno < CEpoc; compno++) {
1174	Jpeg2000Component *comp = tile->comp + compno;
1175	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1176
1177	if (reslevelno < codsty->nreslevels) {
1178	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1179	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1180	step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1181	step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1182	}
1183	}
1184	step_x = 1<<step_x;
1185	step_y = 1<<step_y;
1186
1187	for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1188	for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189	for (compno = CSpoc; compno < CEpoc; compno++) {
1190	Jpeg2000Component *comp = tile->comp + compno;
1191	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1192	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1193	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1194	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1195	unsigned prcx, prcy;
1196
1197	int xc = x / s->cdx[compno];
1198	int yc = y / s->cdy[compno];
1199
1200	if (reslevelno >= codsty->nreslevels)
1201	continue;
1202
1203	if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1204	continue;
1205
1206	if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1207	continue;
1208
1209	// check if a precinct exists
1210	prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1211	prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1212	prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1213	prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1214
1215	precno = prcx + rlevel->num_precincts_x * prcy;
1216
1217	ok_reslevel = 1;
1218	if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1219	av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1220	prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1221	continue;
1222	}
1223
1224	for (layno = 0; layno < LYEpoc; layno++) {
1225	if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1226	codsty, rlevel,
1227	precno, layno,
1228	qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1229	qntsty->nguardbits)) < 0)
1230	return ret;
1231	}
1232	}
1233	}
1234	}
1235	}
1236	break;
1237
1238	case JPEG2000_PGOD_PCRL:
1239	av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1240	step_x = 32;
1241	step_y = 32;
1242	for (compno = CSpoc; compno < CEpoc; compno++) {
1243	Jpeg2000Component *comp = tile->comp + compno;
1244	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1245
1246	for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1247	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1248	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1249	step_x = FFMIN(step_x, rlevel->log2_prec_width + reducedresno);
1250	step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1251	}
1252	}
1253	if (step_x >= 31 || step_y >= 31){
1254	avpriv_request_sample(s->avctx, "PCRL with large step");
1255	return AVERROR_PATCHWELCOME;
1256	}
1257	step_x = 1<<step_x;
1258	step_y = 1<<step_y;
1259
1260	for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1261	for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1262	for (compno = CSpoc; compno < CEpoc; compno++) {
1263	Jpeg2000Component *comp = tile->comp + compno;
1264	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1265	Jpeg2000QuantStyle *qntsty = tile->qntsty + compno;
1266	int xc = x / s->cdx[compno];
1267	int yc = y / s->cdy[compno];
1268
1269	for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1270	unsigned prcx, prcy;
1271	uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; // ==> N_L - r
1272	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1273
1274	if (yc % (1 << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1275	continue;
1276
1277	if (xc % (1 << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1278	continue;
1279
1280	// check if a precinct exists
1281	prcx = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1282	prcy = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1283	prcx -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1284	prcy -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1285
1286	precno = prcx + rlevel->num_precincts_x * prcy;
1287
1288	if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1289	av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1290	prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1291	continue;
1292	}
1293
1294	for (layno = 0; layno < LYEpoc; layno++) {
1295	if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1296	precno, layno,
1297	qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1298	qntsty->nguardbits)) < 0)
1299	return ret;
1300	}
1301	}
1302	}
1303	}
1304	}
1305	break;
1306
1307	default:
1308	break;
1309	}
1310
1311	return ret;
1312	}
1313
1314	static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1315	{
1316	int ret = AVERROR_BUG;
1317	int i;
1318	int tp_index = 0;
1319
1320	s->bit_index = 8;
1321	if (tile->poc.nb_poc) {
1322	for (i=0; i<tile->poc.nb_poc; i++) {
1323	Jpeg2000POCEntry *e = &tile->poc.poc[i];
1324	ret = jpeg2000_decode_packets_po_iteration(s, tile,
1325	e->RSpoc, e->CSpoc,
1326	FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1327	e->REpoc,
1328	FFMIN(e->CEpoc, s->ncomponents),
1329	e->Ppoc, &tp_index
1330	);
1331	if (ret < 0)
1332	return ret;
1333	}
1334	} else {
1335	ret = jpeg2000_decode_packets_po_iteration(s, tile,
1336	0, 0,
1337	tile->codsty[0].nlayers,
1338	33,
1339	s->ncomponents,
1340	tile->codsty[0].prog_order,
1341	&tp_index
1342	);
1343	}
1344	/* EOC marker reached */
1345	bytestream2_skip(&s->g, 2);
1346
1347	return ret;
1348	}
1349
1350	/* TIER-1 routines */
1351	static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1352	int bpno, int bandno,
1353	int vert_causal_ctx_csty_symbol)
1354	{
1355	int mask = 3 << (bpno - 1), y0, x, y;
1356
1357	for (y0 = 0; y0 < height; y0 += 4)
1358	for (x = 0; x < width; x++)
1359	for (y = y0; y < height && y < y0 + 4; y++) {
1360	int flags_mask = -1;
1361	if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1362	flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1363	if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1364	&& !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1365	if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1366	int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1367	if (t1->mqc.raw)
1368	t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1369	else
1370	t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1371	-mask : mask;
1372
1373	ff_jpeg2000_set_significance(t1, x, y,
1374	t1->data[(y) * t1->stride + x] < 0);
1375	}
1376	t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1377	}
1378	}
1379	}
1380
1381	static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1382	int bpno, int vert_causal_ctx_csty_symbol)
1383	{
1384	int phalf, nhalf;
1385	int y0, x, y;
1386
1387	phalf = 1 << (bpno - 1);
1388	nhalf = -phalf;
1389
1390	for (y0 = 0; y0 < height; y0 += 4)
1391	for (x = 0; x < width; x++)
1392	for (y = y0; y < height && y < y0 + 4; y++)
1393	if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1394	int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1395	~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1396	int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1397	int r = ff_mqc_decode(&t1->mqc,
1398	t1->mqc.cx_states + ctxno)
1399	? phalf : nhalf;
1400	t1->data[(y) * t1->stride + x] += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1401	t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1402	}
1403	}
1404
1405	static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1406	int width, int height, int bpno, int bandno,
1407	int seg_symbols, int vert_causal_ctx_csty_symbol)
1408	{
1409	int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1410
1411	for (y0 = 0; y0 < height; y0 += 4) {
1412	for (x = 0; x < width; x++) {
1413	int flags_mask = -1;
1414	if (vert_causal_ctx_csty_symbol)
1415	flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1416	if (y0 + 3 < height &&
1417	!((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1418	(t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1419	(t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1420	(t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1421	if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1422	continue;
1423	runlen = ff_mqc_decode(&t1->mqc,
1424	t1->mqc.cx_states + MQC_CX_UNI);
1425	runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1426	t1->mqc.cx_states +
1427	MQC_CX_UNI);
1428	dec = 1;
1429	} else {
1430	runlen = 0;
1431	dec = 0;
1432	}
1433
1434	for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1435	int flags_mask = -1;
1436	if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1437	flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1438	if (!dec) {
1439	if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1440	dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1441	bandno));
1442	}
1443	}
1444	if (dec) {
1445	int xorbit;
1446	int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1447	&xorbit);
1448	t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1449	t1->mqc.cx_states + ctxno) ^
1450	xorbit)
1451	? -mask : mask;
1452	ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1453	}
1454	dec = 0;
1455	t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1456	}
1457	}
1458	}
1459	if (seg_symbols) {
1460	int val;
1461	val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1462	val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1463	val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1464	val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1465	if (val != 0xa)
1466	av_log(s->avctx, AV_LOG_ERROR,
1467	"Segmentation symbol value incorrect\n");
1468	}
1469	}
1470
1471	static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1472	Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1473	int width, int height, int bandpos)
1474	{
1475	int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1476	int pass_cnt = 0;
1477	int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1478	int term_cnt = 0;
1479	int coder_type;
1480
1481	av_assert0(width <= 1024U && height <= 1024U);
1482	av_assert0(width*height <= 4096);
1483
1484	memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1485
1486	/* If code-block contains no compressed data: nothing to do. */
1487	if (!cblk->length)
1488	return 0;
1489
1490	memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1491
1492	cblk->data[cblk->length] = 0xff;
1493	cblk->data[cblk->length+1] = 0xff;
1494	ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1495
1496	while (passno--) {
1497	if (bpno < 0) {
1498	av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1499	return AVERROR_INVALIDDATA;
1500	}
1501	switch(pass_t) {
1502	case 0:
1503	decode_sigpass(t1, width, height, bpno + 1, bandpos,
1504	vert_causal_ctx_csty_symbol);
1505	break;
1506	case 1:
1507	decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1508	break;
1509	case 2:
1510	av_assert2(!t1->mqc.raw);
1511	decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1512	codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1513	vert_causal_ctx_csty_symbol);
1514	break;
1515	}
1516	if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1517	ff_mqc_init_contexts(&t1->mqc);
1518
1519	if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1520	if (term_cnt >= cblk->nb_terminations) {
1521	av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1522	return AVERROR_INVALIDDATA;
1523	}
1524	if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1525	av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1526	cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1527	pass_cnt, cblk->npasses);
1528	}
1529
1530	ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1531	}
1532
1533	pass_t++;
1534	if (pass_t == 3) {
1535	bpno--;
1536	pass_t = 0;
1537	}
1538	pass_cnt ++;
1539	}
1540
1541	if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1542	av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1543	cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1544	}
1545
1546	return 0;
1547	}
1548
1549	/* TODO: Verify dequantization for lossless case
1550	* comp->data can be float or int
1551	* band->stepsize can be float or int
1552	* depending on the type of DWT transformation.
1553	* see ISO/IEC 15444-1:2002 A.6.1 */
1554
1555	/* Float dequantization of a codeblock.*/
1556	static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1557	Jpeg2000Component *comp,
1558	Jpeg2000T1Context *t1, Jpeg2000Band *band)
1559	{
1560	int i, j;
1561	int w = cblk->coord[0][1] - cblk->coord[0][0];
1562	for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1563	float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1564	int *src = t1->data + j*t1->stride;
1565	for (i = 0; i < w; ++i)
1566	datap[i] = src[i] * band->f_stepsize;
1567	}
1568	}
1569
1570	/* Integer dequantization of a codeblock.*/
1571	static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1572	Jpeg2000Component *comp,
1573	Jpeg2000T1Context *t1, Jpeg2000Band *band)
1574	{
1575	int i, j;
1576	int w = cblk->coord[0][1] - cblk->coord[0][0];
1577	for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1578	int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1579	int *src = t1->data + j*t1->stride;
1580	if (band->i_stepsize == 32768) {
1581	for (i = 0; i < w; ++i)
1582	datap[i] = src[i] / 2;
1583	} else {
1584	// This should be VERY uncommon
1585	for (i = 0; i < w; ++i)
1586	datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1587	}
1588	}
1589	}
1590
1591	static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1592	Jpeg2000Component *comp,
1593	Jpeg2000T1Context *t1, Jpeg2000Band *band)
1594	{
1595	int i, j;
1596	int w = cblk->coord[0][1] - cblk->coord[0][0];
1597	for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1598	int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1599	int *src = t1->data + j*t1->stride;
1600	for (i = 0; i < w; ++i)
1601	datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1602	}
1603	}
1604
1605	static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1606	{
1607	int i, csize = 1;
1608	void *src[3];
1609
1610	for (i = 1; i < 3; i++) {
1611	if (tile->codsty[0].transform != tile->codsty[i].transform) {
1612	av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1613	return;
1614	}
1615	if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1616	av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1617	return;
1618	}
1619	}
1620
1621	for (i = 0; i < 3; i++)
1622	if (tile->codsty[0].transform == FF_DWT97)
1623	src[i] = tile->comp[i].f_data;
1624	else
1625	src[i] = tile->comp[i].i_data;
1626
1627	for (i = 0; i < 2; i++)
1628	csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1629
1630	s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1631	}
1632
1633	static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1634	{
1635	Jpeg2000T1Context t1;
1636
1637	int compno, reslevelno, bandno;
1638
1639	/* Loop on tile components */
1640	for (compno = 0; compno < s->ncomponents; compno++) {
1641	Jpeg2000Component *comp = tile->comp + compno;
1642	Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1643
1644	t1.stride = (1<<codsty->log2_cblk_width) + 2;
1645
1646	/* Loop on resolution levels */
1647	for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1648	Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1649	/* Loop on bands */
1650	for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1651	int nb_precincts, precno;
1652	Jpeg2000Band *band = rlevel->band + bandno;
1653	int cblkno = 0, bandpos;
1654
1655	bandpos = bandno + (reslevelno > 0);
1656
1657	if (band->coord[0][0] == band->coord[0][1] ||
1658	band->coord[1][0] == band->coord[1][1])
1659	continue;
1660
1661	nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1662	/* Loop on precincts */
1663	for (precno = 0; precno < nb_precincts; precno++) {
1664	Jpeg2000Prec *prec = band->prec + precno;
1665
1666	/* Loop on codeblocks */
1667	for (cblkno = 0;
1668	cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1669	cblkno++) {
1670	int x, y;
1671	Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1672	decode_cblk(s, codsty, &t1, cblk,
1673	cblk->coord[0][1] - cblk->coord[0][0],
1674	cblk->coord[1][1] - cblk->coord[1][0],
1675	bandpos);
1676
1677	x = cblk->coord[0][0] - band->coord[0][0];
1678	y = cblk->coord[1][0] - band->coord[1][0];
1679
1680	if (codsty->transform == FF_DWT97)
1681	dequantization_float(x, y, cblk, comp, &t1, band);
1682	else if (codsty->transform == FF_DWT97_INT)
1683	dequantization_int_97(x, y, cblk, comp, &t1, band);
1684	else
1685	dequantization_int(x, y, cblk, comp, &t1, band);
1686	} /* end cblk */
1687	} /*end prec */
1688	} /* end band */
1689	} /* end reslevel */
1690
1691	/* inverse DWT */
1692	ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1693	} /*end comp */
1694	}
1695
1696	#define WRITE_FRAME(D, PIXEL) \
1697	static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile, \
1698	AVFrame * picture, int precision) \
1699	{ \
1700	const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt); \
1701	int planar = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR); \
1702	int pixelsize = planar ? 1 : pixdesc->nb_components; \
1703	\
1704	int compno; \
1705	int x, y; \
1706	\
1707	for (compno = 0; compno < s->ncomponents; compno++) { \
1708	Jpeg2000Component *comp = tile->comp + compno; \
1709	Jpeg2000CodingStyle *codsty = tile->codsty + compno; \
1710	PIXEL *line; \
1711	float *datap = comp->f_data; \
1712	int32_t *i_datap = comp->i_data; \
1713	int cbps = s->cbps[compno]; \
1714	int w = tile->comp[compno].coord[0][1] - s->image_offset_x; \
1715	int plane = 0; \
1716	\
1717	if (planar) \
1718	plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1); \
1719	\
1720	y = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno]; \
1721	line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1722	for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) { \
1723	PIXEL *dst; \
1724	\
1725	x = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno]; \
1726	dst = line + x * pixelsize + compno*!planar; \
1727	\
1728	if (codsty->transform == FF_DWT97) { \
1729	for (; x < w; x++) { \
1730	int val = lrintf(*datap) + (1 << (cbps - 1)); \
1731	/* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1732	val = av_clip(val, 0, (1 << cbps) - 1); \
1733	*dst = val << (precision - cbps); \
1734	datap++; \
1735	dst += pixelsize; \
1736	} \
1737	} else { \
1738	for (; x < w; x++) { \
1739	int val = *i_datap + (1 << (cbps - 1)); \
1740	/* DC level shift and clip see ISO 15444-1:2002 G.1.2 */ \
1741	val = av_clip(val, 0, (1 << cbps) - 1); \
1742	*dst = val << (precision - cbps); \
1743	i_datap++; \
1744	dst += pixelsize; \
1745	} \
1746	} \
1747	line += picture->linesize[plane] / sizeof(PIXEL); \
1748	} \
1749	} \
1750	\
1751	}
1752
1753	WRITE_FRAME(8, uint8_t)
1754	WRITE_FRAME(16, uint16_t)
1755
1756	#undef WRITE_FRAME
1757
1758	static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1759	int jobnr, int threadnr)
1760	{
1761	Jpeg2000DecoderContext *s = avctx->priv_data;
1762	AVFrame *picture = td;
1763	Jpeg2000Tile *tile = s->tile + jobnr;
1764	int x;
1765
1766	tile_codeblocks(s, tile);
1767
1768	/* inverse MCT transformation */
1769	if (tile->codsty[0].mct)
1770	mct_decode(s, tile);
1771
1772	for (x = 0; x < s->ncomponents; x++) {
1773	if (s->cdef[x] < 0) {
1774	for (x = 0; x < s->ncomponents; x++) {
1775	s->cdef[x] = x + 1;
1776	}
1777	if ((s->ncomponents & 1) == 0)
1778	s->cdef[s->ncomponents-1] = 0;
1779	break;
1780	}
1781	}
1782
1783	if (s->precision <= 8) {
1784	write_frame_8(s, tile, picture, 8);
1785	} else {
1786	int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1787	picture->format == AV_PIX_FMT_RGB48 ||
1788	picture->format == AV_PIX_FMT_RGBA64 ||
1789	picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1790
1791	write_frame_16(s, tile, picture, precision);
1792	}
1793
1794	return 0;
1795	}
1796
1797	static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1798	{
1799	int tileno, compno;
1800	for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1801	if (s->tile[tileno].comp) {
1802	for (compno = 0; compno < s->ncomponents; compno++) {
1803	Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1804	Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1805
1806	ff_jpeg2000_cleanup(comp, codsty);
1807	}
1808	av_freep(&s->tile[tileno].comp);
1809	}
1810	}
1811	av_freep(&s->tile);
1812	memset(s->codsty, 0, sizeof(s->codsty));
1813	memset(s->qntsty, 0, sizeof(s->qntsty));
1814	memset(s->properties, 0, sizeof(s->properties));
1815	memset(&s->poc , 0, sizeof(s->poc));
1816	s->numXtiles = s->numYtiles = 0;
1817	s->ncomponents = 0;
1818	}
1819
1820	static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1821	{
1822	Jpeg2000CodingStyle *codsty = s->codsty;
1823	Jpeg2000QuantStyle *qntsty = s->qntsty;
1824	Jpeg2000POC *poc = &s->poc;
1825	uint8_t *properties = s->properties;
1826
1827	for (;;) {
1828	int len, ret = 0;
1829	uint16_t marker;
1830	int oldpos;
1831
1832	if (bytestream2_get_bytes_left(&s->g) < 2) {
1833	av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1834	break;
1835	}
1836
1837	marker = bytestream2_get_be16u(&s->g);
1838	oldpos = bytestream2_tell(&s->g);
1839
1840	if (marker == JPEG2000_SOD) {
1841	Jpeg2000Tile *tile;
1842	Jpeg2000TilePart *tp;
1843
1844	if (!s->tile) {
1845	av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1846	return AVERROR_INVALIDDATA;
1847	}
1848	if (s->curtileno < 0) {
1849	av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1850	return AVERROR_INVALIDDATA;
1851	}
1852
1853	tile = s->tile + s->curtileno;
1854	tp = tile->tile_part + tile->tp_idx;
1855	if (tp->tp_end < s->g.buffer) {
1856	av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1857	return AVERROR_INVALIDDATA;
1858	}
1859	bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1860	bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1861
1862	continue;
1863	}
1864	if (marker == JPEG2000_EOC)
1865	break;
1866
1867	len = bytestream2_get_be16(&s->g);
1868	if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1869	av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1870	return AVERROR_INVALIDDATA;
1871	}
1872
1873	switch (marker) {
1874	case JPEG2000_SIZ:
1875	if (s->ncomponents) {
1876	av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1877	return AVERROR_INVALIDDATA;
1878	}
1879	ret = get_siz(s);
1880	if (!s->tile)
1881	s->numXtiles = s->numYtiles = 0;
1882	break;
1883	case JPEG2000_COC:
1884	ret = get_coc(s, codsty, properties);
1885	break;
1886	case JPEG2000_COD:
1887	ret = get_cod(s, codsty, properties);
1888	break;
1889	case JPEG2000_QCC:
1890	ret = get_qcc(s, len, qntsty, properties);
1891	break;
1892	case JPEG2000_QCD:
1893	ret = get_qcd(s, len, qntsty, properties);
1894	break;
1895	case JPEG2000_POC:
1896	ret = get_poc(s, len, poc);
1897	break;
1898	case JPEG2000_SOT:
1899	if (!(ret = get_sot(s, len))) {
1900	av_assert1(s->curtileno >= 0);
1901	codsty = s->tile[s->curtileno].codsty;
1902	qntsty = s->tile[s->curtileno].qntsty;
1903	poc = &s->tile[s->curtileno].poc;
1904	properties = s->tile[s->curtileno].properties;
1905	}
1906	break;
1907	case JPEG2000_PLM:
1908	// the PLM marker is ignored
1909	case JPEG2000_COM:
1910	// the comment is ignored
1911	bytestream2_skip(&s->g, len - 2);
1912	break;
1913	case JPEG2000_TLM:
1914	// Tile-part lengths
1915	ret = get_tlm(s, len);
1916	break;
1917	case JPEG2000_PLT:
1918	// Packet length, tile-part header
1919	ret = get_plt(s, len);
1920	break;
1921	default:
1922	av_log(s->avctx, AV_LOG_ERROR,
1923	"unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1924	marker, bytestream2_tell(&s->g) - 4);
1925	bytestream2_skip(&s->g, len - 2);
1926	break;
1927	}
1928	if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1929	av_log(s->avctx, AV_LOG_ERROR,
1930	"error during processing marker segment %.4"PRIx16"\n",
1931	marker);
1932	return ret ? ret : -1;
1933	}
1934	}
1935	return 0;
1936	}
1937
1938	/* Read bit stream packets --> T2 operation. */
1939	static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
1940	{
1941	int ret = 0;
1942	int tileno;
1943
1944	for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1945	Jpeg2000Tile *tile = s->tile + tileno;
1946
1947	if ((ret = init_tile(s, tileno)) < 0)
1948	return ret;
1949
1950	s->g = tile->tile_part[0].tpg;
1951	if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
1952	return ret;
1953	}
1954
1955	return 0;
1956	}
1957
1958	static int jp2_find_codestream(Jpeg2000DecoderContext *s)
1959	{
1960	uint32_t atom_size, atom, atom_end;
1961	int search_range = 10;
1962
1963	while (search_range
1964	&&
1965	bytestream2_get_bytes_left(&s->g) >= 8) {
1966	atom_size = bytestream2_get_be32u(&s->g);
1967	atom = bytestream2_get_be32u(&s->g);
1968	atom_end = bytestream2_tell(&s->g) + atom_size - 8;
1969
1970	if (atom == JP2_CODESTREAM)
1971	return 1;
1972
1973	if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
1974	return 0;
1975
1976	if (atom == JP2_HEADER &&
1977	atom_size >= 16) {
1978	uint32_t atom2_size, atom2, atom2_end;
1979	do {
1980	atom2_size = bytestream2_get_be32u(&s->g);
1981	atom2 = bytestream2_get_be32u(&s->g);
1982	atom2_end = bytestream2_tell(&s->g) + atom2_size - 8;
1983	if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
1984	break;
1985	if (atom2 == JP2_CODESTREAM) {
1986	return 1;
1987	} else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
1988	int method = bytestream2_get_byteu(&s->g);
1989	bytestream2_skipu(&s->g, 2);
1990	if (method == 1) {
1991	s->colour_space = bytestream2_get_be32u(&s->g);
1992	}
1993	} else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
1994	int i, size, colour_count, colour_channels, colour_depth[3];
1995	uint32_t r, g, b;
1996	colour_count = bytestream2_get_be16u(&s->g);
1997	colour_channels = bytestream2_get_byteu(&s->g);
1998	// FIXME: Do not ignore channel_sign
1999	colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2000	colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2001	colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2002	size = (colour_depth[0] + 7 >> 3) * colour_count +
2003	(colour_depth[1] + 7 >> 3) * colour_count +
2004	(colour_depth[2] + 7 >> 3) * colour_count;
2005	if (colour_count > 256 ||
2006	colour_channels != 3 ||
2007	colour_depth[0] > 16 ||
2008	colour_depth[1] > 16 ||
2009	colour_depth[2] > 16 ||
2010	atom2_size < size) {
2011	avpriv_request_sample(s->avctx, "Unknown palette");
2012	bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2013	continue;
2014	}
2015	s->pal8 = 1;
2016	for (i = 0; i < colour_count; i++) {
2017	if (colour_depth[0] <= 8) {
2018	r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2019	r |= r >> colour_depth[0];
2020	} else {
2021	r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2022	}
2023	if (colour_depth[1] <= 8) {
2024	g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2025	r |= r >> colour_depth[1];
2026	} else {
2027	g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2028	}
2029	if (colour_depth[2] <= 8) {
2030	b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2031	r |= r >> colour_depth[2];
2032	} else {
2033	b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2034	}
2035	s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2036	}
2037	} else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2038	int n = bytestream2_get_be16u(&s->g);
2039	for (; n>0; n--) {
2040	int cn = bytestream2_get_be16(&s->g);
2041	int av_unused typ = bytestream2_get_be16(&s->g);
2042	int asoc = bytestream2_get_be16(&s->g);
2043	if (cn < 4 && asoc < 4)
2044	s->cdef[cn] = asoc;
2045	}
2046	}
2047	bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2048	} while (atom_end - atom2_end >= 8);
2049	} else {
2050	search_range--;
2051	}
2052	bytestream2_seek(&s->g, atom_end, SEEK_SET);
2053	}
2054
2055	return 0;
2056	}
2057
2058	static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2059	{
2060	Jpeg2000DecoderContext *s = avctx->priv_data;
2061
2062	ff_jpeg2000dsp_init(&s->dsp);
2063
2064	return 0;
2065	}
2066
2067	static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2068	int *got_frame, AVPacket *avpkt)
2069	{
2070	Jpeg2000DecoderContext *s = avctx->priv_data;
2071	ThreadFrame frame = { .f = data };
2072	AVFrame *picture = data;
2073	int ret;
2074
2075	s->avctx = avctx;
2076	bytestream2_init(&s->g, avpkt->data, avpkt->size);
2077	s->curtileno = -1;
2078	memset(s->cdef, -1, sizeof(s->cdef));
2079
2080	if (bytestream2_get_bytes_left(&s->g) < 2) {
2081	ret = AVERROR_INVALIDDATA;
2082	goto end;
2083	}
2084
2085	// check if the image is in jp2 format
2086	if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2087	(bytestream2_get_be32u(&s->g) == 12) &&
2088	(bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2089	(bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2090	if (!jp2_find_codestream(s)) {
2091	av_log(avctx, AV_LOG_ERROR,
2092	"Could not find Jpeg2000 codestream atom.\n");
2093	ret = AVERROR_INVALIDDATA;
2094	goto end;
2095	}
2096	} else {
2097	bytestream2_seek(&s->g, 0, SEEK_SET);
2098	}
2099
2100	while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2101	bytestream2_skip(&s->g, 1);
2102
2103	if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2104	av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2105	ret = AVERROR_INVALIDDATA;
2106	goto end;
2107	}
2108	if (ret = jpeg2000_read_main_headers(s))
2109	goto end;
2110
2111	/* get picture buffer */
2112	if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2113	goto end;
2114	picture->pict_type = AV_PICTURE_TYPE_I;
2115	picture->key_frame = 1;
2116
2117	if (ret = jpeg2000_read_bitstream_packets(s))
2118	goto end;
2119
2120	avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2121
2122	jpeg2000_dec_cleanup(s);
2123
2124	*got_frame = 1;
2125
2126	if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2127	memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2128
2129	return bytestream2_tell(&s->g);
2130
2131	end:
2132	jpeg2000_dec_cleanup(s);
2133	return ret;
2134	}
2135
2136	static av_cold void jpeg2000_init_static_data(AVCodec *codec)
2137	{
2138	ff_jpeg2000_init_tier1_luts();
2139	ff_mqc_init_context_tables();
2140	}
2141
2142	#define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2143	#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2144
2145	static const AVOption options[] = {
2146	{ "lowres", "Lower the decoding resolution by a power of two",
2147	OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2148	{ NULL },
2149	};
2150
2151	static const AVClass jpeg2000_class = {
2152	.class_name = "jpeg2000",
2153	.item_name = av_default_item_name,
2154	.option = options,
2155	.version = LIBAVUTIL_VERSION_INT,
2156	};
2157
2158	AVCodec ff_jpeg2000_decoder = {
2159	.name = "jpeg2000",
2160	.long_name = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2161	.type = AVMEDIA_TYPE_VIDEO,
2162	.id = AV_CODEC_ID_JPEG2000,
2163	.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2164	.priv_data_size = sizeof(Jpeg2000DecoderContext),
2165	.init_static_data = jpeg2000_init_static_data,
2166	.init = jpeg2000_decode_init,
2167	.decode = jpeg2000_decode_frame,
2168	.priv_class = &jpeg2000_class,
2169	.max_lowres = 5,
2170	.profiles = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2171	};
2172