GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/jpeg2000dec.c Lines: 797 1273 62.6 %
Date: 2019-11-20 04:07:19 Branches: 505 965 52.3 %

Line Branch Exec Source
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
#include <math.h>
30
31
#include "libavutil/attributes.h"
32
#include "libavutil/avassert.h"
33
#include "libavutil/common.h"
34
#include "libavutil/imgutils.h"
35
#include "libavutil/opt.h"
36
#include "libavutil/pixdesc.h"
37
#include "libavutil/thread.h"
38
#include "avcodec.h"
39
#include "bytestream.h"
40
#include "internal.h"
41
#include "thread.h"
42
#include "jpeg2000.h"
43
#include "jpeg2000dsp.h"
44
#include "profiles.h"
45
46
#define JP2_SIG_TYPE    0x6A502020
47
#define JP2_SIG_VALUE   0x0D0A870A
48
#define JP2_CODESTREAM  0x6A703263
49
#define JP2_HEADER      0x6A703268
50
51
#define HAD_COC 0x01
52
#define HAD_QCC 0x02
53
54
#define MAX_POCS 32
55
56
typedef struct Jpeg2000POCEntry {
57
    uint16_t LYEpoc;
58
    uint16_t CSpoc;
59
    uint16_t CEpoc;
60
    uint8_t RSpoc;
61
    uint8_t REpoc;
62
    uint8_t Ppoc;
63
} Jpeg2000POCEntry;
64
65
typedef struct Jpeg2000POC {
66
    Jpeg2000POCEntry poc[MAX_POCS];
67
    int nb_poc;
68
    int is_default;
69
} Jpeg2000POC;
70
71
typedef struct Jpeg2000TilePart {
72
    uint8_t tile_index;                 // Tile index who refers the tile-part
73
    const uint8_t *tp_end;
74
    GetByteContext tpg;                 // bit stream in tile-part
75
} Jpeg2000TilePart;
76
77
/* RMK: For JPEG2000 DCINEMA 3 tile-parts in a tile
78
 * one per component, so tile_part elements have a size of 3 */
79
typedef struct Jpeg2000Tile {
80
    Jpeg2000Component   *comp;
81
    uint8_t             properties[4];
82
    Jpeg2000CodingStyle codsty[4];
83
    Jpeg2000QuantStyle  qntsty[4];
84
    Jpeg2000POC         poc;
85
    Jpeg2000TilePart    tile_part[32];
86
    uint16_t tp_idx;                    // Tile-part index
87
    int coord[2][2];                    // border coordinates {{x0, x1}, {y0, y1}}
88
} Jpeg2000Tile;
89
90
typedef struct Jpeg2000DecoderContext {
91
    AVClass         *class;
92
    AVCodecContext  *avctx;
93
    GetByteContext  g;
94
95
    int             width, height;
96
    int             image_offset_x, image_offset_y;
97
    int             tile_offset_x, tile_offset_y;
98
    uint8_t         cbps[4];    // bits per sample in particular components
99
    uint8_t         sgnd[4];    // if a component is signed
100
    uint8_t         properties[4];
101
    int             cdx[4], cdy[4];
102
    int             precision;
103
    int             ncomponents;
104
    int             colour_space;
105
    uint32_t        palette[256];
106
    int8_t          pal8;
107
    int             cdef[4];
108
    int             tile_width, tile_height;
109
    unsigned        numXtiles, numYtiles;
110
    int             maxtilelen;
111
    AVRational      sar;
112
113
    Jpeg2000CodingStyle codsty[4];
114
    Jpeg2000QuantStyle  qntsty[4];
115
    Jpeg2000POC         poc;
116
117
    int             bit_index;
118
119
    int             curtileno;
120
121
    Jpeg2000Tile    *tile;
122
    Jpeg2000DSPContext dsp;
123
124
    /*options parameters*/
125
    int             reduction_factor;
126
} Jpeg2000DecoderContext;
127
128
/* get_bits functions for JPEG2000 packet bitstream
129
 * It is a get_bit function with a bit-stuffing routine. If the value of the
130
 * byte is 0xFF, the next byte includes an extra zero bit stuffed into the MSB.
131
 * cf. ISO-15444-1:2002 / B.10.1 Bit-stuffing routine */
132
4305168
static int get_bits(Jpeg2000DecoderContext *s, int n)
133
{
134
4305168
    int res = 0;
135
136
11521813
    while (--n >= 0) {
137
7216645
        res <<= 1;
138
7216645
        if (s->bit_index == 0) {
139
885441
            s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
140
        }
141
7216645
        s->bit_index--;
142
7216645
        res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
143
    }
144
4305168
    return res;
145
}
146
147
28473
static void jpeg2000_flush(Jpeg2000DecoderContext *s)
148
{
149
28473
    if (bytestream2_get_byte(&s->g) == 0xff)
150
        bytestream2_skip(&s->g, 1);
151
28473
    s->bit_index = 8;
152
28473
}
153
154
/* decode the value stored in node */
155
806199
static int tag_tree_decode(Jpeg2000DecoderContext *s, Jpeg2000TgtNode *node,
156
                           int threshold)
157
{
158
    Jpeg2000TgtNode *stack[30];
159
806199
    int sp = -1, curval = 0;
160
161
806199
    if (!node) {
162
        av_log(s->avctx, AV_LOG_ERROR, "missing node\n");
163
        return AVERROR_INVALIDDATA;
164
    }
165
166

1944689
    while (node && !node->vis) {
167
1138490
        stack[++sp] = node;
168
1138490
        node        = node->parent;
169
    }
170
171
806199
    if (node)
172
652216
        curval = node->val;
173
    else
174
153983
        curval = stack[sp]->val;
175
176

1917636
    while (curval < threshold && sp >= 0) {
177
1111437
        if (curval < stack[sp]->val)
178
1231
            curval = stack[sp]->val;
179
2206627
        while (curval < threshold) {
180
            int ret;
181
2133975
            if ((ret = get_bits(s, 1)) > 0) {
182
1038785
                stack[sp]->vis++;
183
1038785
                break;
184
1095190
            } else if (!ret)
185
1095190
                curval++;
186
            else
187
                return ret;
188
        }
189
1111437
        stack[sp]->val = curval;
190
1111437
        sp--;
191
    }
192
806199
    return curval;
193
}
194
195
824
static int pix_fmt_match(enum AVPixelFormat pix_fmt, int components,
196
                         int bpc, uint32_t log2_chroma_wh, int pal8)
197
{
198
824
    int match = 1;
199
824
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
200
201
    av_assert2(desc);
202
203
824
    if (desc->nb_components != components) {
204
411
        return 0;
205
    }
206
207

413
    switch (components) {
208
2
    case 4:
209
4
        match = match && desc->comp[3].depth >= bpc &&
210

5
                         (log2_chroma_wh >> 14 & 3) == 0 &&
211
1
                         (log2_chroma_wh >> 12 & 3) == 0;
212
413
    case 3:
213
825
        match = match && desc->comp[2].depth >= bpc &&
214

1237
                         (log2_chroma_wh >> 10 & 3) == desc->log2_chroma_w &&
215
412
                         (log2_chroma_wh >>  8 & 3) == desc->log2_chroma_h;
216
413
    case 2:
217
825
        match = match && desc->comp[1].depth >= bpc &&
218

1237
                         (log2_chroma_wh >>  6 & 3) == desc->log2_chroma_w &&
219
412
                         (log2_chroma_wh >>  4 & 3) == desc->log2_chroma_h;
220
221
413
    case 1:
222
825
        match = match && desc->comp[0].depth >= bpc &&
223
412
                         (log2_chroma_wh >>  2 & 3) == 0 &&
224

1237
                         (log2_chroma_wh       & 3) == 0 &&
225
412
                         (desc->flags & AV_PIX_FMT_FLAG_PAL) == pal8 * AV_PIX_FMT_FLAG_PAL;
226
    }
227
413
    return match;
228
}
229
230
// pix_fmts with lower bpp have to be listed before
231
// similar pix_fmts with higher bpp.
232
#define RGB_PIXEL_FORMATS   AV_PIX_FMT_PAL8,AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
233
#define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16,AV_PIX_FMT_YA16
234
#define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
235
                            AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
236
                            AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
237
                            AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
238
                            AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
239
                            AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
240
                            AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
241
                            AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
242
                            AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
243
                            AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
244
                            AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
245
#define XYZ_PIXEL_FORMATS   AV_PIX_FMT_XYZ12
246
247
static const enum AVPixelFormat rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
248
static const enum AVPixelFormat gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
249
static const enum AVPixelFormat yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
250
static const enum AVPixelFormat xyz_pix_fmts[]  = {XYZ_PIXEL_FORMATS,
251
                                                   YUV_PIXEL_FORMATS};
252
static const enum AVPixelFormat all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
253
                                                   GRAY_PIXEL_FORMATS,
254
                                                   YUV_PIXEL_FORMATS,
255
                                                   XYZ_PIXEL_FORMATS};
256
257
/* marker segments */
258
/* get sizes and offsets of image, tiles; number of components */
259
412
static int get_siz(Jpeg2000DecoderContext *s)
260
{
261
    int i;
262
    int ncomponents;
263
412
    uint32_t log2_chroma_wh = 0;
264
412
    const enum AVPixelFormat *possible_fmts = NULL;
265
412
    int possible_fmts_nb = 0;
266
    int ret;
267
268
412
    if (bytestream2_get_bytes_left(&s->g) < 36) {
269
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for SIZ\n");
270
        return AVERROR_INVALIDDATA;
271
    }
272
273
412
    s->avctx->profile = bytestream2_get_be16u(&s->g); // Rsiz
274
412
    s->width          = bytestream2_get_be32u(&s->g); // Width
275
412
    s->height         = bytestream2_get_be32u(&s->g); // Height
276
412
    s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
277
412
    s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
278
412
    s->tile_width     = bytestream2_get_be32u(&s->g); // XTSiz
279
412
    s->tile_height    = bytestream2_get_be32u(&s->g); // YTSiz
280
412
    s->tile_offset_x  = bytestream2_get_be32u(&s->g); // XT0Siz
281
412
    s->tile_offset_y  = bytestream2_get_be32u(&s->g); // YT0Siz
282
412
    ncomponents       = bytestream2_get_be16u(&s->g); // CSiz
283
284

412
    if (s->image_offset_x || s->image_offset_y) {
285
        avpriv_request_sample(s->avctx, "Support for image offsets");
286
        return AVERROR_PATCHWELCOME;
287
    }
288
412
    if (av_image_check_size2(s->width, s->height, s->avctx->max_pixels, AV_PIX_FMT_NONE, 0, s->avctx)) {
289
        avpriv_request_sample(s->avctx, "Large Dimensions");
290
        return AVERROR_PATCHWELCOME;
291
    }
292
293
412
    if (ncomponents <= 0) {
294
        av_log(s->avctx, AV_LOG_ERROR, "Invalid number of components: %d\n",
295
               s->ncomponents);
296
        return AVERROR_INVALIDDATA;
297
    }
298
299
412
    if (ncomponents > 4) {
300
        avpriv_request_sample(s->avctx, "Support for %d components",
301
                              ncomponents);
302
        return AVERROR_PATCHWELCOME;
303
    }
304
305

412
    if (s->tile_offset_x < 0 || s->tile_offset_y < 0 ||
306
412
        s->image_offset_x < s->tile_offset_x ||
307
412
        s->image_offset_y < s->tile_offset_y ||
308
412
        s->tile_width  + (int64_t)s->tile_offset_x <= s->image_offset_x ||
309
412
        s->tile_height + (int64_t)s->tile_offset_y <= s->image_offset_y
310
    ) {
311
        av_log(s->avctx, AV_LOG_ERROR, "Tile offsets are invalid\n");
312
        return AVERROR_INVALIDDATA;
313
    }
314
315
412
    s->ncomponents = ncomponents;
316
317

412
    if (s->tile_width <= 0 || s->tile_height <= 0) {
318
        av_log(s->avctx, AV_LOG_ERROR, "Invalid tile dimension %dx%d.\n",
319
               s->tile_width, s->tile_height);
320
        return AVERROR_INVALIDDATA;
321
    }
322
323
412
    if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents) {
324
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for %d components in SIZ\n", s->ncomponents);
325
        return AVERROR_INVALIDDATA;
326
    }
