GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/j2kenc.c Lines: 650 995 65.3 %
Date: 2020-11-28 20:53:16 Branches: 360 696 51.7 %

Line Branch Exec Source
1
/*
2
 * JPEG2000 image encoder
3
 * Copyright (c) 2007 Kamil Nowosad
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 *
21
 * **********************************************************************************************************************
22
 *
23
 *
24
 *
25
 * This source code incorporates work covered by the following copyright and
26
 * permission notice:
27
 *
28
 * Copyright (c) 2002-2007, Communications and Remote Sensing Laboratory, Universite catholique de Louvain (UCL), Belgium
29
 * Copyright (c) 2002-2007, Professor Benoit Macq
30
 * Copyright (c) 2001-2003, David Janssens
31
 * Copyright (c) 2002-2003, Yannick Verschueren
32
 * Copyright (c) 2003-2007, Francois-Olivier Devaux and Antonin Descampe
33
 * Copyright (c) 2005, Herve Drolon, FreeImage Team
34
 * Copyright (c) 2007, Callum Lerwick <seg@haxxed.com>
35
 * Copyright (c) 2020, Gautam Ramakrishnan <gautamramk@gmail.com>
36
 * All rights reserved.
37
 *
38
 * Redistribution and use in source and binary forms, with or without
39
 * modification, are permitted provided that the following conditions
40
 * are met:
41
 * 1. Redistributions of source code must retain the above copyright
42
 *    notice, this list of conditions and the following disclaimer.
43
 * 2. Redistributions in binary form must reproduce the above copyright
44
 *    notice, this list of conditions and the following disclaimer in the
45
 *    documentation and/or other materials provided with the distribution.
46
 *
47
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
48
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
51
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
52
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
53
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
54
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
55
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
56
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
57
 * POSSIBILITY OF SUCH DAMAGE.
58
 */
59
60
61
/**
62
 * JPEG2000 image encoder
63
 * @file
64
 * @author Kamil Nowosad
65
 */
66
67
#include <float.h>
68
#include "avcodec.h"
69
#include "internal.h"
70
#include "bytestream.h"
71
#include "jpeg2000.h"
72
#include "libavutil/common.h"
73
#include "libavutil/pixdesc.h"
74
#include "libavutil/opt.h"
75
#include "libavutil/intreadwrite.h"
76
#include "libavutil/avstring.h"
77
78
#define NMSEDEC_BITS 7
79
#define NMSEDEC_FRACBITS (NMSEDEC_BITS-1)
80
#define WMSEDEC_SHIFT 13 ///< must be >= 13
81
#define LAMBDA_SCALE (100000000LL << (WMSEDEC_SHIFT - 13))
82
83
#define CODEC_JP2 1
84
#define CODEC_J2K 0
85
86
static int lut_nmsedec_ref [1<<NMSEDEC_BITS],
87
           lut_nmsedec_ref0[1<<NMSEDEC_BITS],
88
           lut_nmsedec_sig [1<<NMSEDEC_BITS],
89
           lut_nmsedec_sig0[1<<NMSEDEC_BITS];
90
91
static const int dwt_norms[2][4][10] = { // [dwt_type][band][rlevel] (multiplied by 10000)
92
    {{10000, 19650, 41770,  84030, 169000, 338400,  676900, 1353000, 2706000, 5409000},
93
     {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
94
     {20220, 39890, 83550, 170400, 342700, 686300, 1373000, 2746000, 5490000},
95
     {20800, 38650, 83070, 171800, 347100, 695900, 1393000, 2786000, 5572000}},
96
97
    {{10000, 15000, 27500, 53750, 106800, 213400, 426700, 853300, 1707000, 3413000},
98
     {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
99
     {10380, 15920, 29190, 57030, 113300, 226400, 452500, 904800, 1809000},
100
     { 7186,  9218, 15860, 30430,  60190, 120100, 240000, 479700,  959300}}
101
};
102
103
typedef struct {
104
   Jpeg2000Component *comp;
105
   double *layer_rates;
106
} Jpeg2000Tile;
107
108
typedef struct {
109
    AVClass *class;
110
    AVCodecContext *avctx;
111
    const AVFrame *picture;
112
113
    int width, height; ///< image width and height
114
    uint8_t cbps[4]; ///< bits per sample in particular components
115
    int chroma_shift[2];
116
    uint8_t planar;
117
    int ncomponents;
118
    int tile_width, tile_height; ///< tile size
119
    int numXtiles, numYtiles;
120
121
    uint8_t *buf_start;
122
    uint8_t *buf;
123
    uint8_t *buf_end;
124
    int bit_index;
125
126
    int64_t lambda;
127
128
    Jpeg2000CodingStyle codsty;
129
    Jpeg2000QuantStyle  qntsty;
130
131
    Jpeg2000Tile *tile;
132
    int layer_rates[100];
133
    uint8_t compression_rate_enc; ///< Is compression done using compression ratio?
134
135
    int format;
136
    int pred;
137
    int sop;
138
    int eph;
139
    int prog;
140
    int nlayers;
141
    char *lr_str;
142
} Jpeg2000EncoderContext;
143
144
145
/* debug */
146
#if 0
147
#undef ifprintf
148
#undef printf
149
150
static void nspaces(FILE *fd, int n)
151
{
152
    while(n--) putc(' ', fd);
153
}
154
155
static void printcomp(Jpeg2000Component *comp)
156
{
157
    int i;
158
    for (i = 0; i < comp->y1 - comp->y0; i++)
159
        ff_jpeg2000_printv(comp->i_data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);
160
}
161
162
static void dump(Jpeg2000EncoderContext *s, FILE *fd)
163
{
164
    int tileno, compno, reslevelno, bandno, precno;
165
    fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
166
                "numXtiles = %d, numYtiles = %d, ncomponents = %d\n"
167
                "tiles:\n",
168
            s->width, s->height, s->tile_width, s->tile_height,
169
            s->numXtiles, s->numYtiles, s->ncomponents);
170
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
171
        Jpeg2000Tile *tile = s->tile + tileno;
172
        nspaces(fd, 2);
173
        fprintf(fd, "tile %d:\n", tileno);
174
        for(compno = 0; compno < s->ncomponents; compno++){
175
            Jpeg2000Component *comp = tile->comp + compno;
176
            nspaces(fd, 4);
177
            fprintf(fd, "component %d:\n", compno);
178
            nspaces(fd, 4);
179
            fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
180
                        comp->x0, comp->x1, comp->y0, comp->y1);
181
            for(reslevelno = 0; reslevelno < s->nreslevels; reslevelno++){
182
                Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
183
                nspaces(fd, 6);
184
                fprintf(fd, "reslevel %d:\n", reslevelno);
185
                nspaces(fd, 6);
186
                fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d, nbands = %d\n",
187
                        reslevel->x0, reslevel->x1, reslevel->y0,
188
                        reslevel->y1, reslevel->nbands);
189
                for(bandno = 0; bandno < reslevel->nbands; bandno++){
190
                    Jpeg2000Band *band = reslevel->band + bandno;
191
                    nspaces(fd, 8);
192
                    fprintf(fd, "band %d:\n", bandno);
193
                    nspaces(fd, 8);
194
                    fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d,"
195
                                "codeblock_width = %d, codeblock_height = %d cblknx = %d cblkny = %d\n",
196
                                band->x0, band->x1,
197
                                band->y0, band->y1,
198
                                band->codeblock_width, band->codeblock_height,
199
                                band->cblknx, band->cblkny);
200
                    for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
201
                        Jpeg2000Prec *prec = band->prec + precno;
202
                        nspaces(fd, 10);
203
                        fprintf(fd, "prec %d:\n", precno);
204
                        nspaces(fd, 10);
205
                        fprintf(fd, "xi0 = %d, xi1 = %d, yi0 = %d, yi1 = %d\n",
206
                                     prec->xi0, prec->xi1, prec->yi0, prec->yi1);
207
                    }
208
                }
209
            }
210
        }
211
    }
212
}
213
#endif
214
215
/* bitstream routines */
216
217
/** put n times val bit */
218
8966043
static void put_bits(Jpeg2000EncoderContext *s, int val, int n) // TODO: optimize
219
{
220
15424806
    while (n-- > 0){
221
6458763
        if (s->bit_index == 8)
222
        {
223
792476
            s->bit_index = *s->buf == 0xff;
224
792476
            *(++s->buf) = 0;
225
        }
226
6458763
        *s->buf |= val << (7 - s->bit_index++);
227
    }
228
8966043
}
229
230
/** put n least significant bits of a number num */
231
761232
static void put_num(Jpeg2000EncoderContext *s, int num, int n)
232
{
233
5223634
    while(--n >= 0)
234
4462402
        put_bits(s, (num >> n) & 1, 1);
235
761232
}
236
237
/** flush the bitstream */
238
27300
static void j2k_flush(Jpeg2000EncoderContext *s)
239
{
240
27300
    if (s->bit_index){
241
27300
        s->bit_index = 0;
242
27300
        s->buf++;
243
    }
244
27300
}
245
246
/* tag tree routines */
247
248
/** code the value stored in node */
249
794016
static void tag_tree_code(Jpeg2000EncoderContext *s, Jpeg2000TgtNode *node, int threshold)
250
{
251
    Jpeg2000TgtNode *stack[30];
252
794016
    int sp = -1, curval = 0;
253
254
2648353
    while(node->parent){
255
1854337
        stack[++sp] = node;
256
1854337
        node = node->parent;
257
    }
258
259
    while (1) {
260
2648353
        if (curval > node->temp_val)
261
467648
            node->temp_val = curval;
262
        else {
263
2180705
            curval = node->temp_val;
264
        }
265
266
2648353
        if (node->val >= threshold) {
267
38097
            put_bits(s, 0, threshold - curval);
268
38097
            curval = threshold;
269
        } else {
270
2610256
            put_bits(s, 0, node->val - curval);
271
2610256
            curval = node->val;
272
2610256
            if (!node->vis) {
273
1066756
                put_bits(s, 1, 1);
274
1066756
                node->vis = 1;
275
            }
276
        }
277
278
2648353
        node->temp_val = curval;
279
2648353
        if (sp < 0)
280
794016
            break;
281
1854337
        node = stack[sp--];
282
    }
283
794016
}
284
285
/** update the value in node */
286
826800
static void tag_tree_update(Jpeg2000TgtNode *node)
287
{
288
826800
    int lev = 0;
289
1220500
    while (node->parent){
290
1062010
        if (node->parent->val <= node->val)
291
668310
            break;
292
393700
        node->parent->val = node->val;
293
393700
        node = node->parent;
294
393700
        lev++;
295
    }
296
826800
}
297
298
400
static int put_siz(Jpeg2000EncoderContext *s)
299
{
300
    int i;
301
302
400
    if (s->buf_end - s->buf < 40 + 3 * s->ncomponents)
303
        return -1;
304
305
400
    bytestream_put_be16(&s->buf, JPEG2000_SIZ);
306
400
    bytestream_put_be16(&s->buf, 38 + 3 * s->ncomponents); // Lsiz
307
400
    bytestream_put_be16(&s->buf, 0); // Rsiz
308
400
    bytestream_put_be32(&s->buf, s->width); // width
309
400
    bytestream_put_be32(&s->buf, s->height); // height
310
400
    bytestream_put_be32(&s->buf, 0); // X0Siz
311
400
    bytestream_put_be32(&s->buf, 0); // Y0Siz
312
313
400
    bytestream_put_be32(&s->buf, s->tile_width); // XTSiz
314
400
    bytestream_put_be32(&s->buf, s->tile_height); // YTSiz
315
400
    bytestream_put_be32(&s->buf, 0); // XT0Siz
316
400
    bytestream_put_be32(&s->buf, 0); // YT0Siz
317
400
    bytestream_put_be16(&s->buf, s->ncomponents); // CSiz
318
319
1600
    for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i
320
1200
        bytestream_put_byte(&s->buf, s->cbps[i] - 1);
321
1200
        bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[0]:1);