327
328
1649
    for (i = 0; i < s->ncomponents; i++) { // Ssiz_i XRsiz_i, YRsiz_i
329
1237
        uint8_t x    = bytestream2_get_byteu(&s->g);
330
1237
        s->cbps[i]   = (x & 0x7f) + 1;
331
1237
        s->precision = FFMAX(s->cbps[i], s->precision);
332
1237
        s->sgnd[i]   = !!(x & 0x80);
333
1237
        s->cdx[i]    = bytestream2_get_byteu(&s->g);
334
1237
        s->cdy[i]    = bytestream2_get_byteu(&s->g);
335

1237
        if (   !s->cdx[i] || s->cdx[i] == 3 || s->cdx[i] > 4
336

1237
            || !s->cdy[i] || s->cdy[i] == 3 || s->cdy[i] > 4) {
337
            av_log(s->avctx, AV_LOG_ERROR, "Invalid sample separation %d/%d\n", s->cdx[i], s->cdy[i]);
338
            return AVERROR_INVALIDDATA;
339
        }
340
1237
        log2_chroma_wh |= s->cdy[i] >> 1 << i * 4 | s->cdx[i] >> 1 << i * 4 + 2;
341
    }
342
343
412
    s->numXtiles = ff_jpeg2000_ceildiv(s->width  - s->tile_offset_x, s->tile_width);
344
412
    s->numYtiles = ff_jpeg2000_ceildiv(s->height - s->tile_offset_y, s->tile_height);
345
346
    // There must be at least a SOT and SOD per tile, their minimum size is 14
347
412
    if (s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(*s->tile) ||
348
412
        s->numXtiles * s->numYtiles * 14LL > bytestream2_size(&s->g)
349
    ) {
350
        s->numXtiles = s->numYtiles = 0;
351
        return AVERROR(EINVAL);
352
    }
353
354
412
    s->tile = av_mallocz_array(s->numXtiles * s->numYtiles, sizeof(*s->tile));
355
412
    if (!s->tile) {
356
        s->numXtiles = s->numYtiles = 0;
357
        return AVERROR(ENOMEM);
358
    }
359
360
1743
    for (i = 0; i < s->numXtiles * s->numYtiles; i++) {
361
1331
        Jpeg2000Tile *tile = s->tile + i;
362
363
1331
        tile->comp = av_mallocz(s->ncomponents * sizeof(*tile->comp));
364
1331
        if (!tile->comp)
365
            return AVERROR(ENOMEM);
366
    }
367
368
    /* compute image size with reduction factor */
369
412
    ret = ff_set_dimensions(s->avctx,
370
412
            ff_jpeg2000_ceildivpow2(s->width  - s->image_offset_x,
371
                                               s->reduction_factor),
372
412
            ff_jpeg2000_ceildivpow2(s->height - s->image_offset_y,
373
                                               s->reduction_factor));
374
412
    if (ret < 0)
375
        return ret;
376
377
412
    if (s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_2K ||
378
409
        s->avctx->profile == FF_PROFILE_JPEG2000_DCINEMA_4K) {
379
3
        possible_fmts = xyz_pix_fmts;
380
3
        possible_fmts_nb = FF_ARRAY_ELEMS(xyz_pix_fmts);
381
    } else {
382

409
        switch (s->colour_space) {
383
409
        case 16:
384
409
            possible_fmts = rgb_pix_fmts;
385
409
            possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
386
409
            break;
387
        case 17:
388
            possible_fmts = gray_pix_fmts;
389
            possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
390
            break;
391
        case 18:
392
            possible_fmts = yuv_pix_fmts;
393
            possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
394
            break;
395
        default:
396
            possible_fmts = all_pix_fmts;
397
            possible_fmts_nb = FF_ARRAY_ELEMS(all_pix_fmts);
398
            break;
399
        }
400
    }
401
824
    for (i = 0; i < possible_fmts_nb; ++i) {
402
824
        if (pix_fmt_match(possible_fmts[i], ncomponents, s->precision, log2_chroma_wh, s->pal8)) {
403
412
            s->avctx->pix_fmt = possible_fmts[i];
404
412
            break;
405
        }
406
    }
407
408
412
    if (i == possible_fmts_nb) {
409
        if (ncomponents == 4 &&
410
            s->cdy[0] == 1 && s->cdx[0] == 1 &&
411
            s->cdy[1] == 1 && s->cdx[1] == 1 &&
412
            s->cdy[2] == s->cdy[3] && s->cdx[2] == s->cdx[3]) {
413
            if (s->precision == 8 && s->cdy[2] == 2 && s->cdx[2] == 2 && !s->pal8) {
414
                s->avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
415
                s->cdef[0] = 0;
416
                s->cdef[1] = 1;
417
                s->cdef[2] = 2;
418
                s->cdef[3] = 3;
419
                i = 0;
420
            }
421
        }
422
    }
423
424
425
412
    if (i == possible_fmts_nb) {
426
        av_log(s->avctx, AV_LOG_ERROR,
427
               "Unknown pix_fmt, profile: %d, colour_space: %d, "
428
               "components: %d, precision: %d\n"
429
               "cdx[0]: %d, cdy[0]: %d\n"
430
               "cdx[1]: %d, cdy[1]: %d\n"
431
               "cdx[2]: %d, cdy[2]: %d\n"
432
               "cdx[3]: %d, cdy[3]: %d\n",
433
               s->avctx->profile, s->colour_space, ncomponents, s->precision,
434
               s->cdx[0],
435
               s->cdy[0],
436
               ncomponents > 1 ? s->cdx[1] : 0,
437
               ncomponents > 1 ? s->cdy[1] : 0,
438
               ncomponents > 2 ? s->cdx[2] : 0,
439
               ncomponents > 2 ? s->cdy[2] : 0,
440
               ncomponents > 3 ? s->cdx[3] : 0,
441
               ncomponents > 3 ? s->cdy[3] : 0);
442
        return AVERROR_PATCHWELCOME;
443
    }
444
412
    s->avctx->bits_per_raw_sample = s->precision;
445
412
    return 0;
446
}
447
448
/* get common part for COD and COC segments */
449
418
static int get_cox(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c)
450
{
451
    uint8_t byte;
452
453
418
    if (bytestream2_get_bytes_left(&s->g) < 5) {
454
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COX\n");
455
        return AVERROR_INVALIDDATA;
456
    }
457
458
    /*  nreslevels = number of resolution levels
459
                   = number of decomposition level +1 */
460
418
    c->nreslevels = bytestream2_get_byteu(&s->g) + 1;
461
418
    if (c->nreslevels >= JPEG2000_MAX_RESLEVELS) {
462
        av_log(s->avctx, AV_LOG_ERROR, "nreslevels %d is invalid\n", c->nreslevels);
463
        return AVERROR_INVALIDDATA;
464
    }
465
466
418
    if (c->nreslevels <= s->reduction_factor) {
467
        /* we are forced to update reduction_factor as its requested value is
468
           not compatible with this bitstream, and as we might have used it
469
           already in setup earlier we have to fail this frame until
470
           reinitialization is implemented */
471
        av_log(s->avctx, AV_LOG_ERROR, "reduction_factor too large for this bitstream, max is %d\n", c->nreslevels - 1);
472
        s->reduction_factor = c->nreslevels - 1;
473
        return AVERROR(EINVAL);
474
    }
475
476
    /* compute number of resolution levels to decode */
477
418
    c->nreslevels2decode = c->nreslevels - s->reduction_factor;
478
479
418
    c->log2_cblk_width  = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk width
480
418
    c->log2_cblk_height = (bytestream2_get_byteu(&s->g) & 15) + 2; // cblk height
481
482

418
    if (c->log2_cblk_width > 10 || c->log2_cblk_height > 10 ||
483
418
        c->log2_cblk_width + c->log2_cblk_height > 12) {
484
        av_log(s->avctx, AV_LOG_ERROR, "cblk size invalid\n");
485
        return AVERROR_INVALIDDATA;
486
    }
487
488
418
    c->cblk_style = bytestream2_get_byteu(&s->g);
489
418
    if (c->cblk_style != 0) { // cblk style
490
        av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
491
        if (c->cblk_style & JPEG2000_CBLK_BYPASS)
492
            av_log(s->avctx, AV_LOG_WARNING, "Selective arithmetic coding bypass\n");
493
    }
494
418
    c->transform = bytestream2_get_byteu(&s->g); // DWT transformation type
495
    /* set integer 9/7 DWT in case of BITEXACT flag */
496

418
    if ((s->avctx->flags & AV_CODEC_FLAG_BITEXACT) && (c->transform == FF_DWT97))
497
213
        c->transform = FF_DWT97_INT;
498
205
    else if (c->transform == FF_DWT53) {
499
204
        s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
500
    }
501
502
418
    if (c->csty & JPEG2000_CSTY_PREC) {
503
        int i;
504
63
        for (i = 0; i < c->nreslevels; i++) {
505
54
            byte = bytestream2_get_byte(&s->g);
506
54
            c->log2_prec_widths[i]  =  byte       & 0x0F;    // precinct PPx
507
54
            c->log2_prec_heights[i] = (byte >> 4) & 0x0F;    // precinct PPy
508
54
            if (i)
509

45
                if (c->log2_prec_widths[i] == 0 || c->log2_prec_heights[i] == 0) {
510
                    av_log(s->avctx, AV_LOG_ERROR, "PPx %d PPy %d invalid\n",
511
                           c->log2_prec_widths[i], c->log2_prec_heights[i]);
512
                    c->log2_prec_widths[i] = c->log2_prec_heights[i] = 1;
513
                    return AVERROR_INVALIDDATA;
514
                }
515
        }
516
    } else {
517
409
        memset(c->log2_prec_widths , 15, sizeof(c->log2_prec_widths ));
518
409
        memset(c->log2_prec_heights, 15, sizeof(c->log2_prec_heights));
519
    }
520
418
    return 0;
521
}
522
523
/* get coding parameters for a particular tile or whole image*/
524
412
static int get_cod(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
525
                   uint8_t *properties)
526
{
527
    Jpeg2000CodingStyle tmp;
528
    int compno, ret;
529
530
412
    if (bytestream2_get_bytes_left(&s->g) < 5) {
531
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COD\n");
532
        return AVERROR_INVALIDDATA;
533
    }
534
535
412
    tmp.csty = bytestream2_get_byteu(&s->g);
536
537
    // get progression order
538
412
    tmp.prog_order = bytestream2_get_byteu(&s->g);
539
540
412
    tmp.nlayers    = bytestream2_get_be16u(&s->g);
541
412
    tmp.mct        = bytestream2_get_byteu(&s->g); // multiple component transformation
542
543

412
    if (tmp.mct && s->ncomponents < 3) {
544
        av_log(s->avctx, AV_LOG_ERROR,
545
               "MCT %"PRIu8" with too few components (%d)\n",
546
               tmp.mct, s->ncomponents);
547
        return AVERROR_INVALIDDATA;
548
    }
549
550
412
    if ((ret = get_cox(s, &tmp)) < 0)
551
        return ret;
552
553
1649
    for (compno = 0; compno < s->ncomponents; compno++)
554
1237
        if (!(properties[compno] & HAD_COC))
555
1237
            memcpy(c + compno, &tmp, sizeof(tmp));
556
412
    return 0;
557
}
558
559
/* Get coding parameters for a component in the whole image or a
560
 * particular tile. */
561
6
static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
562
                   uint8_t *properties)