322
1200
        bytestream_put_byte(&s->buf, i?1<<s->chroma_shift[1]:1);
323
    }
324
400
    return 0;
325
}
326
327
400
static int put_cod(Jpeg2000EncoderContext *s)
328
{
329
400
    Jpeg2000CodingStyle *codsty = &s->codsty;
330
400
    uint8_t scod = 0;
331
332
400
    if (s->buf_end - s->buf < 14)
333
        return -1;
334
335
400
    bytestream_put_be16(&s->buf, JPEG2000_COD);
336
400
    bytestream_put_be16(&s->buf, 12); // Lcod
337
400
    if (s->sop)
338
        scod |= JPEG2000_CSTY_SOP;
339
400
    if (s->eph)
340
        scod |= JPEG2000_CSTY_EPH;
341
400
    bytestream_put_byte(&s->buf, scod);  // Scod
342
    // SGcod
343
400
    bytestream_put_byte(&s->buf, s->prog); // progression level
344
400
    bytestream_put_be16(&s->buf, s->nlayers); // num of layers
345
400
    if(s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
346
        bytestream_put_byte(&s->buf, 0); // unspecified
347
    }else{
348
400
        bytestream_put_byte(&s->buf, 0); // unspecified
349
    }
350
    // SPcod
351
400
    bytestream_put_byte(&s->buf, codsty->nreslevels - 1); // num of decomp. levels
352
400
    bytestream_put_byte(&s->buf, codsty->log2_cblk_width-2); // cblk width
353
400
    bytestream_put_byte(&s->buf, codsty->log2_cblk_height-2); // cblk height
354
400
    bytestream_put_byte(&s->buf, 0); // cblk style
355
400
    bytestream_put_byte(&s->buf, codsty->transform == FF_DWT53); // transformation
356
400
    return 0;
357
}
358
359
400
static int put_qcd(Jpeg2000EncoderContext *s, int compno)
360
{
361
    int i, size;
362
400
    Jpeg2000CodingStyle *codsty = &s->codsty;
363
400
    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
364
365
400
    if (qntsty->quantsty == JPEG2000_QSTY_NONE)
366
200
        size = 4 + 3 * (codsty->nreslevels-1);
367
    else // QSTY_SE
368
200
        size = 5 + 6 * (codsty->nreslevels-1);
369
370
400
    if (s->buf_end - s->buf < size + 2)
371
        return -1;
372
373
400
    bytestream_put_be16(&s->buf, JPEG2000_QCD);
374
400
    bytestream_put_be16(&s->buf, size);  // LQcd
375
400
    bytestream_put_byte(&s->buf, (qntsty->nguardbits << 5) | qntsty->quantsty);  // Sqcd
376
400
    if (qntsty->quantsty == JPEG2000_QSTY_NONE)
377
4000
        for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
378
3800
            bytestream_put_byte(&s->buf, qntsty->expn[i] << 3);
379
    else // QSTY_SE
380
4000
        for (i = 0; i < codsty->nreslevels * 3 - 2; i++)
381
3800
            bytestream_put_be16(&s->buf, (qntsty->expn[i] << 11) | qntsty->mant[i]);
382
400
    return 0;
383
}
384
385
400
static int put_com(Jpeg2000EncoderContext *s, int compno)
386
{
387
400
    int size = 4 + strlen(LIBAVCODEC_IDENT);
388
389
400
    if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
390
400
        return 0;
391
392
    if (s->buf_end - s->buf < size + 2)
393
        return -1;
394
395
    bytestream_put_be16(&s->buf, JPEG2000_COM);
396
    bytestream_put_be16(&s->buf, size);
397
    bytestream_put_be16(&s->buf, 1); // General use (ISO/IEC 8859-15 (Latin) values)
398
399
    bytestream_put_buffer(&s->buf, LIBAVCODEC_IDENT, strlen(LIBAVCODEC_IDENT));
400
401
    return 0;
402
}
403
404
1300
static uint8_t *put_sot(Jpeg2000EncoderContext *s, int tileno)
405
{
406
    uint8_t *psotptr;
407
408
1300
    if (s->buf_end - s->buf < 12)
409
        return NULL;
410
411
1300
    bytestream_put_be16(&s->buf, JPEG2000_SOT);
412
1300
    bytestream_put_be16(&s->buf, 10); // Lsot
413
1300
    bytestream_put_be16(&s->buf, tileno); // Isot
414
415
1300
    psotptr = s->buf;
416
1300
    bytestream_put_be32(&s->buf, 0); // Psot (filled in later)
417
418
1300
    bytestream_put_byte(&s->buf, 0); // TPsot
419
1300
    bytestream_put_byte(&s->buf, 1); // TNsot
420
1300
    return psotptr;
421
}
422
423
8
static void compute_rates(Jpeg2000EncoderContext* s)
424
{
425
    int i, j;
426
    int layno, compno;
427
22
    for (i = 0; i < s->numYtiles; i++) {
428
40
        for (j = 0; j < s->numXtiles; j++) {
429
26
            Jpeg2000Tile *tile = &s->tile[s->numXtiles * i + j];
430
104
            for (compno = 0; compno < s->ncomponents; compno++) {
431
78
                int tilew = tile->comp[compno].coord[0][1] - tile->comp[compno].coord[0][0];
432
78
                int tileh = tile->comp[compno].coord[1][1] - tile->comp[compno].coord[1][0];
433

78
                int scale = (compno?1 << s->chroma_shift[0]:1) * (compno?1 << s->chroma_shift[1]:1);
434
156
                for (layno = 0; layno < s->nlayers; layno++) {
435
78
                    if (s->layer_rates[layno] > 0) {
436
                        tile->layer_rates[layno] += (double)(tilew * tileh) * s->ncomponents * s->cbps[compno] /
437
                                                    (double)(s->layer_rates[layno] * 8 * scale);
438
                    } else {
439
78
                        tile->layer_rates[layno] = 0.0;
440
                    }
441
                }
442
            }
443
        }
444
    }
445
446
8
}
447
448
/**
449
 * compute the sizes of tiles, resolution levels, bands, etc.
450
 * allocate memory for them
451
 * divide the input image into tile-components
452
 */
453
8
static int init_tiles(Jpeg2000EncoderContext *s)
454
{
455
    int tileno, tilex, tiley, compno;
456
8
    Jpeg2000CodingStyle *codsty = &s->codsty;
457
8
    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
458
459
8
    s->numXtiles = ff_jpeg2000_ceildiv(s->width, s->tile_width);
460
8
    s->numYtiles = ff_jpeg2000_ceildiv(s->height, s->tile_height);
461
462
8
    s->tile = av_calloc(s->numXtiles, s->numYtiles * sizeof(Jpeg2000Tile));
463
8
    if (!s->tile)
464
        return AVERROR(ENOMEM);
465
22
    for (tileno = 0, tiley = 0; tiley < s->numYtiles; tiley++)
466
40
        for (tilex = 0; tilex < s->numXtiles; tilex++, tileno++){
467
26
            Jpeg2000Tile *tile = s->tile + tileno;
468
469
26
            tile->comp = av_mallocz_array(s->ncomponents, sizeof(Jpeg2000Component));
470
26
            if (!tile->comp)
471
                return AVERROR(ENOMEM);
472
473
26
            tile->layer_rates = av_mallocz_array(s->nlayers, sizeof(*tile->layer_rates));
474
26
            if (!tile->layer_rates)
475
                return AVERROR(ENOMEM);
476
477
104
            for (compno = 0; compno < s->ncomponents; compno++){
478
78
                Jpeg2000Component *comp = tile->comp + compno;
479
                int ret, i, j;
480
481
78
                comp->coord[0][0] = comp->coord_o[0][0] = tilex * s->tile_width;
482
78
                comp->coord[0][1] = comp->coord_o[0][1] = FFMIN((tilex+1)*s->tile_width, s->width);
483
78
                comp->coord[1][0] = comp->coord_o[1][0] = tiley * s->tile_height;
484
78
                comp->coord[1][1] = comp->coord_o[1][1] = FFMIN((tiley+1)*s->tile_height, s->height);
485
78
                if (compno > 0)
486
156
                    for (i = 0; i < 2; i++)
487
312
                        for (j = 0; j < 2; j++)
488
208
                            comp->coord[i][j] = comp->coord_o[i][j] = ff_jpeg2000_ceildivpow2(comp->coord[i][j], s->chroma_shift[i]);
489
490

208
                if ((ret = ff_jpeg2000_init_component(comp,
491
                                                codsty,
492
                                                qntsty,
493
78
                                                s->cbps[compno],
494
52
                                                compno?1<<s->chroma_shift[0]:1,
495
52
                                                compno?1<<s->chroma_shift[1]:1,
496
                                                s->avctx
497
                                               )) < 0)
498
                    return ret;
499
            }
500
        }
501
8
    compute_rates(s);
502
8
    return 0;
503
}
504
505
#define COPY_FRAME(D, PIXEL)                                                                                                \
506
    static void copy_frame_ ##D(Jpeg2000EncoderContext *s)                                                                  \