563
{
564
    int compno, ret;
565
566
6
    if (bytestream2_get_bytes_left(&s->g) < 2) {
567
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for COC\n");
568
        return AVERROR_INVALIDDATA;
569
    }
570
571
6
    compno = bytestream2_get_byteu(&s->g);
572
573
6
    if (compno >= s->ncomponents) {
574
        av_log(s->avctx, AV_LOG_ERROR,
575
               "Invalid compno %d. There are %d components in the image.\n",
576
               compno, s->ncomponents);
577
        return AVERROR_INVALIDDATA;
578
    }
579
580
6
    c      += compno;
581
6
    c->csty = bytestream2_get_byteu(&s->g);
582
583
6
    if ((ret = get_cox(s, c)) < 0)
584
        return ret;
585
586
6
    properties[compno] |= HAD_COC;
587
6
    return 0;
588
}
589
590
/* Get common part for QCD and QCC segments. */
591
421
static int get_qcx(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q)
592
{
593
    int i, x;
594
595
421
    if (bytestream2_get_bytes_left(&s->g) < 1)
596
        return AVERROR_INVALIDDATA;
597
598
421
    x = bytestream2_get_byteu(&s->g); // Sqcd
599
600
421
    q->nguardbits = x >> 5;
601
421
    q->quantsty   = x & 0x1f;
602
603
421
    if (q->quantsty == JPEG2000_QSTY_NONE) {
604
204
        n -= 3;
605

204
        if (bytestream2_get_bytes_left(&s->g) < n ||
606
            n > JPEG2000_MAX_DECLEVELS*3)
607
            return AVERROR_INVALIDDATA;
608
4080
        for (i = 0; i < n; i++)
609
3876
            q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
610
217
    } else if (q->quantsty == JPEG2000_QSTY_SI) {
611
        if (bytestream2_get_bytes_left(&s->g) < 2)
612
            return AVERROR_INVALIDDATA;
613
        x          = bytestream2_get_be16u(&s->g);
614
        q->expn[0] = x >> 11;
615
        q->mant[0] = x & 0x7ff;
616
        for (i = 1; i < JPEG2000_MAX_DECLEVELS * 3; i++) {
617
            int curexpn = FFMAX(0, q->expn[0] - (i - 1) / 3);
618
            q->expn[i] = curexpn;
619
            q->mant[i] = q->mant[0];
620
        }
621
    } else {
622
217
        n = (n - 3) >> 1;
623

217
        if (bytestream2_get_bytes_left(&s->g) < 2 * n ||
624
            n > JPEG2000_MAX_DECLEVELS*3)
625
            return AVERROR_INVALIDDATA;
626
4301
        for (i = 0; i < n; i++) {
627
4084
            x          = bytestream2_get_be16u(&s->g);
628
4084
            q->expn[i] = x >> 11;
629
4084
            q->mant[i] = x & 0x7ff;
630
        }
631
    }
632
421
    return 0;
633
}
634
635
/* Get quantization parameters for a particular tile or a whole image. */
636
412
static int get_qcd(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
637
                   uint8_t *properties)
638
{
639
    Jpeg2000QuantStyle tmp;
640
    int compno, ret;
641
642
412
    memset(&tmp, 0, sizeof(tmp));
643
644
412
    if ((ret = get_qcx(s, n, &tmp)) < 0)
645
        return ret;
646
1649
    for (compno = 0; compno < s->ncomponents; compno++)
647
1237
        if (!(properties[compno] & HAD_QCC))
648
1237
            memcpy(q + compno, &tmp, sizeof(tmp));
649
412
    return 0;
650
}
651
652
/* Get quantization parameters for a component in the whole image
653
 * on in a particular tile. */
654
9
static int get_qcc(Jpeg2000DecoderContext *s, int n, Jpeg2000QuantStyle *q,
655
                   uint8_t *properties)
656
{
657
    int compno;
658
659
9
    if (bytestream2_get_bytes_left(&s->g) < 1)
660
        return AVERROR_INVALIDDATA;
661
662
9
    compno = bytestream2_get_byteu(&s->g);
663
664
9
    if (compno >= s->ncomponents) {
665
        av_log(s->avctx, AV_LOG_ERROR,
666
               "Invalid compno %d. There are %d components in the image.\n",
667
               compno, s->ncomponents);
668
        return AVERROR_INVALIDDATA;
669
    }
670
671
9
    properties[compno] |= HAD_QCC;
672
9
    return get_qcx(s, n - 1, q + compno);
673
}
674
675
static int get_poc(Jpeg2000DecoderContext *s, int size, Jpeg2000POC *p)
676
{
677
    int i;
678
    int elem_size = s->ncomponents <= 257 ? 7 : 9;
679
    Jpeg2000POC tmp = {{{0}}};
680
681
    if (bytestream2_get_bytes_left(&s->g) < 5 || size < 2 + elem_size) {
682
        av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
683
        return AVERROR_INVALIDDATA;
684
    }
685
686
    if (elem_size > 7) {
687
        avpriv_request_sample(s->avctx, "Fat POC not supported");
688
        return AVERROR_PATCHWELCOME;
689
    }
690
691
    tmp.nb_poc = (size - 2) / elem_size;
692
    if (tmp.nb_poc > MAX_POCS) {
693
        avpriv_request_sample(s->avctx, "Too many POCs (%d)", tmp.nb_poc);
694
        return AVERROR_PATCHWELCOME;
695
    }
696
697
    for (i = 0; i<tmp.nb_poc; i++) {
698
        Jpeg2000POCEntry *e = &tmp.poc[i];
699
        e->RSpoc  = bytestream2_get_byteu(&s->g);
700
        e->CSpoc  = bytestream2_get_byteu(&s->g);
701
        e->LYEpoc = bytestream2_get_be16u(&s->g);
702
        e->REpoc  = bytestream2_get_byteu(&s->g);
703
        e->CEpoc  = bytestream2_get_byteu(&s->g);
704
        e->Ppoc   = bytestream2_get_byteu(&s->g);
705
        if (!e->CEpoc)
706
            e->CEpoc = 256;
707
        if (e->CEpoc > s->ncomponents)
708
            e->CEpoc = s->ncomponents;
709
        if (   e->RSpoc >= e->REpoc || e->REpoc > 33
710
            || e->CSpoc >= e->CEpoc || e->CEpoc > s->ncomponents
711
            || !e->LYEpoc) {
712
            av_log(s->avctx, AV_LOG_ERROR, "POC Entry %d is invalid (%d, %d, %d, %d, %d, %d)\n", i,
713
                e->RSpoc, e->CSpoc, e->LYEpoc, e->REpoc, e->CEpoc, e->Ppoc
714
            );
715
            return AVERROR_INVALIDDATA;
716
        }
717
    }
718
719
    if (!p->nb_poc || p->is_default) {
720
        *p = tmp;
721
    } else {
722
        if (p->nb_poc + tmp.nb_poc > MAX_POCS) {
723
            av_log(s->avctx, AV_LOG_ERROR, "Insufficient space for POC\n");
724
            return AVERROR_INVALIDDATA;
725
        }
726
        memcpy(p->poc + p->nb_poc, tmp.poc, tmp.nb_poc * sizeof(tmp.poc[0]));
727
        p->nb_poc += tmp.nb_poc;
728
    }
729
730
    p->is_default = 0;
731
732
    return 0;
733
}
734
735
736
/* Get start of tile segment. */
737
1343
static int get_sot(Jpeg2000DecoderContext *s, int n)
738
{
739
    Jpeg2000TilePart *tp;
740
    uint16_t Isot;
741
    uint32_t Psot;
742
    unsigned TPsot;
743
744
1343
    if (bytestream2_get_bytes_left(&s->g) < 8)
745
        return AVERROR_INVALIDDATA;
746
747
1343
    s->curtileno = 0;
748
1343
    Isot = bytestream2_get_be16u(&s->g);        // Isot
749
1343
    if (Isot >= s->numXtiles * s->numYtiles)
750
        return AVERROR_INVALIDDATA;
751
752
1343
    s->curtileno = Isot;
753
1343
    Psot  = bytestream2_get_be32u(&s->g);       // Psot
754
1343
    TPsot = bytestream2_get_byteu(&s->g);       // TPsot
755
756
    /* Read TNSot but not used */
757
1343
    bytestream2_get_byteu(&s->g);               // TNsot
758
759
1343
    if (!Psot)
760
        Psot = bytestream2_get_bytes_left(&s->g) - 2 + n + 2;
761
762
1343
    if (Psot > bytestream2_get_bytes_left(&s->g) - 2 + n + 2) {
763
        av_log(s->avctx, AV_LOG_ERROR, "Psot %"PRIu32" too big\n", Psot);
764
        return AVERROR_INVALIDDATA;
765
    }
766
767
1343
    if (TPsot >= FF_ARRAY_ELEMS(s->tile[Isot].tile_part)) {
768
        avpriv_request_sample(s->avctx, "Too many tile parts");
769
        return AVERROR_PATCHWELCOME;
770
    }
771
772
1343
    s->tile[Isot].tp_idx = TPsot;
773
1343
    tp             = s->tile[Isot].tile_part + TPsot;
774
1343
    tp->tile_index = Isot;
775
1343
    tp->tp_end     = s->g.buffer + Psot - n - 2;
776
777
1343
    if (!TPsot) {
778
1331
        Jpeg2000Tile *tile = s->tile + s->curtileno;
779
780
        /* copy defaults */
781
1331
        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(Jpeg2000CodingStyle));
782
1331
        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(Jpeg2000QuantStyle));
783
1331
        memcpy(&tile->poc  , &s->poc  , sizeof(tile->poc));
784
1331
        tile->poc.is_default = 1;
785
    }
786
787
1343
    return 0;
788
}
789
790
/* Tile-part lengths: see ISO 15444-1:2002, section A.7.1
791
 * Used to know the number of tile parts and lengths.
792
 * There may be multiple TLMs in the header.
793
 * TODO: The function is not used for tile-parts management, nor anywhere else.
794
 * It can be useful to allocate memory for tile parts, before managing the SOT
795
 * markers. Parsing the TLM header is needed to increment the input header
796
 * buffer.
797
 * This marker is mandatory for DCI. */
798
4
static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n)
799
{
800
    uint8_t Stlm, ST, SP, tile_tlm, i;
801
4
    bytestream2_get_byte(&s->g);               /* Ztlm: skipped */
802
4
    Stlm = bytestream2_get_byte(&s->g);
803
804
    // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02);
805
4
    ST = (Stlm >> 4) & 0x03;
806
    // TODO: Manage case of ST = 0b11 --> raise error
807
4
    SP       = (Stlm >> 6) & 0x01;
808
4
    tile_tlm = (n - 4) / ((SP + 1) * 2 + ST);
809
21
    for (i = 0; i < tile_tlm; i++) {
810

17
        switch (ST) {
811
        case 0:
812
            break;
813
17
        case 1:
814
17
            bytestream2_get_byte(&s->g);
815
17
            break;
816
        case 2:
817
            bytestream2_get_be16(&s->g);
818
            break;
819
        case 3:
820
            bytestream2_get_be32(&s->g);
821
            break;
822
        }
823
17
        if (SP == 0) {
824
            bytestream2_get_be16(&s->g);
825
        } else {
826
17
            bytestream2_get_be32(&s->g);
827
        }
828
    }
829
4
    return 0;
830
}
831
832
static int get_plt(Jpeg2000DecoderContext *s, int n)
833
{
834
    int i;
835
    int v;
836
837
    av_log(s->avctx, AV_LOG_DEBUG,
838
            "PLT marker at pos 0x%X\n", bytestream2_tell(&s->g) - 4);
839
840
    if (n < 4)
841
        return AVERROR_INVALIDDATA;
842
843
    /*Zplt =*/ bytestream2_get_byte(&s->g);
844
845
    for (i = 0; i < n - 3; i++) {
846
        v = bytestream2_get_byte(&s->g);
847
    }
848
    if (v & 0x80)
849
        return AVERROR_INVALIDDATA;
850
851
    return 0;
852
}
853
854
1331
static int init_tile(Jpeg2000DecoderContext *s, int tileno)
855
{
856
    int compno;
857
1331
    int tilex = tileno % s->numXtiles;
858
1331
    int tiley = tileno / s->numXtiles;
859
1331
    Jpeg2000Tile *tile = s->tile + tileno;
860
861
1331
    if (!tile->comp)
862
        return AVERROR(ENOMEM);
863
864
1331
    tile->coord[0][0] = av_clip(tilex       * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
865
1331
    tile->coord[0][1] = av_clip((tilex + 1) * (int64_t)s->tile_width  + s->tile_offset_x, s->image_offset_x, s->width);
866
1331
    tile->coord[1][0] = av_clip(tiley       * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
867
1331
    tile->coord[1][1] = av_clip((tiley + 1) * (int64_t)s->tile_height + s->tile_offset_y, s->image_offset_y, s->height);
868
869
5326
    for (compno = 0; compno < s->ncomponents; compno++) {
870
3995
        Jpeg2000Component *comp = tile->comp + compno;
871
3995
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
872
3995
        Jpeg2000QuantStyle  *qntsty = tile->qntsty + compno;
873
        int ret; // global bandno
874
875
3995
        comp->coord_o[0][0] = tile->coord[0][0];
876
3995
        comp->coord_o[0][1] = tile->coord[0][1];
877
3995
        comp->coord_o[1][0] = tile->coord[1][0];
878
3995
        comp->coord_o[1][1] = tile->coord[1][1];
879
3995
        if (compno) {
880
2664
            comp->coord_o[0][0] /= s->cdx[compno];
881
2664
            comp->coord_o[0][1] /= s->cdx[compno];
882
2664
            comp->coord_o[1][0] /= s->cdy[compno];
883
2664
            comp->coord_o[1][1] /= s->cdy[compno];
884
        }
885
886
3995
        comp->coord[0][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], s->reduction_factor);
887
3995
        comp->coord[0][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[0][1], s->reduction_factor);
888
3995
        comp->coord[1][0] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], s->reduction_factor);
889
3995
        comp->coord[1][1] = ff_jpeg2000_ceildivpow2(comp->coord_o[1][1], s->reduction_factor);
890
891
3995
        if (ret = ff_jpeg2000_init_component(comp, codsty, qntsty,
892
3995
                                             s->cbps[compno], s->cdx[compno],
893
                                             s->cdy[compno], s->avctx))
894
            return ret;
895
    }