507
    {                                                                                                                       \
508
        int tileno, compno, i, y, x;                                                                                        \
509
        PIXEL *line;                                                                                                        \
510
        for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){                                                   \
511
            Jpeg2000Tile *tile = s->tile + tileno;                                                                          \
512
            if (s->planar){                                                                                                 \
513
                for (compno = 0; compno < s->ncomponents; compno++){                                                        \
514
                    Jpeg2000Component *comp = tile->comp + compno;                                                          \
515
                    int *dst = comp->i_data;                                                                                \
516
                    int cbps = s->cbps[compno];                                                                             \
517
                    line = (PIXEL*)s->picture->data[compno]                                                                 \
518
                           + comp->coord[1][0] * (s->picture->linesize[compno] / sizeof(PIXEL))                             \
519
                           + comp->coord[0][0];                                                                             \
520
                    for (y = comp->coord[1][0]; y < comp->coord[1][1]; y++){                                                \
521
                        PIXEL *ptr = line;                                                                                  \
522
                        for (x = comp->coord[0][0]; x < comp->coord[0][1]; x++)                                             \
523
                            *dst++ = *ptr++ - (1 << (cbps - 1));                                                            \
524
                        line += s->picture->linesize[compno] / sizeof(PIXEL);                                               \
525
                    }                                                                                                       \
526
                }                                                                                                           \
527
            } else{                                                                                                         \
528
                line = (PIXEL*)s->picture->data[0] + tile->comp[0].coord[1][0] * (s->picture->linesize[0] / sizeof(PIXEL))  \
529
                       + tile->comp[0].coord[0][0] * s->ncomponents;                                                        \
530
                                                                                                                            \
531
                i = 0;                                                                                                      \
532
                for (y = tile->comp[0].coord[1][0]; y < tile->comp[0].coord[1][1]; y++){                                    \
533
                    PIXEL *ptr = line;                                                                                      \
534
                    for (x = tile->comp[0].coord[0][0]; x < tile->comp[0].coord[0][1]; x++, i++){                           \
535
                        for (compno = 0; compno < s->ncomponents; compno++){                                                \
536
                            int cbps = s->cbps[compno];                                                                     \
537
                            tile->comp[compno].i_data[i] = *ptr++  - (1 << (cbps - 1));                                     \
538
                        }                                                                                                   \
539
                    }                                                                                                       \
540
                    line += s->picture->linesize[0] / sizeof(PIXEL);                                                        \
541
                }                                                                                                           \
542
            }                                                                                                               \
543
        }                                                                                                                   \
544
    }
545
546




122291500
COPY_FRAME(8, uint8_t)
547
COPY_FRAME(16, uint16_t)
548
549
8
static void init_quantization(Jpeg2000EncoderContext *s)
550
{
551
    int compno, reslevelno, bandno;
552
8
    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
553
8
    Jpeg2000CodingStyle *codsty = &s->codsty;
554
555
32
    for (compno = 0; compno < s->ncomponents; compno++){
556
24
        int gbandno = 0;
557
192
        for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
558
168
            int nbands, lev = codsty->nreslevels - reslevelno - 1;
559
168
            nbands = reslevelno ? 3 : 1;
560
624
            for (bandno = 0; bandno < nbands; bandno++, gbandno++){
561
456
                int expn, mant = 0;
562
563
456
                if (codsty->transform == FF_DWT97_INT){
564
228
                    int bandpos = bandno + (reslevelno>0),
565
228
                        ss = 81920000 / dwt_norms[0][bandpos][lev],
566
228
                        log = av_log2(ss);
567
228
                    mant = (11 - log < 0 ? ss >> log - 11 : ss << 11 - log) & 0x7ff;
568
228
                    expn = s->cbps[compno] - log + 13;
569
                } else
570
228
                    expn = ((bandno&2)>>1) + (reslevelno>0) + s->cbps[compno];
571
572
456
                qntsty->expn[gbandno] = expn;
573
456
                qntsty->mant[gbandno] = mant;
574
            }
575
        }
576
    }
577
8
}
578
579
8
static void init_luts(void)
580
{
581
    int i, a,
582
8
        mask = ~((1<<NMSEDEC_FRACBITS)-1);
583
584
1032
    for (i = 0; i < (1 << NMSEDEC_BITS); i++){
585
1024
        lut_nmsedec_sig[i]  = FFMAX((3 * i << (13 - NMSEDEC_FRACBITS)) - (9 << 11), 0);
586
1024
        lut_nmsedec_sig0[i] = FFMAX((i*i + (1<<NMSEDEC_FRACBITS-1) & mask) << 1, 0);
587
588
1024
        a = (i >> (NMSEDEC_BITS-2)&2) + 1;
589
1024
        lut_nmsedec_ref[i]  = FFMAX((a - 2) * (i << (13 - NMSEDEC_FRACBITS)) +
590
                                    (1 << 13) - (a * a << 11), 0);
591
1024
        lut_nmsedec_ref0[i] = FFMAX(((i * i - (i << NMSEDEC_BITS) + (1 << 2 * NMSEDEC_FRACBITS) + (1 << (NMSEDEC_FRACBITS - 1))) & mask)
592
                                    << 1, 0);
593
    }
594
8
}
595
596
/* tier-1 routines */
597
73779107
static int getnmsedec_sig(int x, int bpno)
598
{
599
73779107
    if (bpno > NMSEDEC_FRACBITS)
600
57508511
        return lut_nmsedec_sig[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
601
16270596
    return lut_nmsedec_sig0[x & ((1 << NMSEDEC_BITS) - 1)];
602
}
603
604
155371831
static int getnmsedec_ref(int x, int bpno)
605
{
606
155371831
    if (bpno > NMSEDEC_FRACBITS)
607
97863320
        return lut_nmsedec_ref[(x >> (bpno - NMSEDEC_FRACBITS)) & ((1 << NMSEDEC_BITS) - 1)];
608
57508511
    return lut_nmsedec_ref0[x & ((1 << NMSEDEC_BITS) - 1)];
609
}
610
611
2341659
static void encode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
612
{
613
2341659
    int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
614
10642563
    for (y0 = 0; y0 < height; y0 += 4)
615
133682311
        for (x = 0; x < width; x++)
616

624667412
            for (y = y0; y < height && y < y0+4; y++){
617

499286005
                if (!(t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG) && (t1->flags[(y+1) * t1->stride + x+1] & JPEG2000_T1_SIG_NB)){
618
163633824
                    int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno),
619
163633824
                        bit = t1->data[(y) * t1->stride + x] & mask ? 1 : 0;
620
163633824
                    ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, bit);
621
163633824
                    if (bit){
622
                        int xorbit;
623
59386202
                        int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
624
59386202
                        ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
625
59386202
                        *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
626
59386202
                        ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
627
                    }
628
163633824
                    t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_VIS;
629
                }
630
            }
631
2341659
}
632
633
2341659
static void encode_refpass(Jpeg2000T1Context *t1, int width, int height, int *nmsedec, int bpno)
634
{
635
2341659
    int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
636
10642563
    for (y0 = 0; y0 < height; y0 += 4)
637
133682311
        for (x = 0; x < width; x++)
638

624667412
            for (y = y0; y < height && y < y0+4; y++)
639
499286005
                if ((t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS)) == JPEG2000_T1_SIG){
640
155371831
                    int ctxno = ff_jpeg2000_getrefctxno(t1->flags[(y+1) * t1->stride + x+1]);
641
155371831
                    *nmsedec += getnmsedec_ref(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
642
155371831
                    ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
643
155371831
                    t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_REF;
644
                }
645
2341659
}
646
647
2755058
static void encode_clnpass(Jpeg2000T1Context *t1, int width, int height, int bandno, int *nmsedec, int bpno)
648
{
649
2755058
    int y0, x, y, mask = 1 << (bpno + NMSEDEC_FRACBITS);
650
12558961
    for (y0 = 0; y0 < height; y0 += 4)
651
158157809
        for (x = 0; x < width; x++){
652
148353906
            if (y0 + 3 < height && !(
653
147328814
            (t1->flags[(y0+1) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
654
57872409
            (t1->flags[(y0+2) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
655
52649523
            (t1->flags[(y0+3) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG)) ||
656
48304510
            (t1->flags[(y0+4) * t1->stride + x+1] & (JPEG2000_T1_SIG_NB | JPEG2000_T1_VIS | JPEG2000_T1_SIG))))
657
3619464
            {
658
                // aggregation mode
659
                int rlen;
660
221843104
                for (rlen = 0; rlen < 4; rlen++)
661
179323436
                    if (t1->data[(y0+rlen) * t1->stride + x] & mask)
662
3619464
                        break;
663
46139132
                ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_RL, rlen != 4);
664
46139132
                if (rlen == 4)
665
42519668
                    continue;
666
3619464
                ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen >> 1);
667
3619464
                ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + MQC_CX_UNI, rlen & 1);
668
12472020
                for (y = y0 + rlen; y < y0 + 4; y++){
669
8852556
                    if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
670
8852556
                        int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
671
8852556
                        if (y > y0 + rlen)
672
5233092
                            ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
673
8852556
                        if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
674
                            int xorbit;
675
4325058
                            int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
676
4325058
                            *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
677
4325058
                            ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
678
4325058
                            ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
679
                        }
680
                    }
681
8852556
                    t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
682
                }
683
            } else{
684

508529450
                for (y = y0; y < y0 + 4 && y < height; y++){
685
406314676
                    if (!(t1->flags[(y+1) * t1->stride + x+1] & (JPEG2000_T1_SIG | JPEG2000_T1_VIS))){
686
87309021
                        int ctxno = ff_jpeg2000_getsigctxno(t1->flags[(y+1) * t1->stride + x+1], bandno);
687
87309021
                        ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, t1->data[(y) * t1->stride + x] & mask ? 1:0);
688
87309021
                        if (t1->data[(y) * t1->stride + x] & mask){ // newly significant
689
                            int xorbit;
690
10067847
                            int ctxno = ff_jpeg2000_getsgnctxno(t1->flags[(y+1) * t1->stride + x+1], &xorbit);
691
10067847
                            *nmsedec += getnmsedec_sig(t1->data[(y) * t1->stride + x], bpno + NMSEDEC_FRACBITS);
692
10067847
                            ff_mqc_encode(&t1->mqc, t1->mqc.cx_states + ctxno, (t1->flags[(y+1) * t1->stride + x+1] >> 15) ^ xorbit);
693
10067847
                            ff_jpeg2000_set_significance(t1, x, y, t1->flags[(y+1) * t1->stride + x+1] >> 15);
694
                        }
695
                    }
696
406314676
                    t1->flags[(y+1) * t1->stride + x+1] &= ~JPEG2000_T1_VIS;
697
                }
698
            }
699
        }
700
2755058
}
701
702
413400
static void encode_cblk(Jpeg2000EncoderContext *s, Jpeg2000T1Context *t1, Jpeg2000Cblk *cblk, Jpeg2000Tile *tile,
703
                        int width, int height, int bandpos, int lev)
704
{
705
413400
    int pass_t = 2, passno, x, y, max=0, nmsedec, bpno;
706
413400
    int64_t wmsedec = 0;
707
708
413400
    memset(t1->flags, 0, t1->stride * (height + 2) * sizeof(*t1->flags));
709
710
6372900
    for (y = 0; y < height; y++){
711
97544700
        for (x = 0; x < width; x++){
712
91585200
            if (t1->data[(y) * t1->stride + x] < 0){
713
35748311
                t1->flags[(y+1) * t1->stride + x+1] |= JPEG2000_T1_SGN;
714
35748311
                t1->data[(y) * t1->stride + x] = -t1->data[(y) * t1->stride + x];
715
            }
716
91585200
            max = FFMAX(max, t1->data[(y) * t1->stride + x]);
717
        }
718
    }
719
720
413400
    if (max == 0){
721
51
        cblk->nonzerobits = 0;
722
51
        bpno = 0;
723
    } else{
724
413349
        cblk->nonzerobits = av_log2(max) + 1 - NMSEDEC_FRACBITS;
725
413349
        bpno = cblk->nonzerobits - 1;
726
    }
727
728
413400
    cblk->data[0] = 0;
729
413400
    ff_mqc_initenc(&t1->mqc, cblk->data + 1);
730
731
7851776
    for (passno = 0; bpno >= 0; passno++){
732
7438376
        nmsedec=0;
733
734

7438376
        switch(pass_t){
735
2341659
            case 0: encode_sigpass(t1, width, height, bandpos, &nmsedec, bpno);
736
2341659
                    break;
737
2341659
            case 1: encode_refpass(t1, width, height, &nmsedec, bpno);
738
2341659
                    break;
739
2755058
            case 2: encode_clnpass(t1, width, height, bandpos, &nmsedec, bpno);
740
2755058
                    break;
741
        }
742
743
7438376
        cblk->passes[passno].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno].flushed, &cblk->passes[passno].flushed_len);
744
7438376
        cblk->passes[passno].rate -= cblk->passes[passno].flushed_len;
745
746
7438376
        wmsedec += (int64_t)nmsedec << (2*bpno);
747
7438376
        cblk->passes[passno].disto = wmsedec;
748
749
7438376
        if (++pass_t == 3){
750
2755058
            pass_t = 0;
751
2755058
            bpno--;
752
        }
753
    }
754
413400
    cblk->npasses = passno;
755
413400
    cblk->ninclpasses = passno;
756
757
413400
    if (passno) {
758
413399
        cblk->passes[passno-1].rate = ff_mqc_flush_to(&t1->mqc, cblk->passes[passno-1].flushed, &cblk->passes[passno-1].flushed_len);
759
413399
        cblk->passes[passno-1].rate -= cblk->passes[passno-1].flushed_len;
760
    }
761
413400
}
762
763
/* tier-2 routines: */
764
765
380616
static void putnumpasses(Jpeg2000EncoderContext *s, int n)
766
{
767
380616
    if (n == 1)
768
45405
        put_num(s, 0, 1);
769
335211
    else if (n == 2)
770
13331
        put_num(s, 2, 2);
771
321880
    else if (n <= 5)
772
111816
        put_num(s, 0xc | (n-3), 4);
773
210064
    else if (n <= 36)
774
210061
        put_num(s, 0x1e0 | (n-6), 9);
775
    else
776
3
        put_num(s, 0xff80 | (n-37), 16);
777
380616
}
778
779
780
27300
static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int layno,
781
                         int precno, uint8_t *expn, int numgbits, int packetno,
782
                         int nlayers)
783
{
784
27300
    int bandno, empty = 1;
785
    int i;
786
    // init bitstream
787
27300
    *s->buf = 0;
788
27300
    s->bit_index = 0;
789
790
27300
    if (s->sop) {
791
        bytestream_put_be16(&s->buf, JPEG2000_SOP);
792
        bytestream_put_be16(&s->buf, 4);
793
        bytestream_put_be16(&s->buf, packetno);
794
    }
795
    // header
796
797
27300
    if (!layno) {
798
101400
        for (bandno = 0; bandno < rlevel->nbands; bandno++) {
799
74100
            Jpeg2000Band *band = rlevel->band + bandno;
800
74100
            if (band->coord[0][0] < band->coord[0][1]
801
74100
            &&  band->coord[1][0] < band->coord[1][1]) {
802
70500
                Jpeg2000Prec *prec = band->prec + precno;
803
70500
                int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
804
                int pos;
805
70500
                ff_tag_tree_zero(prec->zerobits, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);
806
70500
                ff_tag_tree_zero(prec->cblkincl, prec->nb_codeblocks_width, prec->nb_codeblocks_height, 99);
807
483900
                for (pos = 0; pos < nb_cblks; pos++) {
808
413400
                    Jpeg2000Cblk *cblk = &prec->cblk[pos];
809
413400
                    prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - cblk->nonzerobits;
810
413400
                    cblk->incl = 0;
811
413400
                    cblk->lblock = 3;
812
413400
                    tag_tree_update(prec->zerobits + pos);
813
446184
                    for (i = 0; i < nlayers; i++) {
814
413400
                        if (cblk->layers[i].npasses > 0) {
815
380616
                            prec->cblkincl[pos].val = i;
816
380616
                            break;
817
                        }
818
                    }
819
413400
                    if (i == nlayers)
820
32784
                        prec->cblkincl[pos].val = i;
821
413400
                    tag_tree_update(prec->cblkincl + pos);
822
                }
823
            }
824
        }
825
    }
826
827
    // is the packet empty?
828
27309
    for (bandno = 0; bandno < rlevel->nbands; bandno++){
829
27309
        Jpeg2000Band *band = rlevel->band + bandno;
830
27309
        if (band->coord[0][0] < band->coord[0][1]
831
27309
        &&  band->coord[1][0] < band->coord[1][1]) {
832
27309
            Jpeg2000Prec *prec = band->prec + precno;
833
27309
            int nb_cblks = prec->nb_codeblocks_height * prec->nb_codeblocks_width;
834
            int pos;
835
27563
            for (pos = 0; pos < nb_cblks; pos++) {
836
27554
                Jpeg2000Cblk *cblk = &prec->cblk[pos];
837
27554
                if (cblk->layers[layno].npasses) {
838
27300
                    empty = 0;
839
27300
                    break;
840
                }
841
            }
842
27309
            if (!empty)
843
27300
                break;
844
        }
845
    }
846
847
27300
    put_bits(s, !empty, 1);
848
27300
    if (empty){
849
        j2k_flush(s);
850
        if (s->eph)
851
            bytestream_put_be16(&s->buf, JPEG2000_EPH);
852
        return 0;
853
    }
854
855
101400
    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
856
74100
        Jpeg2000Band *band = rlevel->band + bandno;
857
74100
        Jpeg2000Prec *prec = band->prec + precno;
858
        int yi, xi, pos;
859
74100
        int cblknw = prec->nb_codeblocks_width;
860
861
74100
        if (band->coord[0][0] == band->coord[0][1]
862
74100
        ||  band->coord[1][0] == band->coord[1][1])
863
3600
            continue;
864
865
201300
        for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++) {
866
544200
            for (xi = 0; xi < cblknw; xi++, pos++){
867
413400
                int llen = 0, length;
868
413400
                Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
869
870
413400
                if (s->buf_end - s->buf < 20) // approximately
871
                    return -1;
872
873
                // inclusion information
874
413400
                if (!cblk->incl)
875
413400
                    tag_tree_code(s, prec->cblkincl + pos, layno + 1);
876
                else {
877
                    put_bits(s, cblk->layers[layno].npasses > 0, 1);
878
                }
879
880
413400
                if (!cblk->layers[layno].npasses)
881
32784
                    continue;
882
883
                // zerobits information
884
380616
                if (!cblk->incl) {
885
380616
                    tag_tree_code(s, prec->zerobits + pos, 100);
886
380616
                    cblk->incl = 1;
887
                }
888
889
                // number of passes
890
380616
                putnumpasses(s, cblk->layers[layno].npasses);
891
892
380616
                length = cblk->layers[layno].data_len;
893

380616
                if (layno == nlayers - 1 && cblk->layers[layno].cum_passes){
894
380616
                    length += cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len;
895
                }
896
380616
                if (cblk->lblock + av_log2(cblk->layers[layno].npasses) < av_log2(length) + 1) {
897
113187
                    llen = av_log2(length) + 1 - cblk->lblock - av_log2(cblk->layers[layno].npasses);
898
                }
899
900
                // length of code block
901
380616
                cblk->lblock += llen;
902
380616
                put_bits(s, 1, llen);
903
380616
                put_bits(s, 0, 1);
904
380616
                put_num(s, length, cblk->lblock + av_log2(cblk->layers[layno].npasses));
905
            }
906
        }
907
    }
908
27300
    j2k_flush(s);
909
27300
    if (s->eph) {
910
        bytestream_put_be16(&s->buf, JPEG2000_EPH);
911
    }
912
913
101400
    for (bandno = 0; bandno < rlevel->nbands; bandno++) {
914
74100
        Jpeg2000Band *band = rlevel->band + bandno;
915
74100
        Jpeg2000Prec *prec = band->prec + precno;
916
74100
        int yi, cblknw = prec->nb_codeblocks_width;
917
208500
        for (yi =0; yi < prec->nb_codeblocks_height; yi++) {
918
            int xi;
919
551400
            for (xi = 0; xi < cblknw; xi++){
920
417000
                Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
921
417000
                if (cblk->layers[layno].npasses) {
922
380616
                    if (s->buf_end - s->buf < cblk->layers[layno].data_len + 2)
923
                        return -1;
924
380616
                    bytestream_put_buffer(&s->buf, cblk->layers[layno].data_start + 1, cblk->layers[layno].data_len);
925

380616
                    if (layno == nlayers - 1 && cblk->layers[layno].cum_passes) {
926
380616
                        bytestream_put_buffer(&s->buf, cblk->passes[cblk->layers[layno].cum_passes-1].flushed,
927
380616
                                                       cblk->passes[cblk->layers[layno].cum_passes-1].flushed_len);
928
                    }
929
                }
930
            }
931
        }
932
    }
933
27300
    return 0;