896
1331
    return 0;
897
}
898
899
/* Read the number of coding passes. */
900
364564
static int getnpasses(Jpeg2000DecoderContext *s)
901
{
902
    int num;
903
364564
    if (!get_bits(s, 1))
904
21434
        return 1;
905
343130
    if (!get_bits(s, 1))
906
12976
        return 2;
907
330154
    if ((num = get_bits(s, 2)) != 3)
908
110502
        return num < 0 ? num : 3 + num;
909
219652
    if ((num = get_bits(s, 5)) != 31)
910
219649
        return num < 0 ? num : 6 + num;
911
3
    num = get_bits(s, 7);
912
3
    return num < 0 ? num : 37 + num;
913
}
914
915
364564
static int getlblockinc(Jpeg2000DecoderContext *s)
916
{
917
364564
    int res = 0, ret;
918
518597
    while (ret = get_bits(s, 1)) {
919
154033
        if (ret < 0)
920
            return ret;
921
154033
        res++;
922
    }
923
364564
    return res;
924
}
925
926
28473
static int jpeg2000_decode_packet(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile, int *tp_index,
927
                                  Jpeg2000CodingStyle *codsty,
928
                                  Jpeg2000ResLevel *rlevel, int precno,
929
                                  int layno, uint8_t *expn, int numgbits)
930
{
931
    int bandno, cblkno, ret, nb_code_blocks;
932
    int cwsno;
933
934
28473
    if (layno < rlevel->band[0].prec[precno].decoded_layers)
935
        return 0;
936
28473
    rlevel->band[0].prec[precno].decoded_layers = layno + 1;
937
938

28473
    if (bytestream2_get_bytes_left(&s->g) == 0 && s->bit_index == 8) {
939
12
        if (*tp_index < FF_ARRAY_ELEMS(tile->tile_part) - 1) {
940
12
            s->g = tile->tile_part[++(*tp_index)].tpg;
941
        }
942
    }
943
944
28473
    if (bytestream2_peek_be32(&s->g) == JPEG2000_SOP_FIXED_BYTES)
945
        bytestream2_skip(&s->g, JPEG2000_SOP_BYTE_LENGTH);
946
947
28473
    if (!(ret = get_bits(s, 1))) {
948
        jpeg2000_flush(s);
949
        return 0;
950
28473
    } else if (ret < 0)
951
        return ret;
952
953
105886
    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
954
77413
        Jpeg2000Band *band = rlevel->band + bandno;
955
77413
        Jpeg2000Prec *prec = band->prec + precno;
956
957
77413
        if (band->coord[0][0] == band->coord[0][1] ||
958
77413
            band->coord[1][0] == band->coord[1][1])
959
3672
            continue;
960
73741
        nb_code_blocks =  prec->nb_codeblocks_height *
961
73741
                          prec->nb_codeblocks_width;
962
519268
        for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
963
445527
            Jpeg2000Cblk *cblk = prec->cblk + cblkno;
964
            int incl, newpasses, llen;
965
            void *tmp;
966
967
445527
            if (cblk->npasses)
968
2056
                incl = get_bits(s, 1);
969
            else
970
443471
                incl = tag_tree_decode(s, prec->cblkincl + cblkno, layno + 1) == layno;
971
445527
            if (!incl)
972
80963
                continue;
973
364564
            else if (incl < 0)
974
                return incl;
975
976
364564
            if (!cblk->npasses) {
977
725456
                int v = expn[bandno] + numgbits - 1 -
978
362728
                        tag_tree_decode(s, prec->zerobits + cblkno, 100);
979

362728
                if (v < 0 || v > 30) {
980
                    av_log(s->avctx, AV_LOG_ERROR,
981
                           "nonzerobits %d invalid or unsupported\n", v);
982
                    return AVERROR_INVALIDDATA;
983
                }
984
362728
                cblk->nonzerobits = v;
985
            }
986
364564
            if ((newpasses = getnpasses(s)) < 0)
987
                return newpasses;
988
            av_assert2(newpasses > 0);
989
364564
            if (cblk->npasses + newpasses >= JPEG2000_MAX_PASSES) {
990
                avpriv_request_sample(s->avctx, "Too many passes");
991
                return AVERROR_PATCHWELCOME;
992
            }
993
364564
            if ((llen = getlblockinc(s)) < 0)
994
                return llen;
995
364564
            if (cblk->lblock + llen + av_log2(newpasses) > 16) {
996
                avpriv_request_sample(s->avctx,
997
                                      "Block with length beyond 16 bits");
998
                return AVERROR_PATCHWELCOME;
999
            }
1000
1001
364564
            cblk->lblock += llen;
1002
1003
364564
            cblk->nb_lengthinc = 0;
1004
364564
            cblk->nb_terminationsinc = 0;
1005
364564
            av_free(cblk->lengthinc);
1006
364564
            cblk->lengthinc  = av_mallocz_array(newpasses    , sizeof(*cblk->lengthinc));
1007
364564
            if (!cblk->lengthinc)
1008
                return AVERROR(ENOMEM);
1009
364564
            tmp = av_realloc_array(cblk->data_start, cblk->nb_terminations + newpasses + 1, sizeof(*cblk->data_start));
1010
364564
            if (!tmp)
1011
                return AVERROR(ENOMEM);
1012
364564
            cblk->data_start = tmp;
1013
            do {
1014
364564
                int newpasses1 = 0;
1015
1016
3089579
                while (newpasses1 < newpasses) {
1017
2725015
                    newpasses1 ++;
1018
2725015
                    if (needs_termination(codsty->cblk_style, cblk->npasses + newpasses1 - 1)) {
1019
                        cblk->nb_terminationsinc ++;
1020
                        break;
1021
                    }
1022
                }
1023
1024
364564
                if ((ret = get_bits(s, av_log2(newpasses1) + cblk->lblock)) < 0)
1025
                    return ret;
1026
364564
                if (ret > cblk->data_allocated) {
1027
363060
                    size_t new_size = FFMAX(2*cblk->data_allocated, ret);
1028
363060
                    void *new = av_realloc(cblk->data, new_size);
1029
363060
                    if (new) {
1030
363060
                        cblk->data = new;
1031
363060
                        cblk->data_allocated = new_size;
1032
                    }
1033
                }
1034
364564
                if (ret > cblk->data_allocated) {
1035
                    avpriv_request_sample(s->avctx,
1036
                                        "Block with lengthinc greater than %"SIZE_SPECIFIER"",
1037
                                        cblk->data_allocated);
1038
                    return AVERROR_PATCHWELCOME;
1039
                }
1040
364564
                cblk->lengthinc[cblk->nb_lengthinc++] = ret;
1041
364564
                cblk->npasses  += newpasses1;
1042
364564
                newpasses -= newpasses1;
1043
364564
            } while(newpasses);
1044
        }
1045
    }
1046
28473
    jpeg2000_flush(s);
1047
1048
28473
    if (codsty->csty & JPEG2000_CSTY_EPH) {
1049
        if (bytestream2_peek_be16(&s->g) == JPEG2000_EPH)
1050
            bytestream2_skip(&s->g, 2);
1051
        else
1052
            av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found. instead %X\n", bytestream2_peek_be32(&s->g));
1053
    }
1054
1055
105886
    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1056
77413
        Jpeg2000Band *band = rlevel->band + bandno;
1057
77413
        Jpeg2000Prec *prec = band->prec + precno;
1058
1059
77413
        nb_code_blocks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
1060
526612
        for (cblkno = 0; cblkno < nb_code_blocks; cblkno++) {
1061
449199
            Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1062

449199
            if (!cblk->nb_terminationsinc && !cblk->lengthinc)
1063
84635
                continue;
1064
729128
            for (cwsno = 0; cwsno < cblk->nb_lengthinc; cwsno ++) {
1065
364564
                if (cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4) {
1066
364272
                    size_t new_size = FFMAX(2*cblk->data_allocated, cblk->length + cblk->lengthinc[cwsno] + 4);
1067
364272
                    void *new = av_realloc(cblk->data, new_size);
1068
364272
                    if (new) {
1069
364272
                        cblk->data = new;
1070
364272
                        cblk->data_allocated = new_size;
1071
                    }
1072
                }
1073
364564
                if (   bytestream2_get_bytes_left(&s->g) < cblk->lengthinc[cwsno]
1074
364564
                    || cblk->data_allocated < cblk->length + cblk->lengthinc[cwsno] + 4
1075
                ) {
1076
                    av_log(s->avctx, AV_LOG_ERROR,
1077
                        "Block length %"PRIu16" or lengthinc %d is too large, left %d\n",
1078
                        cblk->length, cblk->lengthinc[cwsno], bytestream2_get_bytes_left(&s->g));
1079
                    return AVERROR_INVALIDDATA;
1080
                }
1081
1082
364564
                bytestream2_get_bufferu(&s->g, cblk->data + cblk->length, cblk->lengthinc[cwsno]);
1083
364564
                cblk->length   += cblk->lengthinc[cwsno];
1084
364564
                cblk->lengthinc[cwsno] = 0;
1085
364564
                if (cblk->nb_terminationsinc) {
1086
                    cblk->nb_terminationsinc--;
1087
                    cblk->nb_terminations++;
1088
                    cblk->data[cblk->length++] = 0xFF;
1089
                    cblk->data[cblk->length++] = 0xFF;
1090
                    cblk->data_start[cblk->nb_terminations] = cblk->length;
1091
                }
1092
            }
1093
364564
            av_freep(&cblk->lengthinc);
1094
        }
1095
    }
1096
28473
    return 0;
1097
}
1098
1099
1331
static int jpeg2000_decode_packets_po_iteration(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile,
1100
                                             int RSpoc, int CSpoc,
1101
                                             int LYEpoc, int REpoc, int CEpoc,
1102
                                             int Ppoc, int *tp_index)
1103
{
1104
1331
    int ret = 0;
1105
    int layno, reslevelno, compno, precno, ok_reslevel;
1106
    int x, y;
1107
    int step_x, step_y;
1108
1109

1331
    switch (Ppoc) {
1110
    case JPEG2000_PGOD_RLCP:
1111
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order RLCP\n");
1112
        ok_reslevel = 1;
1113
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1114
            ok_reslevel = 0;
1115
            for (layno = 0; layno < LYEpoc; layno++) {
1116
                for (compno = CSpoc; compno < CEpoc; compno++) {
1117
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1118
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1119
                    if (reslevelno < codsty->nreslevels) {
1120
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1121
                                                reslevelno;
1122
                        ok_reslevel = 1;
1123
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1124
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1125
                                                              codsty, rlevel,
1126
                                                              precno, layno,
1127
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1128
                                                              qntsty->nguardbits)) < 0)
1129
                                return ret;
1130
                    }
1131
                }
1132
            }
1133
        }
1134
        break;
1135
1136
1326
    case JPEG2000_PGOD_LRCP:
1137
1326
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order LRCP\n");
1138
2652
        for (layno = 0; layno < LYEpoc; layno++) {
1139
1326
            ok_reslevel = 1;
1140

11934
            for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1141
10608
                ok_reslevel = 0;
1142
42432
                for (compno = CSpoc; compno < CEpoc; compno++) {
1143
31824
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1144
31824
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1145
31824
                    if (reslevelno < codsty->nreslevels) {
1146
27846
                        Jpeg2000ResLevel *rlevel = tile->comp[compno].reslevel +
1147
                                                reslevelno;
1148
27846
                        ok_reslevel = 1;
1149
55692
                        for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++)
1150
27846
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1151
                                                              codsty, rlevel,
1152
                                                              precno, layno,
1153
27846
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1154
27846
                                                              qntsty->nguardbits)) < 0)
1155
                                return ret;
1156
                    }
1157
                }
1158
            }
1159
        }
1160
1326
        break;
1161
1162
5
    case JPEG2000_PGOD_CPRL:
1163
5
        av_log(s->avctx, AV_LOG_DEBUG, "Progression order CPRL\n");
1164
22
        for (compno = CSpoc; compno < CEpoc; compno++) {
1165
17
            Jpeg2000Component *comp     = tile->comp + compno;
1166
17
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1167
17
            Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1168
17
            step_x = 32;
1169
17
            step_y = 32;
1170
1171
17
            if (RSpoc >= FFMIN(codsty->nreslevels, REpoc))
1172
                continue;
1173
1174
119
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1175
102
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1176
102
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1177
102
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1178
102
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1179
            }