934
}
935
936
1300
static int encode_packets(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno, int nlayers)
937
{
938
    int compno, reslevelno, layno, ret;
939
1300
    Jpeg2000CodingStyle *codsty = &s->codsty;
940
1300
    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
941
1300
    int packetno = 0;
942
    int step_x, step_y;
943
    int x, y;
944
    int tile_coord[2][2];
945
1300
    int col = tileno % s->numXtiles;
946
1300
    int row = tileno / s->numXtiles;
947
948
1300
    tile_coord[0][0] = col * s->tile_width;
949
1300
    tile_coord[0][1] = FFMIN(tile_coord[0][0] + s->tile_width, s->width);
950
1300
    tile_coord[1][0] = row * s->tile_height;
951
1300
    tile_coord[1][1] = FFMIN(tile_coord[1][0] + s->tile_height, s->height);
952
953
1300
    av_log(s->avctx, AV_LOG_DEBUG, "tier2\n");
954
    // lay-rlevel-comp-pos progression
955

1300
    switch (s->prog) {
956
1300
    case JPEG2000_PGOD_LRCP:
957
2600
    for (layno = 0; layno < nlayers; layno++) {
958
10400
        for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
959
36400
            for (compno = 0; compno < s->ncomponents; compno++){
960
                int precno;
961
27300
                Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
962
54600
                for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
963
27300
                    if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
964
27300
                                qntsty->nguardbits, packetno++, nlayers)) < 0)
965
                        return ret;
966
                }
967
            }
968
        }
969
    }
970
1300
    break;
971
    case JPEG2000_PGOD_RLCP:
972
    for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
973
        for (layno = 0; layno < nlayers; layno++) {
974
            for (compno = 0; compno < s->ncomponents; compno++){
975
                int precno;
976
                Jpeg2000ResLevel *reslevel = s->tile[tileno].comp[compno].reslevel + reslevelno;
977
                for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
978
                    if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
979
                                qntsty->nguardbits, packetno++, nlayers)) < 0)
980
                        return ret;
981
                }
982
            }
983
        }
984
    }
985
    break;
986
    case JPEG2000_PGOD_RPCL:
987
    for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
988
        int precno;
989
        step_x = 30;
990
        step_y = 30;
991
        for (compno = 0; compno < s->ncomponents; compno++) {
992
            Jpeg2000Component *comp     = tile->comp + compno;
993
            if (reslevelno < codsty->nreslevels) {
994
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
995
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
996
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
997
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
998
            }
999
        }
1000
1001
        step_x = 1<<step_x;
1002
        step_y = 1<<step_y;
1003
        for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1004
            for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1005
                for (compno = 0; compno < s->ncomponents; compno++) {
1006
                    Jpeg2000Component *comp     = tile->comp + compno;
1007
                    uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1008
                    Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1009
                    int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1010
                    unsigned prcx, prcy;
1011
                    int trx0, try0;
1012
1013
                    trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1014
                    try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1015
1016
                    if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1017
                        (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1018
                        continue;
1019
1020
                    if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1021
                        (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1022
                        continue;
1023
1024
                    // check if a precinct exists
1025
                    prcx   = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1026
                    prcy   = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1027
                    prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1028
                    prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1029
                    precno = prcx + reslevel->num_precincts_x * prcy;
1030
1031
                    if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1032
                        av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1033
                               prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1034
                        continue;
1035
                    }
1036
                    for (layno = 0; layno < nlayers; layno++) {
1037
                        if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1038
                                qntsty->nguardbits, packetno++, nlayers)) < 0)
1039
                            return ret;
1040
                        }
1041
                    }
1042
                }
1043
            }
1044
    }
1045
    break;
1046
    case JPEG2000_PGOD_PCRL:
1047
        step_x = 32;
1048
        step_y = 32;
1049
        for (compno = 0; compno < s->ncomponents; compno++) {
1050
            Jpeg2000Component *comp     = tile->comp + compno;
1051
1052
            for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1053
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1054
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1055
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1056
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1057
            }
1058
        }
1059
        if (step_x >= 31 || step_y >= 31){
1060
            avpriv_request_sample(s->avctx, "PCRL with large step");
1061
            return AVERROR_PATCHWELCOME;
1062
        }
1063
        step_x = 1<<step_x;
1064
        step_y = 1<<step_y;
1065
1066
        for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1067
            for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1068
                for (compno = 0; compno < s->ncomponents; compno++) {
1069
                    Jpeg2000Component *comp     = tile->comp + compno;
1070
                    int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1071
1072
                    for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1073
                        unsigned prcx, prcy;
1074
                        int precno;
1075
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1076
                        Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1077
                        int trx0, try0;
1078
1079
                        trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1080
                        try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1081
1082
                        if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1083
                            (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1084
                            continue;
1085
1086
                        if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1087
                            (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1088
                            continue;
1089
1090
                        // check if a precinct exists
1091
                        prcx   = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1092
                        prcy   = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1093
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1094
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1095
1096
                        precno = prcx + reslevel->num_precincts_x * prcy;
1097
1098
                        if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1099
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1100
                                   prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1101
                            continue;
1102
                        }
1103
                        for (layno = 0; layno < nlayers; layno++) {
1104
                            if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1105
                                    qntsty->nguardbits, packetno++, nlayers)) < 0)
1106
                                return ret;
1107
                        }
1108
                    }
1109
                }
1110
            }
1111
        }
1112
    break;
1113
    case JPEG2000_PGOD_CPRL:
1114
        for (compno = 0; compno < s->ncomponents; compno++) {
1115
            Jpeg2000Component *comp     = tile->comp + compno;
1116
            int log_subsampling[2] = { compno?s->chroma_shift[0]:0, compno?s->chroma_shift[1]:0};
1117
            step_x = 32;
1118
            step_y = 32;
1119
1120
            for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1121
                uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1122
                Jpeg2000ResLevel *rlevel = comp->reslevel + reslevelno;
1123
                step_x = FFMIN(step_x, rlevel->log2_prec_width  + reducedresno);
1124
                step_y = FFMIN(step_y, rlevel->log2_prec_height + reducedresno);
1125
            }
1126
            if (step_x >= 31 || step_y >= 31){
1127
                avpriv_request_sample(s->avctx, "CPRL with large step");
1128
                return AVERROR_PATCHWELCOME;
1129
            }
1130
            step_x = 1<<step_x;
1131
            step_y = 1<<step_y;
1132
1133
            for (y = tile_coord[1][0]; y < tile_coord[1][1]; y = (y/step_y + 1)*step_y) {
1134
                for (x = tile_coord[0][0]; x < tile_coord[0][1]; x = (x/step_x + 1)*step_x) {
1135
                    for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
1136
                        unsigned prcx, prcy;
1137
                        int precno;
1138
                        int trx0, try0;
1139
                        uint8_t reducedresno = codsty->nreslevels - 1 -reslevelno; //  ==> N_L - r
1140
                        Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1141
1142
                        trx0 = ff_jpeg2000_ceildivpow2(tile_coord[0][0], log_subsampling[0] + reducedresno);
1143
                        try0 = ff_jpeg2000_ceildivpow2(tile_coord[1][0], log_subsampling[1] + reducedresno);
1144
1145
                        if (!(y % ((uint64_t)1 << (reslevel->log2_prec_height + reducedresno + log_subsampling[1])) == 0 ||
1146
                            (y == tile_coord[1][0] && (try0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_height)))))
1147
                            continue;
1148
1149
                        if (!(x % ((uint64_t)1 << (reslevel->log2_prec_width + reducedresno + log_subsampling[0])) == 0 ||
1150
                            (x == tile_coord[0][0] && (trx0 << reducedresno) % (1U << (reducedresno + reslevel->log2_prec_width)))))
1151
                            continue;
1152
1153
                        // check if a precinct exists
1154
                        prcx   = ff_jpeg2000_ceildivpow2(x, log_subsampling[0] + reducedresno) >> reslevel->log2_prec_width;
1155
                        prcy   = ff_jpeg2000_ceildivpow2(y, log_subsampling[1] + reducedresno) >> reslevel->log2_prec_height;
1156
                        prcx  -= ff_jpeg2000_ceildivpow2(comp->coord_o[0][0], reducedresno) >> reslevel->log2_prec_width;
1157
                        prcy  -= ff_jpeg2000_ceildivpow2(comp->coord_o[1][0], reducedresno) >> reslevel->log2_prec_height;
1158
1159
                        precno = prcx + reslevel->num_precincts_x * prcy;
1160
1161
                        if (prcx >= reslevel->num_precincts_x || prcy >= reslevel->num_precincts_y) {
1162
                            av_log(s->avctx, AV_LOG_WARNING, "prc %d %d outside limits %d %d\n",
1163
                                   prcx, prcy, reslevel->num_precincts_x, reslevel->num_precincts_y);
1164
                            continue;
1165
                        }
1166
                        for (layno = 0; layno < nlayers; layno++) {
1167
                            if ((ret = encode_packet(s, reslevel, layno, precno, qntsty->expn + (reslevelno ? 3*reslevelno-2 : 0),
1168
                                    qntsty->nguardbits, packetno++, nlayers)) < 0)
1169
                                return ret;
1170
                        }
1171
                    }
1172
                }
1173
            }
1174
        }
1175
1176
    }
1177
1178
1300
    av_log(s->avctx, AV_LOG_DEBUG, "after tier2\n");
1179
1300
    return 0;