1180

17
            if (step_x >= 31 || step_y >= 31){
1181
                avpriv_request_sample(s->avctx, "CPRL with large step");
1182
                return AVERROR_PATCHWELCOME;
1183
            }
1184
17
            step_x = 1<<step_x;
1185
17
            step_y = 1<<step_y;
1186
1187
70
            for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1188
421
                for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1189
2576
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1190
                        unsigned prcx, prcy;
1191
2208
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1192
2208
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1193
2208
                        int xc = x / s->cdx[compno];
1194
2208
                        int yc = y / s->cdy[compno];
1195
1196

2208
                        if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1197
1224
                            continue;
1198
1199

984
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1200
405
                            continue;
1201
1202
                        // check if a precinct exists
1203
579
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1204
579
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1205
579
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1206
579
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1207
1208
579
                        precno = prcx + rlevel->num_precincts_x * prcy;
1209
1210

579
                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1211
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1212
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1213
                            continue;
1214
                        }
1215
1216
1206
                        for (layno = 0; layno < LYEpoc; layno++) {
1217
627
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1218
                                                              precno, layno,
1219
627
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1220
627
                                                              qntsty->nguardbits)) < 0)
1221
                                return ret;
1222
                        }
1223
                    }
1224
                }
1225
            }
1226
        }
1227
5
        break;
1228
1229
    case JPEG2000_PGOD_RPCL:
1230
        av_log(s->avctx, AV_LOG_WARNING, "Progression order RPCL\n");
1231
        ok_reslevel = 1;
1232
        for (reslevelno = RSpoc; ok_reslevel && reslevelno < REpoc; reslevelno++) {
1233
            ok_reslevel = 0;
1234
            step_x = 30;
1235
            step_y = 30;
1236
            for (compno = CSpoc; compno < CEpoc; compno++) {
1237
                Jpeg2000Component *comp     = tile->comp + compno;
1238
                Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1239
1240
                if (reslevelno < codsty->nreslevels) {
1241
                    uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1242
                    Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1243
                    step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1244
                    step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1245
                }
1246
            }
1247
            step_x = 1<<step_x;
1248
            step_y = 1<<step_y;
1249
1250
            for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1251
                for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1252
                    for (compno = CSpoc; compno < CEpoc; compno++) {
1253
                        Jpeg2000Component *comp     = tile->comp + compno;
1254
                        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1255
                        Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1256
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1257
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1258
                        unsigned prcx, prcy;
1259
1260
                        int xc = x / s->cdx[compno];
1261
                        int yc = y / s->cdy[compno];
1262
1263
                        if (reslevelno >= codsty->nreslevels)
1264
                            continue;
1265
1266
                        if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1267
                            continue;
1268
1269
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1270
                            continue;
1271
1272
                        // check if a precinct exists
1273
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1274
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1275
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1276
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1277
1278
                        precno = prcx + rlevel->num_precincts_x * prcy;
1279
1280
                        ok_reslevel = 1;
1281
                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1282
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1283
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1284
                            continue;
1285
                        }
1286
1287
                            for (layno = 0; layno < LYEpoc; layno++) {
1288
                                if ((ret = jpeg2000_decode_packet(s, tile, tp_index,
1289
                                                                codsty, rlevel,
1290
                                                                precno, layno,
1291
                                                                qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1292
                                                                qntsty->nguardbits)) < 0)
1293
                                    return ret;
1294
                            }
1295
                    }
1296
                }
1297
            }
1298
        }
1299
        break;
1300
1301
    case JPEG2000_PGOD_PCRL:
1302
        av_log(s->avctx, AV_LOG_WARNING, "Progression order PCRL\n");
1303
        step_x = 32;
1304
        step_y = 32;
1305
        for (compno = CSpoc; compno < CEpoc; compno++) {
1306
            Jpeg2000Component *comp     = tile->comp + compno;
1307
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1308
1309
            for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1310
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1311
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1312
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1313
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1314
            }
1315
        }
1316
        if (step_x >= 31 || step_y >= 31){
1317
            avpriv_request_sample(s->avctx, "PCRL with large step");
1318
            return AVERROR_PATCHWELCOME;
1319
        }
1320
        step_x = 1<<step_x;
1321
        step_y = 1<<step_y;
1322
1323
        for (y = tile->coord[1][0]; y < tile->coord[1][1]; y = (y/step_y + 1)*step_y) {
1324
            for (x = tile->coord[0][0]; x < tile->coord[0][1]; x = (x/step_x + 1)*step_x) {
1325
                for (compno = CSpoc; compno < CEpoc; compno++) {
1326
                    Jpeg2000Component *comp     = tile->comp + compno;
1327
                    Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1328
                    Jpeg2000QuantStyle *qntsty  = tile->qntsty + compno;
1329
                    int xc = x / s->cdx[compno];
1330
                    int yc = y / s->cdy[compno];
1331
1332
                    for (reslevelno = RSpoc; reslevelno < FFMIN(codsty->nreslevels, REpoc); reslevelno++) {
1333
                        unsigned prcx, prcy;
1334
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1335
                        Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1336
1337
                        if (yc % (1LL << (rlevel->log2_prec_height + reducedresno)) && y != tile->coord[1][0]) //FIXME this is a subset of the check
1338
                            continue;
1339
1340
                        if (xc % (1LL << (rlevel->log2_prec_width + reducedresno)) && x != tile->coord[0][0]) //FIXME this is a subset of the check
1341
                            continue;
1342
1343
                        // check if a precinct exists
1344
                        prcx   = ff_jpeg2000_ceildivpow2(xc, reducedresno) >> rlevel->log2_prec_width;
1345
                        prcy   = ff_jpeg2000_ceildivpow2(yc, reducedresno) >> rlevel->log2_prec_height;
1346
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> rlevel->log2_prec_width;
1347
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> rlevel->log2_prec_height;
1348
1349
                        precno = prcx + rlevel->num_precincts_x * prcy;
1350
1351
                        if (prcx >= rlevel->num_precincts_x || prcy >= rlevel->num_precincts_y) {
1352
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1353
                                   prcx, prcy, rlevel->num_precincts_x, rlevel->num_precincts_y);
1354
                            continue;
1355
                        }
1356
1357
                        for (layno = 0; layno < LYEpoc; layno++) {
1358
                            if ((ret = jpeg2000_decode_packet(s, tile, tp_index, codsty, rlevel,
1359
                                                              precno, layno,
1360
                                                              qntsty->expn + (reslevelno ? 3 * (reslevelno - 1) + 1 : 0),
1361
                                                              qntsty->nguardbits)) < 0)
1362
                                return ret;
1363
                        }
1364
                    }
1365
                }
1366
            }
1367
        }
1368
        break;
1369
1370
    default:
1371
        break;
1372
    }
1373
1374
1331
    return ret;
1375
}
1376
1377
1331
static int jpeg2000_decode_packets(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1378
{
1379
1331
    int ret = AVERROR_BUG;
1380
    int i;
1381
1331
    int tp_index = 0;
1382
1383
1331
    s->bit_index = 8;
1384
1331
    if (tile->poc.nb_poc) {
1385
        for (i=0; i<tile->poc.nb_poc; i++) {
1386
            Jpeg2000POCEntry *e = &tile->poc.poc[i];
1387
            ret = jpeg2000_decode_packets_po_iteration(s, tile,
1388
                e->RSpoc, e->CSpoc,
1389
                FFMIN(e->LYEpoc, tile->codsty[0].nlayers),
1390
                e->REpoc,
1391
                FFMIN(e->CEpoc, s->ncomponents),
1392
                e->Ppoc, &tp_index
1393
                );
1394
            if (ret < 0)
1395
                return ret;
1396
        }
1397
    } else {
1398
1331
        ret = jpeg2000_decode_packets_po_iteration(s, tile,
1399
            0, 0,
1400
1331
            tile->codsty[0].nlayers,
1401
            33,
1402
            s->ncomponents,
1403
1331
            tile->codsty[0].prog_order,
1404
            &tp_index
1405
        );
1406
    }
1407
    /* EOC marker reached */
1408
1331
    bytestream2_skip(&s->g, 2);
1409
1410
1331
    return ret;
1411
}
1412
1413
/* TIER-1 routines */
1414
877598
static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height,
1415
                           int bpno, int bandno,
1416
                           int vert_causal_ctx_csty_symbol)
1417
{
1418
877598
    int mask = 3 << (bpno - 1), y0, x, y;
1419
1420
3778218
    for (y0 = 0; y0 < height; y0 += 4)
1421
50688616
        for (x = 0; x < width; x++)
1422

237307613
            for (y = y0; y < height && y < y0 + 4; y++) {
1423
189519617
                int flags_mask = -1;
1424

189519617
                if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1425
                    flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1426
189519617
                if ((t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB & flags_mask)
1427
73928626
                && !(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1428
51305930
                    if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, bandno))) {
1429
14815869
                        int xorbit, ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask, &xorbit);
1430
14815869
                        if (t1->mqc.raw)
1431
                             t1->data[(y) * t1->stride + x] = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ? -mask : mask;
1432
                        else
1433
29631738
                             t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ctxno) ^ xorbit) ?
1434
14815869
                                               -mask : mask;
1435
1436
14815869
                        ff_jpeg2000_set_significance(t1, x, y,
1437
14815869
                                                     t1->data[(y) * t1->stride + x] < 0);
1438
                    }
1439
51305930
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_VIS;
1440
                }
1441
            }
1442
877598
}
1443
1444
774996
static void decode_refpass(Jpeg2000T1Context *t1, int width, int height,
1445
                           int bpno, int vert_causal_ctx_csty_symbol)
1446
{
1447
    int phalf, nhalf;
1448
    int y0, x, y;
1449
1450
774996
    phalf = 1 << (bpno - 1);
1451
774996
    nhalf = -phalf;
1452
1453
3332385
    for (y0 = 0; y0 < height; y0 += 4)
1454
44968233
        for (x = 0; x < width; x++)
1455

210634860
            for (y = y0; y < height && y < y0 + 4; y++)
1456
168224016
                if ((t1->flags[(y + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG) {
1457
                    int flags_mask = (vert_causal_ctx_csty_symbol && y == y0 + 3) ?
1458
17836470
                        ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S) : -1;
1459
17836470
                    int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask);
1460
35672940
                    int r     = ff_mqc_decode(&t1->mqc,
1461
17836470
                                              t1->mqc.cx_states + ctxno)
1462
17836470
                                ? phalf : nhalf;
1463
17836470
                    t1->data[(y) * t1->stride + x]          += t1->data[(y) * t1->stride + x] < 0 ? -r : r;
1464
17836470
                    t1->flags[(y + 1) * t1->stride + x + 1] |= JPEG2000_T1_REF;
1465
                }
1466
774996
}
1467
1468
1072421
static void decode_clnpass(Jpeg2000DecoderContext *s, Jpeg2000T1Context *t1,
1469
                           int width, int height, int bpno, int bandno,
1470
                           int seg_symbols, int vert_causal_ctx_csty_symbol)
1471
{
1472
1072421
    int mask = 3 << (bpno - 1), y0, x, y, runlen, dec;
1473
1474
4706924
    for (y0 = 0; y0 < height; y0 += 4) {
1475
64726351
        for (x = 0; x < width; x++) {
1476
61091848
            int flags_mask = -1;
1477
61091848
            if (vert_causal_ctx_csty_symbol)
1478
                flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1479
61091848
            if (y0 + 3 < height &&
1480
60371743
                !((t1->flags[(y0 + 1) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1481
40370473
                  (t1->flags[(y0 + 2) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1482
38034169
                  (t1->flags[(y0 + 3) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
1483
35951268
                  (t1->flags[(y0 + 4) * t1->stride + x + 1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG) & flags_mask))) {
1484
35159913
                if (!ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL))
1485
32594876
                    continue;
1486
2565037
                runlen = ff_mqc_decode(&t1->mqc,
1487
2565037
                                       t1->mqc.cx_states + MQC_CX_UNI);
1488
5130074
                runlen = (runlen << 1) | ff_mqc_decode(&t1->mqc,
1489
2565037
                                                       t1->mqc.cx_states +
1490
                                                       MQC_CX_UNI);
1491
2565037
                dec = 1;
1492
            } else {
1493
25931935
                runlen = 0;
1494
25931935
                dec    = 0;
1495
            }
1496
1497

136600024
            for (y = y0 + runlen; y < y0 + 4 && y < height; y++) {
1498
108103052
                int flags_mask = -1;
1499

108103052
                if (vert_causal_ctx_csty_symbol && y == y0 + 3)
1500
                    flags_mask &= ~(JPEG2000_T1_SIG_S | JPEG2000_T1_SIG_SW | JPEG2000_T1_SIG_SE | JPEG2000_T1_SGN_S);
1501
108103052
                if (!dec) {
1502
105538015
                    if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))) {
1503
49943741
                        dec = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1] & flags_mask,
1504
                                                                                             bandno));
1505
                    }
1506
                }
1507
108103052
                if (dec) {
1508
                    int xorbit;
1509
8653736
                    int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y + 1) * t1->stride + x + 1] & flags_mask,
1510
                                                        &xorbit);
1511
17307472
                    t1->data[(y) * t1->stride + x] = (ff_mqc_decode(&t1->mqc,
1512
8653736
                                                    t1->mqc.cx_states + ctxno) ^
1513
                                      xorbit)
1514
8653736
                                     ? -mask : mask;
1515
8653736
                    ff_jpeg2000_set_significance(t1, x, y, t1->data[(y) * t1->stride + x] < 0);
1516
                }
1517
108103052
                dec = 0;
1518
108103052
                t1->flags[(y + 1) * t1->stride + x + 1] &= ~JPEG2000_T1_VIS;
1519
            }
1520
        }
1521
    }
1522
1072421
    if (seg_symbols) {
1523
        int val;
1524
        val = ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1525
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1526
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1527
        val = (val << 1) + ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI);
1528
        if (val != 0xa)
1529
            av_log(s->avctx, AV_LOG_ERROR,
1530
                   "Segmentation symbol value incorrect\n");
1531
    }
1532
1072421
}
1533
1534
443079
static int decode_cblk(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *codsty,
1535
                       Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk,
1536
                       int width, int height, int bandpos)
1537
{
1538
443079
    int passno = cblk->npasses, pass_t = 2, bpno = cblk->nonzerobits - 1;
1539
443079
    int pass_cnt = 0;
1540
443079
    int vert_causal_ctx_csty_symbol = codsty->cblk_style & JPEG2000_CBLK_VSC;
1541
443079
    int term_cnt = 0;
1542
    int coder_type;
1543
1544

443079
    av_assert0(width <= 1024U && height <= 1024U);
1545
443079
    av_assert0(width*height <= 4096);
1546
1547
443079
    memset(t1->data, 0, t1->stride * height * sizeof(*t1->data));
1548
1549
    /* If code-block contains no compressed data: nothing to do. */
1550
443079
    if (!cblk->length)
1551
80351
        return 0;
1552
1553
362728
    memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
1554
1555
362728
    cblk->data[cblk->length] = 0xff;
1556
362728
    cblk->data[cblk->length+1] = 0xff;
1557
362728
    ff_mqc_initdec(&t1->mqc, cblk->data, 0, 1);
1558
1559
3087743
    while (passno--) {
1560
2725015
        if (bpno < 0) {
1561
            av_log(s->avctx, AV_LOG_ERROR, "bpno became negative\n");
1562
            return AVERROR_INVALIDDATA;
1563
        }
1564

2725015
        switch(pass_t) {
1565
877598
        case 0:
1566
877598
            decode_sigpass(t1, width, height, bpno + 1, bandpos,
1567
                           vert_causal_ctx_csty_symbol);
1568
877598
            break;
1569
774996
        case 1:
1570
774996
            decode_refpass(t1, width, height, bpno + 1, vert_causal_ctx_csty_symbol);
1571
774996
            break;
1572
1072421
        case 2:
1573
            av_assert2(!t1->mqc.raw);
1574
1072421
            decode_clnpass(s, t1, width, height, bpno + 1, bandpos,
1575
1072421
                           codsty->cblk_style & JPEG2000_CBLK_SEGSYM,
1576
                           vert_causal_ctx_csty_symbol);
1577
1072421
            break;
1578
        }
1579
2725015
        if (codsty->cblk_style & JPEG2000_CBLK_RESET) // XXX no testcase for just this
1580
            ff_mqc_init_contexts(&t1->mqc);
1581
1582

2725015
        if (passno && (coder_type = needs_termination(codsty->cblk_style, pass_cnt))) {
1583
            if (term_cnt >= cblk->nb_terminations) {
1584
                av_log(s->avctx, AV_LOG_ERROR, "Missing needed termination \n");
1585
                return AVERROR_INVALIDDATA;
1586
            }
1587
            if (FFABS(cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp) > 0) {
1588
                av_log(s->avctx, AV_LOG_WARNING, "Mid mismatch %"PTRDIFF_SPECIFIER" in pass %d of %d\n",
1589
                    cblk->data + cblk->data_start[term_cnt + 1] - 2 - t1->mqc.bp,
1590
                    pass_cnt, cblk->npasses);
1591
            }
1592
1593
            ff_mqc_initdec(&t1->mqc, cblk->data + cblk->data_start[++term_cnt], coder_type == 2, 0);
1594
        }
1595
1596
2725015
        pass_t++;
1597
2725015
        if (pass_t == 3) {
1598
1072421
            bpno--;
1599
1072421
            pass_t = 0;
1600
        }
1601
2725015
        pass_cnt ++;
1602
    }
1603
1604

362728
    if (cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) != t1->mqc.bp) {
1605
1003
        av_log(s->avctx, AV_LOG_WARNING, "End mismatch %"PTRDIFF_SPECIFIER"\n",
1606
1003
               cblk->data + cblk->length - 2*(term_cnt < cblk->nb_terminations) - t1->mqc.bp);
1607
    }
1608
1609
362728
    return 1;
1610
}
1611
1612
/* TODO: Verify dequantization for lossless case
1613
 * comp->data can be float or int
1614
 * band->stepsize can be float or int
1615
 * depending on the type of DWT transformation.
1616
 * see ISO/IEC 15444-1:2002 A.6.1 */
1617
1618
/* Float dequantization of a codeblock.*/
1619
2415
static void dequantization_float(int x, int y, Jpeg2000Cblk *cblk,
1620
                                 Jpeg2000Component *comp,
1621
                                 Jpeg2000T1Context *t1, Jpeg2000Band *band)
1622
{
1623
    int i, j;
1624
2415
    int w = cblk->coord[0][1] - cblk->coord[0][0];
1625
75375
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1626
72960
        float *datap = &comp->f_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1627
72960
        int *src = t1->data + j*t1->stride;
1628
9374976
        for (i = 0; i < w; ++i)
1629
9302016
            datap[i] = src[i] * band->f_stepsize;
1630
    }
1631
2415
}
1632
1633
/* Integer dequantization of a codeblock.*/
1634
163728
static void dequantization_int(int x, int y, Jpeg2000Cblk *cblk,
1635
                               Jpeg2000Component *comp,
1636
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
1637
{
1638
    int i, j;
1639
163728
    int w = cblk->coord[0][1] - cblk->coord[0][0];
1640
2456529
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1641
2292801
        int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1642
2292801
        int *src = t1->data + j*t1->stride;
1643
2292801
        if (band->i_stepsize == 32768) {
1644
37101173
            for (i = 0; i < w; ++i)
1645
34808372
                datap[i] = src[i] / 2;
1646
        } else {
1647
            // This should be VERY uncommon
1648
            for (i = 0; i < w; ++i)
1649
                datap[i] = (src[i] * (int64_t)band->i_stepsize) / 65536;
1650
        }
1651
    }
1652
163728
}
1653
1654
196585
static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
1655
                               Jpeg2000Component *comp,
1656
                               Jpeg2000T1Context *t1, Jpeg2000Band *band)
1657
{
1658
    int i, j;
1659
196585
    int w = cblk->coord[0][1] - cblk->coord[0][0];
1660
3127387
    for (j = 0; j < (cblk->coord[1][1] - cblk->coord[1][0]); ++j) {
1661
2930802
        int32_t *datap = &comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * (y + j) + x];
1662
2930802
        int *src = t1->data + j*t1->stride;
1663
51769172
        for (i = 0; i < w; ++i)
1664
48838370
            datap[i] = (src[i] * (int64_t)band->i_stepsize + (1<<15)) >> 16;
1665
    }
1666
196585
}
1667
1668
3
static inline void mct_decode(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1669
{
1670
3
    int i, csize = 1;
1671
    void *src[3];
1672
1673
9
    for (i = 1; i < 3; i++) {
1674
6
        if (tile->codsty[0].transform != tile->codsty[i].transform) {
1675
            av_log(s->avctx, AV_LOG_ERROR, "Transforms mismatch, MCT not supported\n");
1676
            return;
1677
        }
1678
6
        if (memcmp(tile->comp[0].coord, tile->comp[i].coord, sizeof(tile->comp[0].coord))) {
1679
            av_log(s->avctx, AV_LOG_ERROR, "Coords mismatch, MCT not supported\n");
1680
            return;
1681
        }
1682
    }
1683
1684
12
    for (i = 0; i < 3; i++)
1685
9
        if (tile->codsty[0].transform == FF_DWT97)
1686
            src[i] = tile->comp[i].f_data;
1687
        else
1688
9
            src[i] = tile->comp[i].i_data;
1689
1690
9
    for (i = 0; i < 2; i++)
1691
6
        csize *= tile->comp[0].coord[i][1] - tile->comp[0].coord[i][0];
1692
1693
3
    s->dsp.mct_decode[tile->codsty[0].transform](src[0], src[1], src[2], csize);
1694
}
1695
1696
1331
static inline void tile_codeblocks(Jpeg2000DecoderContext *s, Jpeg2000Tile *tile)
1697
{
1698
    Jpeg2000T1Context t1;
1699
1700
    int compno, reslevelno, bandno;
1701
1702
    /* Loop on tile components */
1703
5326
    for (compno = 0; compno < s->ncomponents; compno++) {
1704
3995
        Jpeg2000Component *comp     = tile->comp + compno;
1705
3995
        Jpeg2000CodingStyle *codsty = tile->codsty + compno;
1706
3995
        int coded = 0;
1707
1708
3995
        t1.stride = (1<<codsty->log2_cblk_width) + 2;
1709
1710
        /* Loop on resolution levels */
1711
31943
        for (reslevelno = 0; reslevelno < codsty->nreslevels2decode; reslevelno++) {
1712
27948
            Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1713
            /* Loop on bands */
1714
103802
            for (bandno = 0; bandno < rlevel->nbands; bandno++) {
1715
                int nb_precincts, precno;
1716
75854
                Jpeg2000Band *band = rlevel->band + bandno;
1717
75854
                int cblkno = 0, bandpos;
1718
1719
75854
                bandpos = bandno + (reslevelno > 0);
1720
1721
75854
                if (band->coord[0][0] == band->coord[0][1] ||
1722
75854
                    band->coord[1][0] == band->coord[1][1])
1723
3672
                    continue;
1724
1725
72182
                nb_precincts = rlevel->num_precincts_x * rlevel->num_precincts_y;
1726
                /* Loop on precincts */
1727
145795
                for (precno = 0; precno < nb_precincts; precno++) {
1728
73613
                    Jpeg2000Prec *prec = band->prec + precno;
1729
1730
                    /* Loop on codeblocks */
1731
73613
                    for (cblkno = 0;
1732
516692
                         cblkno < prec->nb_codeblocks_width * prec->nb_codeblocks_height;
1733
443079
                         cblkno++) {
1734
                        int x, y;
1735
443079
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1736
443079
                        int ret = decode_cblk(s, codsty, &t1, cblk,
1737
443079
                                    cblk->coord[0][1] - cblk->coord[0][0],
1738
443079
                                    cblk->coord[1][1] - cblk->coord[1][0],
1739
                                    bandpos);
1740
443079
                        if (ret)
1741
362728
                            coded = 1;
1742
                        else
1743
80351
                            continue;
1744
362728
                        x = cblk->coord[0][0] - band->coord[0][0];
1745
362728
                        y = cblk->coord[1][0] - band->coord[1][0];
1746
1747
362728
                        if (codsty->transform == FF_DWT97)
1748
2415
                            dequantization_float(x, y, cblk, comp, &t1, band);
1749
360313
                        else if (codsty->transform == FF_DWT97_INT)
1750
196585
                            dequantization_int_97(x, y, cblk, comp, &t1, band);
1751
                        else
1752
163728
                            dequantization_int(x, y, cblk, comp, &t1, band);
1753
                   } /* end cblk */
1754
                } /*end prec */
1755
            } /* end band */
1756
        } /* end reslevel */
1757
1758
        /* inverse DWT */
1759
3995
        if (coded)
1760
3995
            ff_dwt_decode(&comp->dwt, codsty->transform == FF_DWT97 ? (void*)comp->f_data : (void*)comp->i_data);
1761
1762
    } /*end comp */
1763
1331
}
1764
1765
#define WRITE_FRAME(D, PIXEL)                                                                     \
1766
    static inline void write_frame_ ## D(Jpeg2000DecoderContext * s, Jpeg2000Tile * tile,         \
1767
                                         AVFrame * picture, int precision)                        \