1180
}
1181
1182
static void makelayer(Jpeg2000EncoderContext *s, int layno, double thresh, Jpeg2000Tile* tile, int final)
1183
{
1184
    int compno, resno, bandno, precno, cblkno;
1185
    int passno;
1186
1187
    for (compno = 0; compno < s->ncomponents; compno++) {
1188
        Jpeg2000Component *comp = &tile->comp[compno];
1189
1190
        for (resno = 0; resno < s->codsty.nreslevels; resno++) {
1191
            Jpeg2000ResLevel *reslevel = comp->reslevel + resno;
1192
1193
            for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1194
                for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1195
                    Jpeg2000Band *band = reslevel->band + bandno;
1196
                    Jpeg2000Prec *prec = band->prec + precno;
1197
1198
                    for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1199
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1200
                        Jpeg2000Layer *layer = &cblk->layers[layno];
1201
                        int n;
1202
1203
                        if (layno == 0) {
1204
                            cblk->ninclpasses = 0;
1205
                        }
1206
1207
                        n = cblk->ninclpasses;
1208
1209
                        if (thresh < 0) {
1210
                            n = cblk->npasses;
1211
                        } else {
1212
                            for (passno = cblk->ninclpasses; passno < cblk->npasses; passno++) {
1213
                                int32_t dr;
1214
                                double dd;
1215
                                Jpeg2000Pass *pass = &cblk->passes[passno];
1216
1217
                                if (n == 0) {
1218
                                    dr = pass->rate;
1219
                                    dd = pass->disto;
1220
                                } else {
1221
                                    dr = pass->rate - cblk->passes[n - 1].rate;
1222
                                    dd = pass->disto - cblk->passes[n-1].disto;
1223
                                }
1224
1225
                                if (!dr) {
1226
                                    if (dd != 0.0) {
1227
                                        n = passno + 1;
1228
                                    }
1229
                                    continue;
1230
                                }
1231
1232
                                if (thresh - (dd / dr) < DBL_EPSILON)
1233
                                    n = passno + 1;
1234
                            }
1235
                        }
1236
                        layer->npasses = n - cblk->ninclpasses;
1237
                        layer->cum_passes = n;
1238
1239
                        if (layer->npasses == 0) {
1240
                            layer->disto = 0;
1241
                            layer->data_len = 0;
1242
                            continue;
1243
                        }
1244
1245
                        if (cblk->ninclpasses == 0) {
1246
                            layer->data_len = cblk->passes[n - 1].rate;
1247
                            layer->data_start = cblk->data;
1248
                            layer->disto = cblk->passes[n - 1].disto;
1249
                        } else {
1250
                            layer->data_len = cblk->passes[n - 1].rate - cblk->passes[cblk->ninclpasses - 1].rate;
1251
                            layer->data_start = cblk->data + cblk->passes[cblk->ninclpasses - 1].rate;
1252
                            layer->disto = cblk->passes[n - 1].disto -
1253
                                           cblk->passes[cblk->ninclpasses - 1].disto;
1254
                        }
1255
                        if (final) {
1256
                            cblk->ninclpasses = n;
1257
                        }
1258
                    }
1259
                }
1260
            }
1261
        }
1262
    }
1263
}
1264
1265
static void makelayers(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
1266
{
1267
    int precno, compno, reslevelno, bandno, cblkno, lev, passno, layno;
1268
    int i;
1269
    double min = DBL_MAX;
1270
    double max = 0;
1271
    double thresh;
1272
    int tile_disto = 0;
1273
1274
    Jpeg2000CodingStyle *codsty = &s->codsty;
1275
1276
    for (compno = 0; compno < s->ncomponents; compno++){
1277
        Jpeg2000Component *comp = tile->comp + compno;
1278
1279
        for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1280
            Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1281
1282
            for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1283
                for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1284
                    Jpeg2000Band *band = reslevel->band + bandno;
1285
                    Jpeg2000Prec *prec = band->prec + precno;
1286
1287
                    for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1288
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1289
                        for (passno = 0; passno < cblk->npasses; passno++) {
1290
                            Jpeg2000Pass *pass = &cblk->passes[passno];
1291
                            int dr;
1292
                            double dd, drslope;
1293
1294
                            tile_disto += pass->disto;
1295
                            if (passno == 0) {
1296
                                dr = (int32_t)pass->rate;
1297
                                dd = pass->disto;
1298
                            } else {
1299
                                dr = (int32_t)(pass->rate - cblk->passes[passno - 1].rate);
1300
                                dd = pass->disto - cblk->passes[passno - 1].disto;
1301
                            }
1302
1303
                            if (dr <= 0)
1304
                                continue;
1305
1306
                            drslope = dd / dr;
1307
                            if (drslope < min)
1308
                                min = drslope;
1309
1310
                            if (drslope > max)
1311
                                max = drslope;
1312
                        }
1313
                    }
1314
                }
1315
            }
1316
        }
1317
    }
1318
1319
    for (layno = 0; layno < s->nlayers; layno++) {
1320
        double lo = min;
1321
        double hi = max;
1322
        double stable_thresh = 0.0;
1323
        double good_thresh = 0.0;
1324
        if (!s->layer_rates[layno]) {
1325
            good_thresh = -1.0;
1326
        } else {
1327
            for (i = 0; i < 128; i++) {
1328
                uint8_t *stream_pos = s->buf;
1329
                int ret;
1330
                thresh = (lo + hi) / 2;
1331
                makelayer(s, layno, thresh, tile, 0);
1332
                ret = encode_packets(s, tile, (int)(tile - s->tile), layno + 1);
1333
                memset(stream_pos, 0, s->buf - stream_pos);
1334
                if ((s->buf - stream_pos > ceil(tile->layer_rates[layno])) || ret < 0) {
1335
                    lo = thresh;
1336
                    s->buf = stream_pos;
1337
                    continue;
1338
                }
1339
                hi = thresh;
1340
                stable_thresh = thresh;
1341
                s->buf = stream_pos;
1342
            }
1343
        }
1344
        if (good_thresh >= 0.0)
1345
            good_thresh = stable_thresh == 0.0 ? thresh : stable_thresh;
1346
        makelayer(s, layno, good_thresh, tile, 1);
1347
    }
1348
}
1349
1350
417000
static int getcut(Jpeg2000Cblk *cblk, int64_t lambda, int dwt_norm)
1351
{
1352
417000
    int passno, res = 0;
1353
7855376
    for (passno = 0; passno < cblk->npasses; passno++){
1354
        int dr;
1355
        int64_t dd;
1356
1357
14876752
        dr = cblk->passes[passno].rate
1358
7438376
           - (res ? cblk->passes[res-1].rate : 0);
1359
14876752
        dd = cblk->passes[passno].disto
1360
7438376
           - (res ? cblk->passes[res-1].disto : 0);
1361
1362
7438376
        if (((dd * dwt_norm) >> WMSEDEC_SHIFT) * dwt_norm >= dr * lambda)
1363
2587785
            res = passno+1;
1364
    }
1365
417000
    return res;
1366
}
1367
1368
1300
static void truncpasses(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile)
1369
{
1370
    int precno, compno, reslevelno, bandno, cblkno, lev;
1371
1300
    Jpeg2000CodingStyle *codsty = &s->codsty;
1372
1373
5200
    for (compno = 0; compno < s->ncomponents; compno++){
1374
3900
        Jpeg2000Component *comp = tile->comp + compno;
1375
1376
31200
        for (reslevelno = 0, lev = codsty->nreslevels-1; reslevelno < codsty->nreslevels; reslevelno++, lev--){
1377
27300
            Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1378
1379
54600
            for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
1380
101400
                for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1381
74100
                    int bandpos = bandno + (reslevelno > 0);
1382
74100
                    Jpeg2000Band *band = reslevel->band + bandno;
1383
74100
                    Jpeg2000Prec *prec = band->prec + precno;
1384
1385
491100
                    for (cblkno = 0; cblkno < prec->nb_codeblocks_height * prec->nb_codeblocks_width; cblkno++){
1386
417000
                        Jpeg2000Cblk *cblk = prec->cblk + cblkno;
1387
1388
834000
                        cblk->ninclpasses = getcut(cblk, s->lambda,
1389
417000
                                (int64_t)dwt_norms[codsty->transform == FF_DWT53][bandpos][lev] * (int64_t)band->i_stepsize >> 15);
1390
417000
                        cblk->layers[0].data_start = cblk->data;
1391
417000
                        cblk->layers[0].cum_passes = cblk->ninclpasses;
1392
417000
                        cblk->layers[0].npasses = cblk->ninclpasses;
1393
417000
                        if (cblk->ninclpasses)
1394
380616
                            cblk->layers[0].data_len = cblk->passes[cblk->ninclpasses - 1].rate;
1395
                    }
1396
                }
1397
            }
1398
        }
1399
    }
1400
1300
}
1401
1402
1300
static int encode_tile(Jpeg2000EncoderContext *s, Jpeg2000Tile *tile, int tileno)
1403
{
1404
    int compno, reslevelno, bandno, ret;
1405
    Jpeg2000T1Context t1;
1406
1300
    Jpeg2000CodingStyle *codsty = &s->codsty;
1407
5200
    for (compno = 0; compno < s->ncomponents; compno++){
1408
3900
        Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1409
1410
3900
        t1.stride = (1<<codsty->log2_cblk_width) + 2;
1411
1412
3900
        av_log(s->avctx, AV_LOG_DEBUG,"dwt\n");
1413
3900
        if ((ret = ff_dwt_encode(&comp->dwt, comp->i_data)) < 0)
1414
            return ret;
1415
3900
        av_log(s->avctx, AV_LOG_DEBUG,"after dwt -> tier1\n");
1416
1417
31200
        for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
1418
27300
            Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
1419
1420
101400
            for (bandno = 0; bandno < reslevel->nbands ; bandno++){
1421
74100
                Jpeg2000Band *band = reslevel->band + bandno;
1422
74100
                Jpeg2000Prec *prec = band->prec; // we support only 1 precinct per band ATM in the encoder
1423
74100
                int cblkx, cblky, cblkno=0, xx0, x0, xx1, y0, yy0, yy1, bandpos;
1424
74100
                yy0 = bandno == 0 ? 0 : comp->reslevel[reslevelno-1].coord[1][1] - comp->reslevel[reslevelno-1].coord[1][0];
1425
74100
                y0 = yy0;
1426
74100
                yy1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[1][0] + 1, band->log2_cblk_height) << band->log2_cblk_height,
1427
74100
                            band->coord[1][1]) - band->coord[1][0] + yy0;
1428
1429

74100
                if (band->coord[0][0] == band->coord[0][1] || band->coord[1][0] == band->coord[1][1])
1430
3600
                    continue;
1431
1432
70500
                bandpos = bandno + (reslevelno > 0);
1433
1434
201300
                for (cblky = 0; cblky < prec->nb_codeblocks_height; cblky++){
1435

130800
                    if (reslevelno == 0 || bandno == 1)
1436
45600
                        xx0 = 0;
1437
                    else
1438
85200
                        xx0 = comp->reslevel[reslevelno-1].coord[0][1] - comp->reslevel[reslevelno-1].coord[0][0];
1439
130800
                    x0 = xx0;
1440
130800
                    xx1 = FFMIN(ff_jpeg2000_ceildivpow2(band->coord[0][0] + 1, band->log2_cblk_width) << band->log2_cblk_width,
1441
130800
                                band->coord[0][1]) - band->coord[0][0] + xx0;
1442
1443
544200
                    for (cblkx = 0; cblkx < prec->nb_codeblocks_width; cblkx++, cblkno++){
1444
                        int y, x;
1445
413400
                        if (codsty->transform == FF_DWT53){
1446
3186450
                            for (y = yy0; y < yy1; y++){
1447
2979750
                                int *ptr = t1.data + (y-yy0)*t1.stride;
1448
48772350
                                for (x = xx0; x < xx1; x++){
1449
45792600
                                    *ptr++ = comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x] * (1 << NMSEDEC_FRACBITS);
1450
                                }
1451
                            }
1452
                        } else{
1453
3186450
                            for (y = yy0; y < yy1; y++){
1454
2979750
                                int *ptr = t1.data + (y-yy0)*t1.stride;
1455
48772350
                                for (x = xx0; x < xx1; x++){
1456
45792600
                                    *ptr = (comp->i_data[(comp->coord[0][1] - comp->coord[0][0]) * y + x]);
1457
45792600
                                    *ptr = (int64_t)*ptr * (int64_t)(16384 * 65536 / band->i_stepsize) >> 15 - NMSEDEC_FRACBITS;
1458
45792600
                                    ptr++;
1459
                                }
1460
                            }
1461
                        }
1462
413400
                        if (!prec->cblk[cblkno].data)
1463
8268
                            prec->cblk[cblkno].data = av_malloc(1 + 8192);
1464
413400
                        if (!prec->cblk[cblkno].passes)
1465
8268
                            prec->cblk[cblkno].passes = av_malloc_array(JPEG2000_MAX_PASSES, sizeof (*prec->cblk[cblkno].passes));
1466

413400
                        if (!prec->cblk[cblkno].data || !prec->cblk[cblkno].passes)
1467
                            return AVERROR(ENOMEM);
1468
413400
                        encode_cblk(s, &t1, prec->cblk + cblkno, tile, xx1 - xx0, yy1 - yy0,
1469
413400
                                    bandpos, codsty->nreslevels - reslevelno - 1);
1470
413400
                        xx0 = xx1;
1471
413400
                        xx1 = FFMIN(xx1 + (1 << band->log2_cblk_width), band->coord[0][1] - band->coord[0][0] + x0);
1472
                    }
1473
130800
                    yy0 = yy1;
1474
130800
                    yy1 = FFMIN(yy1 + (1 << band->log2_cblk_height), band->coord[1][1] - band->coord[1][0] + y0);
1475
                }