1768
    {                                                                                             \
1769
        const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(s->avctx->pix_fmt);               \
1770
        int planar    = !!(pixdesc->flags & AV_PIX_FMT_FLAG_PLANAR);                              \
1771
        int pixelsize = planar ? 1 : pixdesc->nb_components;                                      \
1772
                                                                                                  \
1773
        int compno;                                                                               \
1774
        int x, y;                                                                                 \
1775
                                                                                                  \
1776
        for (compno = 0; compno < s->ncomponents; compno++) {                                     \
1777
            Jpeg2000Component *comp     = tile->comp + compno;                                    \
1778
            Jpeg2000CodingStyle *codsty = tile->codsty + compno;                                  \
1779
            PIXEL *line;                                                                          \
1780
            float *datap     = comp->f_data;                                                      \
1781
            int32_t *i_datap = comp->i_data;                                                      \
1782
            int cbps         = s->cbps[compno];                                                   \
1783
            int w            = tile->comp[compno].coord[0][1] - s->image_offset_x;                \
1784
            int plane        = 0;                                                                 \
1785
                                                                                                  \
1786
            if (planar)                                                                           \
1787
                plane = s->cdef[compno] ? s->cdef[compno]-1 : (s->ncomponents-1);                 \
1788
                                                                                                  \
1789
            y    = tile->comp[compno].coord[1][0] - s->image_offset_y / s->cdy[compno];           \
1790
            line = (PIXEL *)picture->data[plane] + y * (picture->linesize[plane] / sizeof(PIXEL));\
1791
            for (; y < tile->comp[compno].coord[1][1] - s->image_offset_y; y++) {                 \
1792
                PIXEL *dst;                                                                       \
1793
                                                                                                  \
1794
                x   = tile->comp[compno].coord[0][0] - s->image_offset_x / s->cdx[compno];        \
1795
                dst = line + x * pixelsize + compno*!planar;                                      \
1796
                                                                                                  \
1797
                if (codsty->transform == FF_DWT97) {                                              \
1798
                    for (; x < w; x++) {                                                          \
1799
                        int val = lrintf(*datap) + (1 << (cbps - 1));                             \
1800
                        /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1801
                        val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1802
                        *dst = val << (precision - cbps);                                         \
1803
                        datap++;                                                                  \
1804
                        dst += pixelsize;                                                         \
1805
                    }                                                                             \
1806
                } else {                                                                          \
1807
                    for (; x < w; x++) {                                                          \
1808
                        int val = *i_datap + (1 << (cbps - 1));                                   \
1809
                        /* DC level shift and clip see ISO 15444-1:2002 G.1.2 */                  \
1810
                        val  = av_clip(val, 0, (1 << cbps) - 1);                                  \
1811
                        *dst = val << (precision - cbps);                                         \
1812
                        i_datap++;                                                                \
1813
                        dst += pixelsize;                                                         \
1814
                    }                                                                             \
1815
                }                                                                                 \
1816
                line += picture->linesize[plane] / sizeof(PIXEL);                                 \
1817
            }                                                                                     \
1818
        }                                                                                         \
1819
                                                                                                  \
1820
    }
1821
1822




93961380
WRITE_FRAME(8, uint8_t)
1823




28113934
WRITE_FRAME(16, uint16_t)
1824
1825
#undef WRITE_FRAME
1826
1827
1331
static int jpeg2000_decode_tile(AVCodecContext *avctx, void *td,
1828
                                int jobnr, int threadnr)
1829
{
1830
1331
    Jpeg2000DecoderContext *s = avctx->priv_data;
1831
1331
    AVFrame *picture = td;
1832
1331
    Jpeg2000Tile *tile = s->tile + jobnr;
1833
    int x;
1834
1835
1331
    tile_codeblocks(s, tile);
1836
1837
    /* inverse MCT transformation */
1838
1331
    if (tile->codsty[0].mct)
1839
3
        mct_decode(s, tile);
1840
1841
4089
    for (x = 0; x < s->ncomponents; x++) {
1842
3170
        if (s->cdef[x] < 0) {
1843
1649
            for (x = 0; x < s->ncomponents; x++) {
1844
1237
                s->cdef[x] = x + 1;
1845
            }
1846
412
            if ((s->ncomponents & 1) == 0)
1847
1
                s->cdef[s->ncomponents-1] = 0;
1848
412
            break;
1849
        }
1850
    }
1851
1852
1331
    if (s->precision <= 8) {
1853
1326
        write_frame_8(s, tile, picture, 8);
1854
    } else {
1855
12
        int precision = picture->format == AV_PIX_FMT_XYZ12 ||
1856
2
                        picture->format == AV_PIX_FMT_RGB48 ||
1857
2
                        picture->format == AV_PIX_FMT_RGBA64 ||
1858

7
                        picture->format == AV_PIX_FMT_GRAY16 ? 16 : s->precision;
1859
1860
5
        write_frame_16(s, tile, picture, precision);
1861
    }
1862
1863
1331
    return 0;
1864
}
1865
1866
412
static void jpeg2000_dec_cleanup(Jpeg2000DecoderContext *s)
1867
{
1868
    int tileno, compno;
1869
1743
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
1870
1331
        if (s->tile[tileno].comp) {
1871
5326
            for (compno = 0; compno < s->ncomponents; compno++) {
1872
3995
                Jpeg2000Component *comp     = s->tile[tileno].comp   + compno;
1873
3995
                Jpeg2000CodingStyle *codsty = s->tile[tileno].codsty + compno;
1874
1875
3995
                ff_jpeg2000_cleanup(comp, codsty);
1876
            }
1877
1331
            av_freep(&s->tile[tileno].comp);
1878
        }
1879
    }
1880
412
    av_freep(&s->tile);
1881
412
    memset(s->codsty, 0, sizeof(s->codsty));
1882
412
    memset(s->qntsty, 0, sizeof(s->qntsty));
1883
412
    memset(s->properties, 0, sizeof(s->properties));
1884
412
    memset(&s->poc  , 0, sizeof(s->poc));
1885
412
    s->numXtiles = s->numYtiles = 0;
1886
412
    s->ncomponents = 0;
1887
412
}
1888
1889
412
static int jpeg2000_read_main_headers(Jpeg2000DecoderContext *s)
1890
{
1891
412
    Jpeg2000CodingStyle *codsty = s->codsty;
1892
412
    Jpeg2000QuantStyle *qntsty  = s->qntsty;
1893
412
    Jpeg2000POC         *poc    = &s->poc;
1894
412
    uint8_t *properties         = s->properties;
1895
1896
3951
    for (;;) {
1897
4363
        int len, ret = 0;
1898
        uint16_t marker;
1899
        int oldpos;
1900
1901
4363
        if (bytestream2_get_bytes_left(&s->g) < 2) {
1902
            av_log(s->avctx, AV_LOG_ERROR, "Missing EOC\n");
1903
            break;
1904
        }
1905
1906
4363
        marker = bytestream2_get_be16u(&s->g);
1907
4363
        oldpos = bytestream2_tell(&s->g);
1908
1909
4363
        if (marker == JPEG2000_SOD) {
1910
            Jpeg2000Tile *tile;
1911
            Jpeg2000TilePart *tp;
1912
1913
1343
            if (!s->tile) {
1914
                av_log(s->avctx, AV_LOG_ERROR, "Missing SIZ\n");
1915
                return AVERROR_INVALIDDATA;
1916
            }
1917
1343
            if (s->curtileno < 0) {
1918
                av_log(s->avctx, AV_LOG_ERROR, "Missing SOT\n");
1919
                return AVERROR_INVALIDDATA;
1920
            }
1921
1922
1343
            tile = s->tile + s->curtileno;
1923
1343
            tp = tile->tile_part + tile->tp_idx;
1924
1343
            if (tp->tp_end < s->g.buffer) {
1925
                av_log(s->avctx, AV_LOG_ERROR, "Invalid tpend\n");
1926
                return AVERROR_INVALIDDATA;
1927
            }
1928
1343
            bytestream2_init(&tp->tpg, s->g.buffer, tp->tp_end - s->g.buffer);
1929
1343
            bytestream2_skip(&s->g, tp->tp_end - s->g.buffer);
1930
1931
1343
            continue;
1932
        }
1933
3020
        if (marker == JPEG2000_EOC)
1934
412
            break;
1935
1936
2608
        len = bytestream2_get_be16(&s->g);
1937

2608
        if (len < 2 || bytestream2_get_bytes_left(&s->g) < len - 2) {
1938
            av_log(s->avctx, AV_LOG_ERROR, "Invalid len %d left=%d\n", len, bytestream2_get_bytes_left(&s->g));
1939
            return AVERROR_INVALIDDATA;
1940
        }
1941
1942


2608
        switch (marker) {
1943
412
        case JPEG2000_SIZ:
1944
412
            if (s->ncomponents) {
1945
                av_log(s->avctx, AV_LOG_ERROR, "Duplicate SIZ\n");
1946
                return AVERROR_INVALIDDATA;
1947
            }
1948
412
            ret = get_siz(s);
1949
412
            if (!s->tile)
1950
                s->numXtiles = s->numYtiles = 0;
1951
412
            break;
1952
6
        case JPEG2000_COC:
1953
6
            ret = get_coc(s, codsty, properties);
1954
6
            break;
1955
412
        case JPEG2000_COD:
1956
412
            ret = get_cod(s, codsty, properties);
1957
412
            break;
1958
9
        case JPEG2000_QCC:
1959
9
            ret = get_qcc(s, len, qntsty, properties);
1960
9
            break;
1961
412
        case JPEG2000_QCD:
1962
412
            ret = get_qcd(s, len, qntsty, properties);
1963
412
            break;
1964
        case JPEG2000_POC:
1965
            ret = get_poc(s, len, poc);
1966
            break;
1967
1343
        case JPEG2000_SOT:
1968
1343
            if (!(ret = get_sot(s, len))) {
1969
                av_assert1(s->curtileno >= 0);
1970
1343
                codsty = s->tile[s->curtileno].codsty;
1971
1343
                qntsty = s->tile[s->curtileno].qntsty;
1972
1343
                poc    = &s->tile[s->curtileno].poc;
1973
1343
                properties = s->tile[s->curtileno].properties;
1974
            }
1975
1343
            break;
1976
10
        case JPEG2000_PLM:
1977
            // the PLM marker is ignored
1978
        case JPEG2000_COM:
1979
            // the comment is ignored
1980
10
            bytestream2_skip(&s->g, len - 2);
1981
10
            break;
1982
4
        case JPEG2000_TLM:
1983
            // Tile-part lengths
1984
4
            ret = get_tlm(s, len);
1985
4
            break;
1986
        case JPEG2000_PLT:
1987
            // Packet length, tile-part header
1988
            ret = get_plt(s, len);
1989
            break;
1990
        default:
1991
            av_log(s->avctx, AV_LOG_ERROR,
1992
                   "unsupported marker 0x%.4"PRIX16" at pos 0x%X\n",
1993
                   marker, bytestream2_tell(&s->g) - 4);
1994
            bytestream2_skip(&s->g, len - 2);
1995
            break;
1996
        }
1997

2608
        if (bytestream2_tell(&s->g) - oldpos != len || ret) {
1998
            av_log(s->avctx, AV_LOG_ERROR,
1999
                   "error during processing marker segment %.4"PRIx16"\n",
2000
                   marker);
2001
            return ret ? ret : -1;
2002
        }
2003
    }
2004
412
    return 0;
2005
}
2006
2007
/* Read bit stream packets --> T2 operation. */
2008
412
static int jpeg2000_read_bitstream_packets(Jpeg2000DecoderContext *s)
2009
{
2010
412
    int ret = 0;
2011
    int tileno;
2012
2013
1743
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++) {
2014
1331
        Jpeg2000Tile *tile = s->tile + tileno;
2015
2016
1331
        if ((ret = init_tile(s, tileno)) < 0)
2017
            return ret;
2018
2019
1331
        s->g = tile->tile_part[0].tpg;
2020
1331
        if ((ret = jpeg2000_decode_packets(s, tile)) < 0)
2021
            return ret;
2022
    }
2023
2024
412
    return 0;