1476
            }
1477
        }
1478
3900
        av_log(s->avctx, AV_LOG_DEBUG, "after tier1\n");
1479
    }
1480
1481
1300
    av_log(s->avctx, AV_LOG_DEBUG, "rate control\n");
1482
1300
    if (s->compression_rate_enc)
1483
        makelayers(s, tile);
1484
    else
1485
1300
        truncpasses(s, tile);
1486
1487
1300
    if ((ret = encode_packets(s, tile, tileno, s->nlayers)) < 0)
1488
        return ret;
1489
1300
    av_log(s->avctx, AV_LOG_DEBUG, "after rate control\n");
1490
1300
    return 0;
1491
}
1492
1493
8
static void cleanup(Jpeg2000EncoderContext *s)
1494
{
1495
    int tileno, compno;
1496
8
    Jpeg2000CodingStyle *codsty = &s->codsty;
1497
1498
8
    if (!s->tile)
1499
        return;
1500
34
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1501
26
        if (s->tile[tileno].comp) {
1502
104
            for (compno = 0; compno < s->ncomponents; compno++){
1503
78
                Jpeg2000Component *comp = s->tile[tileno].comp + compno;
1504
78
                ff_jpeg2000_cleanup(comp, codsty);
1505
            }
1506
26
            av_freep(&s->tile[tileno].comp);
1507
        }
1508
26
        av_freep(&s->tile[tileno].layer_rates);
1509
    }
1510
8
    av_freep(&s->tile);
1511
}
1512
1513
400
static void reinit(Jpeg2000EncoderContext *s)
1514
{
1515
    int tileno, compno;
1516
1700
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1517
1300
        Jpeg2000Tile *tile = s->tile + tileno;
1518
5200
        for (compno = 0; compno < s->ncomponents; compno++)
1519
3900
            ff_jpeg2000_reinit(tile->comp + compno, &s->codsty);
1520
    }
1521
400
}
1522
1523
2000
static void update_size(uint8_t *size, const uint8_t *end)
1524
{
1525
2000
    AV_WB32(size, end-size);
1526
2000
}
1527
1528
400
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
1529
                        const AVFrame *pict, int *got_packet)
1530
{
1531
    int tileno, ret;
1532
400
    Jpeg2000EncoderContext *s = avctx->priv_data;
1533
    uint8_t *chunkstart, *jp2cstart, *jp2hstart;
1534
1535
400
    if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*9 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
1536
        return ret;
1537
1538
    // init:
1539
400
    s->buf = s->buf_start = pkt->data;
1540
400
    s->buf_end = pkt->data + pkt->size;
1541
1542
400
    s->picture = pict;
1543
1544
400
    s->lambda = s->picture->quality * LAMBDA_SCALE;
1545
1546

400
    if (avctx->pix_fmt == AV_PIX_FMT_BGR48 || avctx->pix_fmt == AV_PIX_FMT_GRAY16)
1547
        copy_frame_16(s);
1548
    else
1549
400
        copy_frame_8(s);
1550
1551
400
    reinit(s);
1552
1553
400
    if (s->format == CODEC_JP2) {
1554
400
        av_assert0(s->buf == pkt->data);
1555
1556
400
        bytestream_put_be32(&s->buf, 0x0000000C);
1557
400
        bytestream_put_be32(&s->buf, 0x6A502020);
1558
400
        bytestream_put_be32(&s->buf, 0x0D0A870A);
1559
1560
400
        chunkstart = s->buf;
1561
400
        bytestream_put_be32(&s->buf, 0);
1562
400
        bytestream_put_buffer(&s->buf, "ftyp", 4);
1563
400
        bytestream_put_buffer(&s->buf, "jp2\040\040", 4);
1564
400
        bytestream_put_be32(&s->buf, 0);
1565
400
        bytestream_put_buffer(&s->buf, "jp2\040", 4);
1566
400
        update_size(chunkstart, s->buf);
1567
1568
400
        jp2hstart = s->buf;
1569
400
        bytestream_put_be32(&s->buf, 0);
1570
400
        bytestream_put_buffer(&s->buf, "jp2h", 4);
1571
1572
400
        chunkstart = s->buf;
1573
400
        bytestream_put_be32(&s->buf, 0);
1574
400
        bytestream_put_buffer(&s->buf, "ihdr", 4);
1575
400
        bytestream_put_be32(&s->buf, avctx->height);
1576
400
        bytestream_put_be32(&s->buf, avctx->width);
1577
400
        bytestream_put_be16(&s->buf, s->ncomponents);
1578
400
        bytestream_put_byte(&s->buf, s->cbps[0]);
1579
400
        bytestream_put_byte(&s->buf, 7);
1580
400
        bytestream_put_byte(&s->buf, 0);
1581
400
        bytestream_put_byte(&s->buf, 0);
1582
400
        update_size(chunkstart, s->buf);
1583
1584
400
        chunkstart = s->buf;
1585
400
        bytestream_put_be32(&s->buf, 0);
1586
400
        bytestream_put_buffer(&s->buf, "colr", 4);
1587
400
        bytestream_put_byte(&s->buf, 1);
1588
400
        bytestream_put_byte(&s->buf, 0);
1589
400
        bytestream_put_byte(&s->buf, 0);
1590

400
        if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1591
400
            bytestream_put_be32(&s->buf, 16);
1592
        } else if (s->ncomponents == 1) {
1593
            bytestream_put_be32(&s->buf, 17);
1594
        } else {
1595
            bytestream_put_be32(&s->buf, 18);
1596
        }
1597
400
        update_size(chunkstart, s->buf);
1598
400
        if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
1599
            int i;
1600
            uint8_t *palette = pict->data[1];
1601
            chunkstart = s->buf;
1602
            bytestream_put_be32(&s->buf, 0);
1603
            bytestream_put_buffer(&s->buf, "pclr", 4);
1604
            bytestream_put_be16(&s->buf, AVPALETTE_COUNT);
1605
            bytestream_put_byte(&s->buf, 3); // colour channels
1606
            bytestream_put_be24(&s->buf, 0x070707); //colour depths
1607
            for (i = 0; i < AVPALETTE_COUNT; i++) {
1608
                bytestream_put_be24(&s->buf, HAVE_BIGENDIAN ? AV_RB24(palette + 1) : AV_RL24(palette));
1609
                palette += 4;
1610
            }
1611
            update_size(chunkstart, s->buf);
1612
            chunkstart = s->buf;
1613
            bytestream_put_be32(&s->buf, 0);
1614
            bytestream_put_buffer(&s->buf, "cmap", 4);
1615
            for (i = 0; i < 3; i++) {
1616
                bytestream_put_be16(&s->buf, 0); // component
1617
                bytestream_put_byte(&s->buf, 1); // palette mapping
1618
                bytestream_put_byte(&s->buf, i); // index
1619
            }
1620
            update_size(chunkstart, s->buf);
1621
        }
1622
400
        update_size(jp2hstart, s->buf);
1623
1624
400
        jp2cstart = s->buf;
1625
400
        bytestream_put_be32(&s->buf, 0);
1626
400
        bytestream_put_buffer(&s->buf, "jp2c", 4);
1627
    }
1628
1629
400
    if (s->buf_end - s->buf < 2)
1630
        return -1;
1631
400
    bytestream_put_be16(&s->buf, JPEG2000_SOC);
1632
400
    if ((ret = put_siz(s)) < 0)
1633
        return ret;
1634
400
    if ((ret = put_cod(s)) < 0)
1635
        return ret;
1636
400
    if ((ret = put_qcd(s, 0)) < 0)
1637
        return ret;
1638
400
    if ((ret = put_com(s, 0)) < 0)
1639
        return ret;
1640
1641
1700
    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
1642
        uint8_t *psotptr;
1643
1300
        if (!(psotptr = put_sot(s, tileno)))
1644
            return -1;
1645
1300
        if (s->buf_end - s->buf < 2)
1646
            return -1;
1647
1300
        bytestream_put_be16(&s->buf, JPEG2000_SOD);
1648
1300
        if ((ret = encode_tile(s, s->tile + tileno, tileno)) < 0)
1649
            return ret;
1650
1300
        bytestream_put_be32(&psotptr, s->buf - psotptr + 6);
1651
    }
1652
400
    if (s->buf_end - s->buf < 2)
1653
        return -1;
1654
400
    bytestream_put_be16(&s->buf, JPEG2000_EOC);
1655
1656
400
    if (s->format == CODEC_JP2)
1657
400
        update_size(jp2cstart, s->buf);
1658
1659
400
    av_log(s->avctx, AV_LOG_DEBUG, "end\n");
1660
400
    pkt->size = s->buf - s->buf_start;
1661
400
    pkt->flags |= AV_PKT_FLAG_KEY;
1662
400
    *got_packet = 1;
1663
1664
400
    return 0;
1665
}
1666
1667
8
static int parse_layer_rates(Jpeg2000EncoderContext *s)
1668
{
1669
    int i;
1670
    char *token;
1671
8
    char *saveptr = NULL;
1672
    int rate;
1673
8
    int nlayers = 0;
1674
8
    if (!s->lr_str) {
1675
8
        s->nlayers = 1;
1676
8
        s->layer_rates[0] = 0;
1677
8
        s->compression_rate_enc = 0;
1678
8
        return 0;
1679
    }
1680
1681
    token = av_strtok(s->lr_str, ",", &saveptr);
1682
    if (rate = strtol(token, NULL, 10)) {
1683
            s->layer_rates[0] = rate <= 1 ? 0:rate;
1684
            nlayers++;
1685
    } else {
1686
            return AVERROR_INVALIDDATA;
1687
    }
1688
1689
    while (1) {
1690
        token = av_strtok(NULL, ",", &saveptr);
1691
        if (!token)
1692
            break;
1693
        if (rate = strtol(token, NULL, 10)) {
1694
            if (nlayers >= 100) {
1695
                return AVERROR_INVALIDDATA;
1696
            }
1697
            s->layer_rates[nlayers] = rate <= 1 ? 0:rate;
1698
            nlayers++;
1699
        } else {
1700
            return AVERROR_INVALIDDATA;
1701
        }
1702
    }
1703
1704
    for (i = 1; i < nlayers; i++) {
1705
        if (s->layer_rates[i] >= s->layer_rates[i-1]) {
1706
            return AVERROR_INVALIDDATA;
1707
        }
1708
    }
1709
    s->nlayers = nlayers;
1710
    s->compression_rate_enc = 1;
1711
    return 0;
1712
}
1713
1714
8
static av_cold int j2kenc_init(AVCodecContext *avctx)
1715
{
1716
    int i, ret;
1717
8
    Jpeg2000EncoderContext *s = avctx->priv_data;
1718
8
    Jpeg2000CodingStyle *codsty = &s->codsty;
1719
8
    Jpeg2000QuantStyle  *qntsty = &s->qntsty;
1720
1721
8
    s->avctx = avctx;
1722
8
    av_log(s->avctx, AV_LOG_DEBUG, "init\n");
1723
8
    if (parse_layer_rates(s)) {
1724
        av_log(s, AV_LOG_WARNING, "Layer rates invalid. Encoding with 1 layer based on quality metric.\n");
1725
        s->nlayers = 1;
1726
        s->layer_rates[0] = 0;
1727
        s->compression_rate_enc = 0;
1728
    }
1729
1730
#if FF_API_PRIVATE_OPT
1731
FF_DISABLE_DEPRECATION_WARNINGS
1732
8
    if (avctx->prediction_method)
1733
        s->pred = avctx->prediction_method;
1734
FF_ENABLE_DEPRECATION_WARNINGS
1735
#endif
1736
1737

8
    if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && (s->pred != FF_DWT97_INT || s->format != CODEC_JP2)) {
1738
        av_log(s->avctx, AV_LOG_WARNING, "Forcing lossless jp2 for pal8\n");
1739
        s->pred = FF_DWT97_INT;
1740
        s->format = CODEC_JP2;
1741
    }
1742
1743
    // defaults:
1744
    // TODO: implement setting non-standard precinct size
1745
8
    memset(codsty->log2_prec_widths , 15, sizeof(codsty->log2_prec_widths ));
1746
8
    memset(codsty->log2_prec_heights, 15, sizeof(codsty->log2_prec_heights));
1747
8
    codsty->nreslevels2decode=
1748
8
    codsty->nreslevels       = 7;
1749
8
    codsty->nlayers          = s->nlayers;
1750
8
    codsty->log2_cblk_width  = 4;
1751
8
    codsty->log2_cblk_height = 4;
1752
8
    codsty->transform        = s->pred ? FF_DWT53 : FF_DWT97_INT;
1753
1754
8
    qntsty->nguardbits       = 1;
1755
1756
8
    if ((s->tile_width  & (s->tile_width -1)) ||
1757
8
        (s->tile_height & (s->tile_height-1))) {
1758
        av_log(avctx, AV_LOG_WARNING, "Tile dimension not a power of 2\n");
1759
    }
1760
1761
8
    if (codsty->transform == FF_DWT53)
1762
4
        qntsty->quantsty = JPEG2000_QSTY_NONE;
1763
    else
1764
4
        qntsty->quantsty = JPEG2000_QSTY_SE;
1765
1766
8
    s->width = avctx->width;
1767
8
    s->height = avctx->height;
1768
1769
32
    for (i = 0; i < 3; i++) {
1770

24
        if (avctx->pix_fmt == AV_PIX_FMT_GRAY16 || avctx->pix_fmt == AV_PIX_FMT_RGB48)
1771
            s->cbps[i] = 16;
1772
        else
1773
24
            s->cbps[i] = 8;
1774
    }
1775
1776

8
    if (avctx->pix_fmt == AV_PIX_FMT_RGB24 || avctx->pix_fmt == AV_PIX_FMT_RGB48){
1777
8
        s->ncomponents = 3;
1778
    } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 || avctx->pix_fmt == AV_PIX_FMT_PAL8 || avctx->pix_fmt == AV_PIX_FMT_GRAY16){
1779
        s->ncomponents = 1;
1780
    } else{ // planar YUV
1781
        s->planar = 1;
1782
        s->ncomponents = 3;
1783
        ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
1784
                                               s->chroma_shift, s->chroma_shift + 1);
1785
        if (ret)
1786
            return ret;
1787
    }
1788
1789
8
    ff_jpeg2000_init_tier1_luts();
1790
8
    ff_mqc_init_context_tables();
1791
8
    init_luts();
1792
1793
8
    init_quantization(s);
1794
8
    if ((ret=init_tiles(s)) < 0)
1795
        return ret;
1796
1797
8
    av_log(s->avctx, AV_LOG_DEBUG, "after init\n");
1798
1799
8
    return 0;
1800
}
1801
1802
8
static int j2kenc_destroy(AVCodecContext *avctx)
1803
{
1804
8
    Jpeg2000EncoderContext *s = avctx->priv_data;
1805
1806
8
    cleanup(s);
1807
8
    return 0;
1808
}
1809
1810
// taken from the libopenjpeg wraper so it matches
1811
1812
#define OFFSET(x) offsetof(Jpeg2000EncoderContext, x)
1813
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1814
static const AVOption options[] = {
1815
    { "format",        "Codec Format",      OFFSET(format),        AV_OPT_TYPE_INT,   { .i64 = CODEC_JP2   }, CODEC_J2K, CODEC_JP2,   VE, "format"      },
1816
    { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K   }, 0,         0,           VE, "format"      },
1817
    { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2   }, 0,         0,           VE, "format"      },
1818
    { "tile_width",    "Tile Width",        OFFSET(tile_width),    AV_OPT_TYPE_INT,   { .i64 = 256         }, 1,     1<<30,           VE, },
1819
    { "tile_height",   "Tile Height",       OFFSET(tile_height),   AV_OPT_TYPE_INT,   { .i64 = 256         }, 1,     1<<30,           VE, },
1820
    { "pred",          "DWT Type",          OFFSET(pred),          AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE, "pred"        },
1821
    { "dwt97int",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = 0           }, INT_MIN, INT_MAX,       VE, "pred"        },
1822
    { "dwt53",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = 0           }, INT_MIN, INT_MAX,       VE, "pred"        },
1823
    { "sop",           "SOP marker",        OFFSET(sop),           AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE, },
1824
    { "eph",           "EPH marker",        OFFSET(eph),           AV_OPT_TYPE_INT,   { .i64 = 0           }, 0,         1,           VE, },
1825
    { "prog",          "Progression Order", OFFSET(prog),          AV_OPT_TYPE_INT,   { .i64 = 0           }, JPEG2000_PGOD_LRCP,         JPEG2000_PGOD_CPRL,           VE, "prog" },
1826
    { "lrcp",          NULL,                OFFSET(prog),          AV_OPT_TYPE_CONST,   { .i64 = JPEG2000_PGOD_LRCP           }, 0,         0,           VE, "prog" },
1827
    { "rlcp",          NULL,                OFFSET(prog),          AV_OPT_TYPE_CONST,   { .i64 = JPEG2000_PGOD_RLCP            }, 0,         0,           VE, "prog" },
1828
    { "rpcl",          NULL,                OFFSET(prog),          AV_OPT_TYPE_CONST,   { .i64 = JPEG2000_PGOD_RPCL            }, 0,         0,           VE, "prog" },
1829
    { "pcrl",          NULL,                OFFSET(prog),          AV_OPT_TYPE_CONST,   { .i64 = JPEG2000_PGOD_PCRL            }, 0,         0,           VE, "prog" },
1830
    { "cprl",          NULL,                OFFSET(prog),          AV_OPT_TYPE_CONST,   { .i64 = JPEG2000_PGOD_CPRL            }, 0,         0,           VE, "prog" },
1831
    { "layer_rates",   "Layer Rates",       OFFSET(lr_str),        AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VE },
1832
    { NULL }
1833
};
1834
1835
static const AVClass j2k_class = {
1836
    .class_name = "jpeg 2000 encoder",
1837
    .item_name  = av_default_item_name,
1838
    .option     = options,
1839
    .version    = LIBAVUTIL_VERSION_INT,
1840
};
1841
1842
AVCodec ff_jpeg2000_encoder = {
1843
    .name           = "jpeg2000",
1844
    .long_name      = NULL_IF_CONFIG_SMALL("JPEG 2000"),
1845
    .type           = AVMEDIA_TYPE_VIDEO,
1846
    .id             = AV_CODEC_ID_JPEG2000,
1847
    .priv_data_size = sizeof(Jpeg2000EncoderContext),
1848
    .init           = j2kenc_init,
1849
    .encode2        = encode_frame,
1850
    .close          = j2kenc_destroy,
1851
    .pix_fmts       = (const enum AVPixelFormat[]) {
1852
        AV_PIX_FMT_RGB24, AV_PIX_FMT_YUV444P, AV_PIX_FMT_GRAY8,
1853
        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P,
1854
        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
1855
        AV_PIX_FMT_PAL8,
1856
        AV_PIX_FMT_RGB48, AV_PIX_FMT_GRAY16,
1857
        AV_PIX_FMT_NONE
1858
    },
1859
    .priv_class     = &j2k_class,
1860
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
1861
};