2025
}
2026
2027
409
static int jp2_find_codestream(Jpeg2000DecoderContext *s)
2028
{
2029
    uint32_t atom_size, atom, atom_end;
2030
409
    int search_range = 10;
2031
2032
1228
    while (search_range
2033
1228
           &&
2034
1228
           bytestream2_get_bytes_left(&s->g) >= 8) {
2035
1228
        atom_size = bytestream2_get_be32u(&s->g);
2036
1228
        atom      = bytestream2_get_be32u(&s->g);
2037
1228
        if (atom_size == 1) {
2038
            if (bytestream2_get_be32u(&s->g)) {
2039
                avpriv_request_sample(s->avctx, "Huge atom");
2040
                return 0;
2041
            }
2042
            atom_size = bytestream2_get_be32u(&s->g);
2043
            atom_end  = bytestream2_tell(&s->g) + atom_size - 16;
2044
        } else {
2045
1228
            atom_end  = bytestream2_tell(&s->g) + atom_size -  8;
2046
        }
2047
2048
1228
        if (atom == JP2_CODESTREAM)
2049
409
            return 1;
2050
2051

819
        if (bytestream2_get_bytes_left(&s->g) < atom_size || atom_end < atom_size)
2052
            return 0;
2053
2054

819
        if (atom == JP2_HEADER &&
2055
409
                   atom_size >= 16) {
2056
            uint32_t atom2_size, atom2, atom2_end;
2057
            do {
2058
818
                atom2_size = bytestream2_get_be32u(&s->g);
2059
818
                atom2      = bytestream2_get_be32u(&s->g);
2060
818
                atom2_end  = bytestream2_tell(&s->g) + atom2_size - 8;
2061

818
                if (atom2_size < 8 || atom2_end > atom_end || atom2_end < atom2_size)
2062
                    break;
2063
818
                atom2_size -= 8;
2064
818
                if (atom2 == JP2_CODESTREAM) {
2065
                    return 1;
2066

1227
                } else if (atom2 == MKBETAG('c','o','l','r') && atom2_size >= 7) {
2067
409
                    int method = bytestream2_get_byteu(&s->g);
2068
409
                    bytestream2_skipu(&s->g, 2);
2069
409
                    if (method == 1) {
2070
409
                        s->colour_space = bytestream2_get_be32u(&s->g);
2071
                    }
2072

409
                } else if (atom2 == MKBETAG('p','c','l','r') && atom2_size >= 6) {
2073
                    int i, size, colour_count, colour_channels, colour_depth[3];
2074
                    colour_count = bytestream2_get_be16u(&s->g);
2075
                    colour_channels = bytestream2_get_byteu(&s->g);
2076
                    // FIXME: Do not ignore channel_sign
2077
                    colour_depth[0] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2078
                    colour_depth[1] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2079
                    colour_depth[2] = (bytestream2_get_byteu(&s->g) & 0x7f) + 1;
2080
                    size = (colour_depth[0] + 7 >> 3) * colour_count +
2081
                           (colour_depth[1] + 7 >> 3) * colour_count +
2082
                           (colour_depth[2] + 7 >> 3) * colour_count;
2083
                    if (colour_count > AVPALETTE_COUNT ||
2084
                        colour_channels != 3 ||
2085
                        colour_depth[0] > 16 ||
2086
                        colour_depth[1] > 16 ||
2087
                        colour_depth[2] > 16 ||
2088
                        atom2_size < size) {
2089
                        avpriv_request_sample(s->avctx, "Unknown palette");
2090
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2091
                        continue;
2092
                    }
2093
                    s->pal8 = 1;
2094
                    for (i = 0; i < colour_count; i++) {
2095
                        uint32_t r, g, b;
2096
                        if (colour_depth[0] <= 8) {
2097
                            r = bytestream2_get_byteu(&s->g) << 8 - colour_depth[0];
2098
                            r |= r >> colour_depth[0];
2099
                        } else {
2100
                            r = bytestream2_get_be16u(&s->g) >> colour_depth[0] - 8;
2101
                        }
2102
                        if (colour_depth[1] <= 8) {
2103
                            g = bytestream2_get_byteu(&s->g) << 8 - colour_depth[1];
2104
                            g |= g >> colour_depth[1];
2105
                        } else {
2106
                            g = bytestream2_get_be16u(&s->g) >> colour_depth[1] - 8;
2107
                        }
2108
                        if (colour_depth[2] <= 8) {
2109
                            b = bytestream2_get_byteu(&s->g) << 8 - colour_depth[2];
2110
                            b |= b >> colour_depth[2];
2111
                        } else {
2112
                            b = bytestream2_get_be16u(&s->g) >> colour_depth[2] - 8;
2113
                        }
2114
                        s->palette[i] = 0xffu << 24 | r << 16 | g << 8 | b;
2115
                    }
2116

409
                } else if (atom2 == MKBETAG('c','d','e','f') && atom2_size >= 2) {
2117
                    int n = bytestream2_get_be16u(&s->g);
2118
                    for (; n>0; n--) {
2119
                        int cn   = bytestream2_get_be16(&s->g);
2120
                        int av_unused typ  = bytestream2_get_be16(&s->g);
2121
                        int asoc = bytestream2_get_be16(&s->g);
2122
                        if (cn < 4 && asoc < 4)
2123
                            s->cdef[cn] = asoc;
2124
                    }
2125

409
                } else if (atom2 == MKBETAG('r','e','s',' ') && atom2_size >= 18) {
2126
                    int64_t vnum, vden, hnum, hden, vexp, hexp;
2127
                    uint32_t resx;
2128
                    bytestream2_skip(&s->g, 4);
2129
                    resx = bytestream2_get_be32u(&s->g);
2130
                    if (resx != MKBETAG('r','e','s','c') && resx != MKBETAG('r','e','s','d')) {
2131
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2132
                        continue;
2133
                    }
2134
                    vnum = bytestream2_get_be16u(&s->g);
2135
                    vden = bytestream2_get_be16u(&s->g);
2136
                    hnum = bytestream2_get_be16u(&s->g);
2137
                    hden = bytestream2_get_be16u(&s->g);
2138
                    vexp = bytestream2_get_byteu(&s->g);
2139
                    hexp = bytestream2_get_byteu(&s->g);
2140
                    if (!vnum || !vden || !hnum || !hden) {
2141
                        bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2142
                        av_log(s->avctx, AV_LOG_WARNING, "RES box invalid\n");
2143
                        continue;
2144
                    }
2145
                    if (vexp > hexp) {
2146
                        vexp -= hexp;
2147
                        hexp = 0;
2148
                    } else {
2149
                        hexp -= vexp;
2150
                        vexp = 0;
2151
                    }
2152
                    if (   INT64_MAX / (hnum * vden) > pow(10, hexp)
2153
                        && INT64_MAX / (vnum * hden) > pow(10, vexp))
2154
                        av_reduce(&s->sar.den, &s->sar.num,
2155
                                  hnum * vden * pow(10, hexp),
2156
                                  vnum * hden * pow(10, vexp),
2157
                                  INT32_MAX);
2158
                }
2159
818
                bytestream2_seek(&s->g, atom2_end, SEEK_SET);
2160
818
            } while (atom_end - atom2_end >= 8);
2161
        } else {
2162
410
            search_range--;
2163
        }
2164
819
        bytestream2_seek(&s->g, atom_end, SEEK_SET);
2165
    }
2166
2167
    return 0;
2168
}
2169
2170
10
static av_cold void jpeg2000_init_static_data(void)
2171
{
2172
10
    ff_jpeg2000_init_tier1_luts();
2173
10
    ff_mqc_init_context_tables();
2174
10
}
2175
2176
19
static av_cold int jpeg2000_decode_init(AVCodecContext *avctx)
2177
{
2178
    static AVOnce init_static_once = AV_ONCE_INIT;
2179
19
    Jpeg2000DecoderContext *s = avctx->priv_data;
2180
2181
19
    ff_thread_once(&init_static_once, jpeg2000_init_static_data);
2182
19
    ff_jpeg2000dsp_init(&s->dsp);
2183
2184
19
    return 0;
2185
}
2186
2187
412
static int jpeg2000_decode_frame(AVCodecContext *avctx, void *data,
2188
                                 int *got_frame, AVPacket *avpkt)
2189
{
2190
412
    Jpeg2000DecoderContext *s = avctx->priv_data;
2191
412
    ThreadFrame frame = { .f = data };
2192
412
    AVFrame *picture = data;
2193
    int ret;
2194
2195
412
    s->avctx     = avctx;
2196
412
    bytestream2_init(&s->g, avpkt->data, avpkt->size);
2197
412
    s->curtileno = -1;
2198
412
    memset(s->cdef, -1, sizeof(s->cdef));
2199
2200
412
    if (bytestream2_get_bytes_left(&s->g) < 2) {
2201
        ret = AVERROR_INVALIDDATA;
2202
        goto end;
2203
    }
2204
2205
    // check if the image is in jp2 format
2206

824
    if (bytestream2_get_bytes_left(&s->g) >= 12 &&
2207
821
       (bytestream2_get_be32u(&s->g) == 12) &&
2208
818
       (bytestream2_get_be32u(&s->g) == JP2_SIG_TYPE) &&
2209
409
       (bytestream2_get_be32u(&s->g) == JP2_SIG_VALUE)) {
2210
409
        if (!jp2_find_codestream(s)) {
2211
            av_log(avctx, AV_LOG_ERROR,
2212
                   "Could not find Jpeg2000 codestream atom.\n");
2213
            ret = AVERROR_INVALIDDATA;
2214
            goto end;
2215
        }
2216
    } else {
2217
3
        bytestream2_seek(&s->g, 0, SEEK_SET);
2218
    }
2219
2220

412
    while (bytestream2_get_bytes_left(&s->g) >= 3 && bytestream2_peek_be16(&s->g) != JPEG2000_SOC)
2221
        bytestream2_skip(&s->g, 1);
2222
2223
412
    if (bytestream2_get_be16u(&s->g) != JPEG2000_SOC) {
2224
        av_log(avctx, AV_LOG_ERROR, "SOC marker not present\n");
2225
        ret = AVERROR_INVALIDDATA;
2226
        goto end;
2227
    }
2228
412
    if (ret = jpeg2000_read_main_headers(s))
2229
        goto end;
2230
2231
    /* get picture buffer */
2232
412
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
2233
        goto end;
2234
412
    picture->pict_type = AV_PICTURE_TYPE_I;
2235
412
    picture->key_frame = 1;
2236
2237
412
    if (ret = jpeg2000_read_bitstream_packets(s))
2238
        goto end;
2239
2240
412
    avctx->execute2(avctx, jpeg2000_decode_tile, picture, NULL, s->numXtiles * s->numYtiles);
2241
2242
412
    jpeg2000_dec_cleanup(s);
2243
2244
412
    *got_frame = 1;
2245
2246
412
    if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
2247
        memcpy(picture->data[1], s->palette, 256 * sizeof(uint32_t));
2248

412
    if (s->sar.num && s->sar.den)
2249
        avctx->sample_aspect_ratio = s->sar;
2250
412
    s->sar.num = s->sar.den = 0;
2251
2252
412
    return bytestream2_tell(&s->g);
2253
2254
end:
2255
    jpeg2000_dec_cleanup(s);
2256
    return ret;
2257
}
2258
2259
#define OFFSET(x) offsetof(Jpeg2000DecoderContext, x)
2260
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
2261
2262
static const AVOption options[] = {
2263
    { "lowres",  "Lower the decoding resolution by a power of two",
2264
        OFFSET(reduction_factor), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, JPEG2000_MAX_RESLEVELS - 1, VD },
2265
    { NULL },
2266
};
2267
2268
static const AVClass jpeg2000_class = {
2269
    .class_name = "jpeg2000",
2270
    .item_name  = av_default_item_name,
2271
    .option     = options,
2272
    .version    = LIBAVUTIL_VERSION_INT,
2273
};
2274
2275
AVCodec ff_jpeg2000_decoder = {
2276
    .name             = "jpeg2000",
2277
    .long_name        = NULL_IF_CONFIG_SMALL("JPEG 2000"),
2278
    .type             = AVMEDIA_TYPE_VIDEO,
2279
    .id               = AV_CODEC_ID_JPEG2000,
2280
    .capabilities     = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_DR1,
2281
    .priv_data_size   = sizeof(Jpeg2000DecoderContext),
2282
    .init             = jpeg2000_decode_init,
2283
    .decode           = jpeg2000_decode_frame,
2284
    .priv_class       = &jpeg2000_class,
2285
    .max_lowres       = 5,
2286
    .profiles         = NULL_IF_CONFIG_SMALL(ff_jpeg2000_profiles)
2287
};