GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/diracdec.c Lines: 904 1174 77.0 %
Date: 2021-04-20 15:25:36 Branches: 568 855 66.4 %

Line Branch Exec Source
1
/*
2
 * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
3
 * Copyright (C) 2009 David Conrad
4
 * Copyright (C) 2011 Jordi Ortiz
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
 * Dirac Decoder
26
 * @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
27
 */
28
29
#include "libavutil/mem_internal.h"
30
#include "libavutil/pixdesc.h"
31
#include "libavutil/thread.h"
32
#include "avcodec.h"
33
#include "get_bits.h"
34
#include "bytestream.h"
35
#include "internal.h"
36
#include "golomb.h"
37
#include "dirac_arith.h"
38
#include "dirac_vlc.h"
39
#include "mpeg12data.h"
40
#include "libavcodec/mpegvideo.h"
41
#include "mpegvideoencdsp.h"
42
#include "dirac_dwt.h"
43
#include "dirac.h"
44
#include "diractab.h"
45
#include "diracdsp.h"
46
#include "videodsp.h"
47
48
/**
49
 * The spec limits this to 3 for frame coding, but in practice can be as high as 6
50
 */
51
#define MAX_REFERENCE_FRAMES 8
52
#define MAX_DELAY 5         /* limit for main profile for frame coding (TODO: field coding) */
53
#define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
54
#define MAX_QUANT 255        /* max quant for VC-2 */
55
#define MAX_BLOCKSIZE 32    /* maximum xblen/yblen we support */
56
57
/**
58
 * DiracBlock->ref flags, if set then the block does MC from the given ref
59
 */
60
#define DIRAC_REF_MASK_REF1   1
61
#define DIRAC_REF_MASK_REF2   2
62
#define DIRAC_REF_MASK_GLOBAL 4
63
64
/**
65
 * Value of Picture.reference when Picture is not a reference picture, but
66
 * is held for delayed output.
67
 */
68
#define DELAYED_PIC_REF 4
69
70
#define CALC_PADDING(size, depth)                       \
71
    (((size + (1 << depth) - 1) >> depth) << depth)
72
73
#define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
74
75
typedef struct {
76
    AVFrame *avframe;
77
    int interpolated[3];    /* 1 if hpel[] is valid */
78
    uint8_t *hpel[3][4];
79
    uint8_t *hpel_base[3][4];
80
    int reference;
81
} DiracFrame;
82
83
typedef struct {
84
    union {
85
        int16_t mv[2][2];
86
        int16_t dc[3];
87
    } u; /* anonymous unions aren't in C99 :( */
88
    uint8_t ref;
89
} DiracBlock;
90
91
typedef struct SubBand {
92
    int level;
93
    int orientation;
94
    int stride; /* in bytes */
95
    int width;
96
    int height;
97
    int pshift;
98
    int quant;
99
    uint8_t *ibuf;
100
    struct SubBand *parent;
101
102
    /* for low delay */
103
    unsigned length;
104
    const uint8_t *coeff_data;
105
} SubBand;
106
107
typedef struct Plane {
108
    DWTPlane idwt;
109
110
    int width;
111
    int height;
112
    ptrdiff_t stride;
113
114
    /* block length */
115
    uint8_t xblen;
116
    uint8_t yblen;
117
    /* block separation (block n+1 starts after this many pixels in block n) */
118
    uint8_t xbsep;
119
    uint8_t ybsep;
120
    /* amount of overspill on each edge (half of the overlap between blocks) */
121
    uint8_t xoffset;
122
    uint8_t yoffset;
123
124
    SubBand band[MAX_DWT_LEVELS][4];
125
} Plane;
126
127
/* Used by Low Delay and High Quality profiles */
128
typedef struct DiracSlice {
129
    GetBitContext gb;
130
    int slice_x;
131
    int slice_y;
132
    int bytes;
133
} DiracSlice;
134
135
typedef struct DiracContext {
136
    AVCodecContext *avctx;
137
    MpegvideoEncDSPContext mpvencdsp;
138
    VideoDSPContext vdsp;
139
    DiracDSPContext diracdsp;
140
    DiracVersionInfo version;
141
    GetBitContext gb;
142
    AVDiracSeqHeader seq;
143
    int seen_sequence_header;
144
    int64_t frame_number;       /* number of the next frame to display       */
145
    Plane plane[3];
146
    int chroma_x_shift;
147
    int chroma_y_shift;
148
149
    int bit_depth;              /* bit depth                                 */
150
    int pshift;                 /* pixel shift = bit_depth > 8               */
151
152
    int zero_res;               /* zero residue flag                         */
153
    int is_arith;               /* whether coeffs use arith or golomb coding */
154
    int core_syntax;            /* use core syntax only                      */
155
    int low_delay;              /* use the low delay syntax                  */
156
    int hq_picture;             /* high quality picture, enables low_delay   */
157
    int ld_picture;             /* use low delay picture, turns on low_delay */
158
    int dc_prediction;          /* has dc prediction                         */
159
    int globalmc_flag;          /* use global motion compensation            */
160
    int num_refs;               /* number of reference pictures              */
161
162
    /* wavelet decoding */
163
    unsigned wavelet_depth;     /* depth of the IDWT                         */
164
    unsigned wavelet_idx;
165
166
    /**
167
     * schroedinger older than 1.0.8 doesn't store
168
     * quant delta if only one codebook exists in a band
169
     */
170
    unsigned old_delta_quant;
171
    unsigned codeblock_mode;
172
173
    unsigned num_x;              /* number of horizontal slices               */
174
    unsigned num_y;              /* number of vertical slices                 */
175
176
    uint8_t *thread_buf;         /* Per-thread buffer for coefficient storage */
177
    int threads_num_buf;         /* Current # of buffers allocated            */
178
    int thread_buf_size;         /* Each thread has a buffer this size        */
179
180
    DiracSlice *slice_params_buf;
181
    int slice_params_num_buf;
182
183
    struct {
184
        unsigned width;
185
        unsigned height;
186
    } codeblock[MAX_DWT_LEVELS+1];
187
188
    struct {
189
        AVRational bytes;       /* average bytes per slice                   */
190
        uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
191
    } lowdelay;
192
193
    struct {
194
        unsigned prefix_bytes;
195
        uint64_t size_scaler;
196
    } highquality;
197
198
    struct {
199
        int pan_tilt[2];        /* pan/tilt vector                           */
200
        int zrs[2][2];          /* zoom/rotate/shear matrix                  */
201
        int perspective[2];     /* perspective vector                        */
202
        unsigned zrs_exp;
203
        unsigned perspective_exp;
204
    } globalmc[2];
205
206
    /* motion compensation */
207
    uint8_t mv_precision;       /* [DIRAC_STD] REFS_WT_PRECISION             */
208
    int16_t weight[2];          /* [DIRAC_STD] REF1_WT and REF2_WT           */
209
    unsigned weight_log2denom;  /* [DIRAC_STD] REFS_WT_PRECISION             */
210
211
    int blwidth;                /* number of blocks (horizontally)           */
212
    int blheight;               /* number of blocks (vertically)             */
213
    int sbwidth;                /* number of superblocks (horizontally)      */
214
    int sbheight;               /* number of superblocks (vertically)        */
215
216
    uint8_t *sbsplit;
217
    DiracBlock *blmotion;
218
219
    uint8_t *edge_emu_buffer[4];
220
    uint8_t *edge_emu_buffer_base;
221
222
    uint16_t *mctmp;            /* buffer holding the MC data multiplied by OBMC weights */
223
    uint8_t *mcscratch;
224
    int buffer_stride;
225
226
    DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
227
228
    void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
229
    void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
230
    void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
231
    dirac_weight_func weight_func;
232
    dirac_biweight_func biweight_func;
233
234
    DiracFrame *current_picture;
235
    DiracFrame *ref_pics[2];
236
237
    DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
238
    DiracFrame *delay_frames[MAX_DELAY+1];
239
    DiracFrame all_frames[MAX_FRAMES];
240
} DiracContext;
241
242
enum dirac_subband {
243
    subband_ll = 0,
244
    subband_hl = 1,
245
    subband_lh = 2,
246
    subband_hh = 3,
247
    subband_nb,
248
};
249
250
/* magic number division by 3 from schroedinger */
251
55371
static inline int divide3(int x)
252
{
253
55371
    return (int)((x+1U)*21845 + 10922) >> 16;
254
}
255
256
14
static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
257
{
258
14
    DiracFrame *remove_pic = NULL;
259
14
    int i, remove_idx = -1;
260
261
39
    for (i = 0; framelist[i]; i++)
262
25
        if (framelist[i]->avframe->display_picture_number == picnum) {
263
13
            remove_pic = framelist[i];
264
13
            remove_idx = i;
265
        }
266
267
14
    if (remove_pic)
268
32
        for (i = remove_idx; framelist[i]; i++)
269
19
            framelist[i] = framelist[i+1];
270
271
14
    return remove_pic;
272
}
273
274
18
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
275
{
276
    int i;
277
33
    for (i = 0; i < maxframes; i++)
278
33
        if (!framelist[i]) {
279
18
            framelist[i] = frame;
280
18
            return 0;
281
        }
282
    return -1;
283
}
284
285
70
static int alloc_sequence_buffers(DiracContext *s)
286
{
287
70
    int sbwidth  = DIVRNDUP(s->seq.width,  4);
288
70
    int sbheight = DIVRNDUP(s->seq.height, 4);
289
    int i, w, h, top_padding;
290
291
    /* todo: think more about this / use or set Plane here */
292
280
    for (i = 0; i < 3; i++) {
293
210
        int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
294
210
        int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
295
210
        w = s->seq.width  >> (i ? s->chroma_x_shift : 0);
296
210
        h = s->seq.height >> (i ? s->chroma_y_shift : 0);
297
298
        /* we allocate the max we support here since num decompositions can
299
         * change from frame to frame. Stride is aligned to 16 for SIMD, and
300
         * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
301
         * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
302
         * on each side */
303
210
        top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
304
210
        w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
305
210
        h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
306
307
210
        s->plane[i].idwt.buf_base = av_mallocz_array((w+max_xblen), h * (2 << s->pshift));
308
210
        s->plane[i].idwt.tmp      = av_malloc_array((w+16), 2 << s->pshift);
309
210
        s->plane[i].idwt.buf      = s->plane[i].idwt.buf_base + (top_padding*w)*(2 << s->pshift);
310

210
        if (!s->plane[i].idwt.buf_base || !s->plane[i].idwt.tmp)
311
            return AVERROR(ENOMEM);
312
    }
313
314
    /* fixme: allocate using real stride here */
315
70
    s->sbsplit  = av_malloc_array(sbwidth, sbheight);
316
70
    s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));
317
318

70
    if (!s->sbsplit || !s->blmotion)
319
        return AVERROR(ENOMEM);
320
70
    return 0;
321
}
322
323
260
static int alloc_buffers(DiracContext *s, int stride)
324
{
325
260
    int w = s->seq.width;
326
260
    int h = s->seq.height;
327
328
260
    av_assert0(stride >= w);
329
260
    stride += 64;
330
331
260
    if (s->buffer_stride >= stride)
332
190
        return 0;
333
70
    s->buffer_stride = 0;
334
335
70
    av_freep(&s->edge_emu_buffer_base);
336
70
    memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));
337
70
    av_freep(&s->mctmp);
338
70
    av_freep(&s->mcscratch);
339
340
70
    s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE);
341
342
70
    s->mctmp     = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
343
70
    s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE);
344
345

70
    if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)
346
        return AVERROR(ENOMEM);
347
348
70
    s->buffer_stride = stride;
349
70
    return 0;
350
}
351
352
70
static void free_sequence_buffers(DiracContext *s)
353
{
354
    int i, j, k;
355
356
1050
    for (i = 0; i < MAX_FRAMES; i++) {
357
980
        if (s->all_frames[i].avframe->data[0]) {
358
38
            av_frame_unref(s->all_frames[i].avframe);
359
38
            memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
360
        }
361
362
3920
        for (j = 0; j < 3; j++)
363
11760
            for (k = 1; k < 4; k++)
364
8820
                av_freep(&s->all_frames[i].hpel_base[j][k]);
365
    }
366
367
70
    memset(s->ref_frames, 0, sizeof(s->ref_frames));
368
70
    memset(s->delay_frames, 0, sizeof(s->delay_frames));
369
370
280
    for (i = 0; i < 3; i++) {
371
210
        av_freep(&s->plane[i].idwt.buf_base);
372
210
        av_freep(&s->plane[i].idwt.tmp);
373
    }
374
375
70
    s->buffer_stride = 0;
376
70
    av_freep(&s->sbsplit);
377
70
    av_freep(&s->blmotion);
378
70
    av_freep(&s->edge_emu_buffer_base);
379
380
70
    av_freep(&s->mctmp);
381
70
    av_freep(&s->mcscratch);
382
70
}
383
384
static AVOnce dirac_arith_init = AV_ONCE_INIT;
385
386
70
static av_cold int dirac_decode_init(AVCodecContext *avctx)
387
{
388
70
    DiracContext *s = avctx->priv_data;
389
    int i, ret;
390
391
70
    s->avctx = avctx;
392
70
    s->frame_number = -1;
393
394
70
    s->thread_buf = NULL;
395
70
    s->threads_num_buf = -1;
396
70
    s->thread_buf_size = -1;
397
398
70
    ff_diracdsp_init(&s->diracdsp);
399
70
    ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
400
70
    ff_videodsp_init(&s->vdsp, 8);
401
402
1050
    for (i = 0; i < MAX_FRAMES; i++) {
403
980
        s->all_frames[i].avframe = av_frame_alloc();
404
980
        if (!s->all_frames[i].avframe) {
405
            while (i > 0)
406
                av_frame_free(&s->all_frames[--i].avframe);
407
            return AVERROR(ENOMEM);
408
        }
409
    }
410
70
    ret = ff_thread_once(&dirac_arith_init, ff_dirac_init_arith_tables);
411
70
    if (ret != 0)
412
        return AVERROR_UNKNOWN;
413
414
70
    return 0;
415
}
416
417
70
static void dirac_decode_flush(AVCodecContext *avctx)
418
{
419
70
    DiracContext *s = avctx->priv_data;
420
70
    free_sequence_buffers(s);
421
70
    s->seen_sequence_header = 0;
422
70
    s->frame_number = -1;
423
70
}
424
425
70
static av_cold int dirac_decode_end(AVCodecContext *avctx)
426
{
427
70
    DiracContext *s = avctx->priv_data;
428
    int i;
429
430
70
    dirac_decode_flush(avctx);
431
1050
    for (i = 0; i < MAX_FRAMES; i++)
432
980
        av_frame_free(&s->all_frames[i].avframe);
433
434
70
    av_freep(&s->thread_buf);
435
70
    av_freep(&s->slice_params_buf);
436
437
70
    return 0;
438
}
439
440
1949239
static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
441
{
442
1949239
    int coeff = dirac_get_se_golomb(gb);
443
1949239
    const unsigned sign = FFSIGN(coeff);
444
1949239
    if (coeff)
445
336797
        coeff = sign*((sign * coeff * qfactor + qoffset) >> 2);
446
1949239
    return coeff;
447
}
448
449
#define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
450
451
#define UNPACK_ARITH(n, type) \
452
    static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
453
                                              SubBand *b, type *buf, int x, int y) \
454
    { \
455
        int sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
456
        unsigned coeff; \
457
        const int mstride = -(b->stride >> (1+b->pshift)); \
458
        if (b->parent) { \
459
            const type *pbuf = (type *)b->parent->ibuf; \
460
            const int stride = b->parent->stride >> (1+b->parent->pshift); \
461
            pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \
462
        } \
463
        if (b->orientation == subband_hl) \
464
            sign_pred = buf[mstride]; \
465
        if (x) { \
466
            pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \
467
            if (b->orientation == subband_lh) \
468
                sign_pred = buf[-1]; \
469
        } else { \
470
            pred_ctx += !buf[mstride]; \
471
        } \
472
        coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \
473
        if (coeff) { \
474
            coeff = (coeff * qfactor + qoffset) >> 2; \
475
            sign  = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \
476
            coeff = (coeff ^ -sign) + sign; \
477
        } \
478
        *buf = coeff; \
479
    } \
480
481



337100
UNPACK_ARITH(8, int16_t)
482
UNPACK_ARITH(10, int32_t)
483
484
/**
485
 * Decode the coeffs in the rectangle defined by left, right, top, bottom
486
 * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
487
 */
488
82699
static inline int codeblock(DiracContext *s, SubBand *b,
489
                             GetBitContext *gb, DiracArith *c,
490
                             int left, int right, int top, int bottom,
491
                             int blockcnt_one, int is_arith)
492
{
493
    int x, y, zero_block;
494
    int qoffset, qfactor;
495
    uint8_t *buf;
496
497
    /* check for any coded coefficients in this codeblock */
498
82699
    if (!blockcnt_one) {
499
82635
        if (is_arith)
500
82635
            zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
501
        else
502
            zero_block = get_bits1(gb);
503
504
82635
        if (zero_block)
505
77258
            return 0;
506
    }
507
508

5441
    if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
509
        int quant;
510
        if (is_arith)
511
            quant = dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
512
        else
513
            quant = dirac_get_se_golomb(gb);
514
        if (quant > INT_MAX - b->quant || b->quant + quant < 0) {
515
            av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
516
            return AVERROR_INVALIDDATA;
517
        }
518
        b->quant += quant;
519
    }
520
521
5441
    if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
522
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
523
        b->quant = 0;
524
        return AVERROR_INVALIDDATA;
525
    }
526
527
5441
    qfactor = ff_dirac_qscale_tab[b->quant];
528
    /* TODO: context pointer? */
529
5441
    if (!s->num_refs)
530
1700
        qoffset = ff_dirac_qoffset_intra_tab[b->quant] + 2;
531
    else
532
3741
        qoffset = ff_dirac_qoffset_inter_tab[b->quant] + 2;
533
534
5441
    buf = b->ibuf + top * b->stride;
535
5441
    if (is_arith) {
536
46055
        for (y = top; y < bottom; y++) {
537
40614
            if (c->error)
538
                return c->error;
539
377714
            for (x = left; x < right; x++) {
540
337100
                if (b->pshift) {
541
                    coeff_unpack_arith_10(c, qfactor, qoffset, b, (int32_t*)(buf)+x, x, y);
542
                } else {
543
337100
                    coeff_unpack_arith_8(c, qfactor, qoffset, b, (int16_t*)(buf)+x, x, y);
544
                }
545
            }
546
40614
            buf += b->stride;
547
        }
548
    } else {
549
        for (y = top; y < bottom; y++) {
550
            if (get_bits_left(gb) < 1)
551
                return AVERROR_INVALIDDATA;
552
            for (x = left; x < right; x++) {
553
                int val = coeff_unpack_golomb(gb, qfactor, qoffset);
554
                if (b->pshift) {
555
                    AV_WN32(&buf[4*x], val);
556
                } else {
557
                    AV_WN16(&buf[2*x], val);
558
                }
559
            }
560
            buf += b->stride;
561
         }
562
     }
563
5441
     return 0;
564
}
565
566
/**
567
 * Dirac Specification ->
568
 * 13.3 intra_dc_prediction(band)
569
 */
570
#define INTRA_DC_PRED(n, type) \
571
    static inline void intra_dc_prediction_##n(SubBand *b) \
572
    { \
573
        type *buf = (type*)b->ibuf; \
574
        int x, y; \
575
        \
576
        for (x = 1; x < b->width; x++) \
577
            buf[x] += buf[x-1]; \
578
        buf += (b->stride >> (1+b->pshift)); \
579
        \
580
        for (y = 1; y < b->height; y++) { \
581
            buf[0] += buf[-(b->stride >> (1+b->pshift))]; \
582
            \
583
            for (x = 1; x < b->width; x++) { \
584
                int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \
585
                buf[x]  += divide3(pred); \
586
            } \
587
            buf += (b->stride >> (1+b->pshift)); \
588
        } \
589
    } \
590
591

59400
INTRA_DC_PRED(8, int16_t)
592
INTRA_DC_PRED(10, uint32_t)
593
594
/**
595
 * Dirac Specification ->
596
 * 13.4.2 Non-skipped subbands.  subband_coeffs()
597
 */
598
930
static av_always_inline int decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
599
{
600
    int cb_x, cb_y, left, right, top, bottom;
601
    DiracArith c;
602
    GetBitContext gb;
603
930
    int cb_width  = s->codeblock[b->level + (b->orientation != subband_ll)].width;
604
930
    int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
605
930
    int blockcnt_one = (cb_width + cb_height) == 2;
606
    int ret;
607
608
930
    if (!b->length)
609
263
        return 0;
610
611
667
    init_get_bits8(&gb, b->coeff_data, b->length);
612
613
667
    if (is_arith)
614
667
        ff_dirac_init_arith_decoder(&c, &gb, b->length);
615
616
667
    top = 0;
617
5972
    for (cb_y = 0; cb_y < cb_height; cb_y++) {
618
5305
        bottom = (b->height * (cb_y+1LL)) / cb_height;
619
5305
        left = 0;
620
88004
        for (cb_x = 0; cb_x < cb_width; cb_x++) {
621
82699
            right = (b->width * (cb_x+1LL)) / cb_width;
622
82699
            ret = codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
623
82699
            if (ret < 0)
624
                return ret;
625
82699
            left = right;
626
        }
627
5305
        top = bottom;
628
    }
629
630

667
    if (b->orientation == subband_ll && s->num_refs == 0) {
631
6
        if (s->pshift) {
632
            intra_dc_prediction_10(b);
633
        } else {
634
6
            intra_dc_prediction_8(b);
635
        }
636
    }
637
667
    return 0;
638
}
639
640
930
static int decode_subband_arith(AVCodecContext *avctx, void *b)
641
{
642
930
    DiracContext *s = avctx->priv_data;
643
930
    return decode_subband_internal(s, b, 1);
644
}
645
646
static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
647
{
648
    DiracContext *s = avctx->priv_data;
649
    SubBand **b     = arg;
650
    return decode_subband_internal(s, *b, 0);
651
}
652
653
/**
654
 * Dirac Specification ->
655
 * [DIRAC_STD] 13.4.1 core_transform_data()
656
 */
657
93
static int decode_component(DiracContext *s, int comp)
658
{
659
93
    AVCodecContext *avctx = s->avctx;
660
    SubBand *bands[3*MAX_DWT_LEVELS+1];
661
    enum dirac_subband orientation;
662
93
    int level, num_bands = 0;
663
    int ret[3*MAX_DWT_LEVELS+1];
664
    int i;
665
93
    int damaged_count = 0;
666
667
    /* Unpack all subbands at all levels. */
668
372
    for (level = 0; level < s->wavelet_depth; level++) {
669
1209
        for (orientation = !!level; orientation < 4; orientation++) {
670
930
            SubBand *b = &s->plane[comp].band[level][orientation];
671
930
            bands[num_bands++] = b;
672
673
930
            align_get_bits(&s->gb);
674
            /* [DIRAC_STD] 13.4.2 subband() */
675
930
            b->length = get_interleaved_ue_golomb(&s->gb);
676
930
            if (b->length) {
677
667
                b->quant = get_interleaved_ue_golomb(&s->gb);
678
667
                if (b->quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
679
                    av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
680
                    b->quant = 0;
681
                    return AVERROR_INVALIDDATA;
682
                }
683
667
                align_get_bits(&s->gb);
684
667
                b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
685

667
                if (b->length > FFMAX(get_bits_left(&s->gb)/8, 0)) {
686
                    b->length = FFMAX(get_bits_left(&s->gb)/8, 0);
687
                    damaged_count ++;
688
                }
689
667
                skip_bits_long(&s->gb, b->length*8);
690
            }
691
        }
692
        /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
693
279
        if (s->is_arith)
694
279
            avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
695
279
                           ret + 3*level + !!level, 4-!!level, sizeof(SubBand));
696
    }
697
    /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
698
93
    if (!s->is_arith)
699
        avctx->execute(avctx, decode_subband_golomb, bands, ret, num_bands, sizeof(SubBand*));
700
701
1023
    for (i = 0; i < s->wavelet_depth * 3 + 1; i++) {
702
930
        if (ret[i] < 0)
703
            damaged_count++;
704
    }
705
93
    if (damaged_count > (s->wavelet_depth * 3 + 1) /2)
706
        return AVERROR_INVALIDDATA;
707
708
93
    return 0;
709
}
710
711
#define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \
712
    type *buf = (type *)buf1; \
713
    buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
714
    if (get_bits_count(gb) >= ebits) \
715
        return; \
716
    if (buf2) { \
717
        buf = (type *)buf2; \
718
        buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
719
        if (get_bits_count(gb) >= ebits) \
720
            return; \
721
    } \
722
723
186000
static void decode_subband(DiracContext *s, GetBitContext *gb, int quant,
724
                           int slice_x, int slice_y, int bits_end,
725
                           SubBand *b1, SubBand *b2)
726
{
727
186000
    int left   = b1->width  * slice_x    / s->num_x;
728
186000
    int right  = b1->width  *(slice_x+1) / s->num_x;
729
186000
    int top    = b1->height * slice_y    / s->num_y;
730
186000
    int bottom = b1->height *(slice_y+1) / s->num_y;
731
732
    int qfactor, qoffset;
733
734
186000
    uint8_t *buf1 =      b1->ibuf + top * b1->stride;
735
186000
    uint8_t *buf2 = b2 ? b2->ibuf + top * b2->stride: NULL;
736
    int x, y;
737
738
186000
    if (quant > (DIRAC_MAX_QUANT_INDEX - 1)) {
739
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", quant);
740
        return;
741
    }
742
186000
    qfactor = ff_dirac_qscale_tab[quant];
743
186000
    qoffset = ff_dirac_qoffset_intra_tab[quant] + 2;
744
    /* we have to constantly check for overread since the spec explicitly
745
       requires this, with the meaning that all remaining coeffs are set to 0 */
746
186000
    if (get_bits_count(gb) >= bits_end)
747
38746
        return;
748
749
147254
    if (s->pshift) {
750
        for (y = top; y < bottom; y++) {
751
            for (x = left; x < right; x++) {
752
                PARSE_VALUES(int32_t, x, gb, bits_end, buf1, buf2);
753
            }
754
            buf1 += b1->stride;
755
            if (buf2)
756
                buf2 += b2->stride;
757
        }
758
    }
759
    else {
760
518899
        for (y = top; y < bottom; y++) {
761
1836007
            for (x = left; x < right; x++) {
762

1464362
                PARSE_VALUES(int16_t, x, gb, bits_end, buf1, buf2);
763
            }
764
371645
            buf1 += b1->stride;
765
371645
            if (buf2)
766
173605
                buf2 += b2->stride;
767
        }
768
    }
769
}
770
771
/**
772
 * Dirac Specification ->
773
 * 13.5.2 Slices. slice(sx,sy)
774
 */
775
9300
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
776
{
777
9300
    DiracContext *s = avctx->priv_data;
778
9300
    DiracSlice *slice = arg;
779
9300
    GetBitContext *gb = &slice->gb;
780
    enum dirac_subband orientation;
781
    int level, quant, chroma_bits, chroma_end;
782
783
9300
    int quant_base  = get_bits(gb, 7); /*[DIRAC_STD] qindex */
784
9300
    int length_bits = av_log2(8 * slice->bytes)+1;
785
9300
    int luma_bits   = get_bits_long(gb, length_bits);
786
9300
    int luma_end    = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
787
788
    /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
789
37200
    for (level = 0; level < s->wavelet_depth; level++)
790
120900
        for (orientation = !!level; orientation < 4; orientation++) {
791
93000
            quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
792
93000
            decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
793
                           &s->plane[0].band[level][orientation], NULL);
794
        }
795
796
    /* consume any unused bits from luma */
797
9300
    skip_bits_long(gb, get_bits_count(gb) - luma_end);
798
799
9300
    chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
800
9300
    chroma_end  = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
801
    /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
802
37200
    for (level = 0; level < s->wavelet_depth; level++)
803
120900
        for (orientation = !!level; orientation < 4; orientation++) {
804
93000
            quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
805
93000
            decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
806
                           &s->plane[1].band[level][orientation],
807
                           &s->plane[2].band[level][orientation]);
808
        }
809
810
9300
    return 0;
811
}
812
813
typedef struct SliceCoeffs {
814
    int left;
815
    int top;
816
    int tot_h;
817
    int tot_v;
818
    int tot;
819
} SliceCoeffs;
820
821
117841
static int subband_coeffs(DiracContext *s, int x, int y, int p,
822
                          SliceCoeffs c[MAX_DWT_LEVELS])
823
{
824
117841
    int level, coef = 0;
825
589174
    for (level = 0; level < s->wavelet_depth; level++) {
826
471333
        SliceCoeffs *o = &c[level];
827
471333
        SubBand *b = &s->plane[p].band[level][3]; /* orientation doens't matter */
828
471333
        o->top   = b->height * y / s->num_y;
829
471333
        o->left  = b->width  * x / s->num_x;
830
471333
        o->tot_h = ((b->width  * (x + 1)) / s->num_x) - o->left;
831
471333
        o->tot_v = ((b->height * (y + 1)) / s->num_y) - o->top;
832
471333
        o->tot   = o->tot_h*o->tot_v;
833
471333
        coef    += o->tot * (4 - !!level);
834
    }
835
117841
    return coef;
836
}
837
838
/**
839
 * VC-2 Specification ->
840
 * 13.5.3 hq_slice(sx,sy)
841
 */
842
39204
static int decode_hq_slice(DiracContext *s, DiracSlice *slice, uint8_t *tmp_buf)
843
{
844
    int i, level, orientation, quant_idx;
845
    int qfactor[MAX_DWT_LEVELS][4], qoffset[MAX_DWT_LEVELS][4];
846
39204
    GetBitContext *gb = &slice->gb;
847
    SliceCoeffs coeffs_num[MAX_DWT_LEVELS];
848
849
39204
    skip_bits_long(gb, 8*s->highquality.prefix_bytes);
850
39204
    quant_idx = get_bits(gb, 8);
851
852
39204
    if (quant_idx > DIRAC_MAX_QUANT_INDEX - 1) {
853
        av_log(s->avctx, AV_LOG_ERROR, "Invalid quantization index - %i\n", quant_idx);
854
        return AVERROR_INVALIDDATA;
855
    }
856
857
    /* Slice quantization (slice_quantizers() in the specs) */
858
196020
    for (level = 0; level < s->wavelet_depth; level++) {
859
666468
        for (orientation = !!level; orientation < 4; orientation++) {
860
509652
            const int quant = FFMAX(quant_idx - s->lowdelay.quant[level][orientation], 0);
861
509652
            qfactor[level][orientation] = ff_dirac_qscale_tab[quant];
862
509652
            qoffset[level][orientation] = ff_dirac_qoffset_intra_tab[quant] + 2;
863
        }
864
    }
865
866
    /* Luma + 2 Chroma planes */
867
156816
    for (i = 0; i < 3; i++) {
868
117612
        int coef_num, coef_par, off = 0;
869
117612
        int64_t length = s->highquality.size_scaler*get_bits(gb, 8);
870
117612
        int64_t bits_end = get_bits_count(gb) + 8*length;
871
117612
        const uint8_t *addr = align_get_bits(gb);
872
873
117612
        if (length*8 > get_bits_left(gb)) {
874
            av_log(s->avctx, AV_LOG_ERROR, "end too far away\n");
875
            return AVERROR_INVALIDDATA;
876
        }
877
878
117612
        coef_num = subband_coeffs(s, slice->slice_x, slice->slice_y, i, coeffs_num);
879
880
117612
        if (s->pshift)
881
85536
            coef_par = ff_dirac_golomb_read_32bit(addr, length,
882
                                                  tmp_buf, coef_num);
883
        else
884
32076
            coef_par = ff_dirac_golomb_read_16bit(addr, length,
885
                                                  tmp_buf, coef_num);
886
887
117612
        if (coef_num > coef_par) {
888
            const int start_b = coef_par * (1 << (s->pshift + 1));
889
            const int end_b   = coef_num * (1 << (s->pshift + 1));
890
            memset(&tmp_buf[start_b], 0, end_b - start_b);
891
        }
892
893
588060
        for (level = 0; level < s->wavelet_depth; level++) {
894
470448
            const SliceCoeffs *c = &coeffs_num[level];
895
1999404
            for (orientation = !!level; orientation < 4; orientation++) {
896
1528956
                const SubBand *b1 = &s->plane[i].band[level][orientation];
897
1528956
                uint8_t *buf = b1->ibuf + c->top * b1->stride + (c->left << (s->pshift + 1));
898
899
                /* Change to c->tot_h <= 4 for AVX2 dequantization */
900
1528956
                const int qfunc = s->pshift + 2*(c->tot_h <= 2);
901
1528956
                s->diracdsp.dequant_subband[qfunc](&tmp_buf[off], buf, b1->stride,
902
                                                   qfactor[level][orientation],
903
                                                   qoffset[level][orientation],
904
                                                   c->tot_v, c->tot_h);
905
906
1528956
                off += c->tot << (s->pshift + 1);
907
            }
908
        }
909
910
117612
        skip_bits_long(gb, bits_end - get_bits_count(gb));
911
    }
912
913
39204
    return 0;
914
}
915
916
3564
static int decode_hq_slice_row(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
917
{
918
    int i;
919
3564
    DiracContext *s = avctx->priv_data;
920
3564
    DiracSlice *slices = ((DiracSlice *)arg) + s->num_x*jobnr;
921
3564
    uint8_t *thread_buf = &s->thread_buf[s->thread_buf_size*threadnr];
922
42768
    for (i = 0; i < s->num_x; i++)
923
39204
        decode_hq_slice(s, &slices[i], thread_buf);
924
3564
    return 0;
925
}
926
927
/**
928
 * Dirac Specification ->
929
 * 13.5.1 low_delay_transform_data()
930
 */
931
229
static int decode_lowdelay(DiracContext *s)
932
{
933
229
    AVCodecContext *avctx = s->avctx;
934
    int slice_x, slice_y, bufsize;
935
229
    int64_t coef_buf_size, bytes = 0;
936
    const uint8_t *buf;
937
    DiracSlice *slices;
938
    SliceCoeffs tmp[MAX_DWT_LEVELS];
939
229
    int slice_num = 0;
940
941
229
    if (s->slice_params_num_buf != (s->num_x * s->num_y)) {
942
68
        s->slice_params_buf = av_realloc_f(s->slice_params_buf, s->num_x * s->num_y, sizeof(DiracSlice));
943
68
        if (!s->slice_params_buf) {
944
            av_log(s->avctx, AV_LOG_ERROR, "slice params buffer allocation failure\n");
945
            s->slice_params_num_buf = 0;
946
            return AVERROR(ENOMEM);
947
        }
948
68
        s->slice_params_num_buf = s->num_x * s->num_y;
949
    }
950
229
    slices = s->slice_params_buf;
951
952
    /* 8 becacuse that's how much the golomb reader could overread junk data
953
     * from another plane/slice at most, and 512 because SIMD */
954
229
    coef_buf_size = subband_coeffs(s, s->num_x - 1, s->num_y - 1, 0, tmp) + 8;
955
229
    coef_buf_size = (coef_buf_size << (1 + s->pshift)) + 512;
956
957
229
    if (s->threads_num_buf != avctx->thread_count ||
958
161
        s->thread_buf_size != coef_buf_size) {
959
68
        s->threads_num_buf  = avctx->thread_count;
960
68
        s->thread_buf_size  = coef_buf_size;
961
68
        s->thread_buf       = av_realloc_f(s->thread_buf, avctx->thread_count, s->thread_buf_size);
962
68
        if (!s->thread_buf) {
963
            av_log(s->avctx, AV_LOG_ERROR, "thread buffer allocation failure\n");
964
            return AVERROR(ENOMEM);
965
        }
966
    }
967
968
229
    align_get_bits(&s->gb);
969
    /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
970
229
    buf = s->gb.buffer + get_bits_count(&s->gb)/8;
971
229
    bufsize = get_bits_left(&s->gb);
972
973
229
    if (s->hq_picture) {
974
        int i;
975
976

3762
        for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
977

42768
            for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
978
39204
                bytes = s->highquality.prefix_bytes + 1;
979
156816
                for (i = 0; i < 3; i++) {
980
117612
                    if (bytes <= bufsize/8)
981
117612
                        bytes += buf[bytes] * s->highquality.size_scaler + 1;
982
                }
983

39204
                if (bytes >= INT_MAX || bytes*8 > bufsize) {
984
                    av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
985
                    return AVERROR_INVALIDDATA;
986
                }
987
988
39204
                slices[slice_num].bytes   = bytes;
989
39204
                slices[slice_num].slice_x = slice_x;
990
39204
                slices[slice_num].slice_y = slice_y;
991
39204
                init_get_bits(&slices[slice_num].gb, buf, bufsize);
992
39204
                slice_num++;
993
994
39204
                buf     += bytes;
995
39204
                if (bufsize/8 >= bytes)
996
39204
                    bufsize -= bytes*8;
997
                else
998
                    bufsize = 0;
999
            }
1000
        }
1001
1002
198
        if (s->num_x*s->num_y != slice_num) {
1003
            av_log(s->avctx, AV_LOG_ERROR, "too few slices\n");
1004
            return AVERROR_INVALIDDATA;
1005
        }
1006
1007
198
        avctx->execute2(avctx, decode_hq_slice_row, slices, NULL, s->num_y);
1008
    } else {
1009

496
        for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
1010

9765
            for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
1011
9300
                bytes = (slice_num+1) * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den
1012
9300
                       - slice_num    * (int64_t)s->lowdelay.bytes.num / s->lowdelay.bytes.den;
1013

9300
                if (bytes >= INT_MAX || bytes*8 > bufsize) {
1014
                    av_log(s->avctx, AV_LOG_ERROR, "too many bytes\n");
1015
                    return AVERROR_INVALIDDATA;
1016
                }
1017
9300
                slices[slice_num].bytes   = bytes;
1018
9300
                slices[slice_num].slice_x = slice_x;
1019
9300
                slices[slice_num].slice_y = slice_y;
1020
9300
                init_get_bits(&slices[slice_num].gb, buf, bufsize);
1021
9300
                slice_num++;
1022
1023
9300
                buf     += bytes;
1024
9300
                if (bufsize/8 >= bytes)
1025
9300
                    bufsize -= bytes*8;
1026
                else
1027
                    bufsize = 0;
1028
            }
1029
        }
1030
31
        avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
1031
                       sizeof(DiracSlice)); /* [DIRAC_STD] 13.5.2 Slices */
1032
    }
1033
1034
229
    if (s->dc_prediction) {
1035
31
        if (s->pshift) {
1036
            intra_dc_prediction_10(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1037
            intra_dc_prediction_10(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1038
            intra_dc_prediction_10(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1039
        } else {
1040
31
            intra_dc_prediction_8(&s->plane[0].band[0][0]);
1041
31
            intra_dc_prediction_8(&s->plane[1].band[0][0]);
1042
31
            intra_dc_prediction_8(&s->plane[2].band[0][0]);
1043
        }
1044
    }
1045
1046
229
    return 0;
1047
}
1048
1049
260
static void init_planes(DiracContext *s)
1050
{
1051
    int i, w, h, level, orientation;
1052
1053
1040
    for (i = 0; i < 3; i++) {
1054
780
        Plane *p = &s->plane[i];
1055
1056
780
        p->width       = s->seq.width  >> (i ? s->chroma_x_shift : 0);
1057
780
        p->height      = s->seq.height >> (i ? s->chroma_y_shift : 0);
1058
780
        p->idwt.width  = w = CALC_PADDING(p->width , s->wavelet_depth);
1059
780
        p->idwt.height = h = CALC_PADDING(p->height, s->wavelet_depth);
1060
780
        p->idwt.stride = FFALIGN(p->idwt.width, 8) << (1 + s->pshift);
1061
1062
3714
        for (level = s->wavelet_depth-1; level >= 0; level--) {
1063
2934
            w = w>>1;
1064
2934
            h = h>>1;
1065
12516
            for (orientation = !!level; orientation < 4; orientation++) {
1066
9582
                SubBand *b = &p->band[level][orientation];
1067
1068
9582
                b->pshift = s->pshift;
1069
9582
                b->ibuf   = p->idwt.buf;
1070
9582
                b->level  = level;
1071
9582
                b->stride = p->idwt.stride << (s->wavelet_depth - level);
1072
9582
                b->width  = w;
1073
9582
                b->height = h;
1074
9582
                b->orientation = orientation;
1075
1076
9582
                if (orientation & 1)
1077
5868
                    b->ibuf += w << (1+b->pshift);
1078
9582
                if (orientation > 1)
1079
5868
                    b->ibuf += (b->stride>>1);
1080
1081
9582
                if (level)
1082
6462
                    b->parent = &p->band[level-1][orientation];
1083
            }
1084
        }
1085
1086
780
        if (i > 0) {
1087
520
            p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
1088
520
            p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
1089
520
            p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
1090
520
            p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
1091
        }
1092
1093
780
        p->xoffset = (p->xblen - p->xbsep)/2;
1094
780
        p->yoffset = (p->yblen - p->ybsep)/2;
1095
    }
1096
260
}
1097
1098
/**
1099
 * Unpack the motion compensation parameters
1100
 * Dirac Specification ->
1101
 * 11.2 Picture prediction data. picture_prediction()
1102
 */
1103
29
static int dirac_unpack_prediction_parameters(DiracContext *s)
1104
{
1105
    static const uint8_t default_blen[] = { 4, 12, 16, 24 };
1106
1107
29
    GetBitContext *gb = &s->gb;
1108
    unsigned idx, ref;
1109
1110
29
    align_get_bits(gb);
1111
    /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
1112
    /* Luma and Chroma are equal. 11.2.3 */
1113
29
    idx = get_interleaved_ue_golomb(gb); /* [DIRAC_STD] index */
1114
1115
29
    if (idx > 4) {
1116
        av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
1117
        return AVERROR_INVALIDDATA;
1118
    }
1119
1120
29
    if (idx == 0) {
1121
29
        s->plane[0].xblen = get_interleaved_ue_golomb(gb);
1122
29
        s->plane[0].yblen = get_interleaved_ue_golomb(gb);
1123
29
        s->plane[0].xbsep = get_interleaved_ue_golomb(gb);
1124
29
        s->plane[0].ybsep = get_interleaved_ue_golomb(gb);
1125
    } else {
1126
        /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
1127
        s->plane[0].xblen = default_blen[idx-1];
1128
        s->plane[0].yblen = default_blen[idx-1];
1129
        s->plane[0].xbsep = 4 * idx;
1130
        s->plane[0].ybsep = 4 * idx;
1131
    }
1132
    /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
1133
      Calculated in function dirac_unpack_block_motion_data */
1134
1135
29
    if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
1136
29
        s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
1137

29
        !s->plane[0].xblen || !s->plane[0].yblen) {
1138
        av_log(s->avctx, AV_LOG_ERROR,
1139
               "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
1140
               s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
1141
        return AVERROR_INVALIDDATA;
1142
    }
1143


29
    if (!s->plane[0].xbsep || !s->plane[0].ybsep || s->plane[0].xbsep < s->plane[0].xblen/2 || s->plane[0].ybsep < s->plane[0].yblen/2) {
1144
        av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
1145
        return AVERROR_INVALIDDATA;
1146
    }
1147

29
    if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
1148
        av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
1149
        return AVERROR_INVALIDDATA;
1150
    }
1151
29
    if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
1152
        av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
1153
        return AVERROR_PATCHWELCOME;
1154
    }
1155
1156
    /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
1157
      Read motion vector precision */
1158
29
    s->mv_precision = get_interleaved_ue_golomb(gb);
1159
29
    if (s->mv_precision > 3) {
1160
        av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
1161
        return AVERROR_INVALIDDATA;
1162
    }
1163
1164
    /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
1165
      Read the global motion compensation parameters */
1166
29
    s->globalmc_flag = get_bits1(gb);
1167
29
    if (s->globalmc_flag) {
1168
        memset(s->globalmc, 0, sizeof(s->globalmc));
1169
        /* [DIRAC_STD] pan_tilt(gparams) */
1170
        for (ref = 0; ref < s->num_refs; ref++) {
1171
            if (get_bits1(gb)) {
1172
                s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
1173
                s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
1174
            }
1175
            /* [DIRAC_STD] zoom_rotate_shear(gparams)
1176
               zoom/rotation/shear parameters */
1177
            if (get_bits1(gb)) {
1178
                s->globalmc[ref].zrs_exp   = get_interleaved_ue_golomb(gb);
1179
                s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
1180
                s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
1181
                s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
1182
                s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
1183
            } else {
1184
                s->globalmc[ref].zrs[0][0] = 1;
1185
                s->globalmc[ref].zrs[1][1] = 1;
1186
            }
1187
            /* [DIRAC_STD] perspective(gparams) */
1188
            if (get_bits1(gb)) {
1189
                s->globalmc[ref].perspective_exp = get_interleaved_ue_golomb(gb);
1190
                s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
1191
                s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
1192
            }
1193
            if (s->globalmc[ref].perspective_exp + (uint64_t)s->globalmc[ref].zrs_exp > 30) {
1194
                return AVERROR_INVALIDDATA;
1195
            }
1196
1197
        }
1198
    }
1199
1200
    /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
1201
      Picture prediction mode, not currently used. */
1202
29
    if (get_interleaved_ue_golomb(gb)) {
1203
        av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
1204
        return AVERROR_INVALIDDATA;
1205
    }
1206
1207
    /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
1208
       just data read, weight calculation will be done later on. */
1209
29
    s->weight_log2denom = 1;
1210
29
    s->weight[0]        = 1;
1211
29
    s->weight[1]        = 1;
1212
1213
29
    if (get_bits1(gb)) {
1214
        s->weight_log2denom = get_interleaved_ue_golomb(gb);
1215
        if (s->weight_log2denom < 1 || s->weight_log2denom > 8) {
1216
            av_log(s->avctx, AV_LOG_ERROR, "weight_log2denom unsupported or invalid\n");
1217
            s->weight_log2denom = 1;
1218
            return AVERROR_INVALIDDATA;
1219
        }
1220
        s->weight[0] = dirac_get_se_golomb(gb);
1221
        if (s->num_refs == 2)
1222
            s->weight[1] = dirac_get_se_golomb(gb);
1223
    }
1224
29
    return 0;
1225
}
1226
1227
/**
1228
 * Dirac Specification ->
1229
 * 11.3 Wavelet transform data. wavelet_transform()
1230
 */
1231
260
static int dirac_unpack_idwt_params(DiracContext *s)
1232
{
1233
260
    GetBitContext *gb = &s->gb;
1234
    int i, level;
1235
    unsigned tmp;
1236
1237
#define CHECKEDREAD(dst, cond, errmsg) \
1238
    tmp = get_interleaved_ue_golomb(gb); \
1239
    if (cond) { \
1240
        av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1241
        return AVERROR_INVALIDDATA; \
1242
    }\
1243
    dst = tmp;
1244
1245
260
    align_get_bits(gb);
1246
1247
260
    s->zero_res = s->num_refs ? get_bits1(gb) : 0;
1248
260
    if (s->zero_res)
1249
        return 0;
1250
1251
    /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
1252
260
    CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
1253
1254

260
    CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
1255
1256
260
    if (!s->low_delay) {
1257
        /* Codeblock parameters (core syntax only) */
1258
31
        if (get_bits1(gb)) {
1259
155
            for (i = 0; i <= s->wavelet_depth; i++) {
1260

124
                CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n")
1261

124
                CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n")
1262
            }
1263
1264
31
            CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
1265
        }
1266
        else {
1267
            for (i = 0; i <= s->wavelet_depth; i++)
1268
                s->codeblock[i].width = s->codeblock[i].height = 1;
1269
        }
1270
    }
1271
    else {
1272
229
        s->num_x        = get_interleaved_ue_golomb(gb);
1273
229
        s->num_y        = get_interleaved_ue_golomb(gb);
1274

229
        if (s->num_x * s->num_y == 0 || s->num_x * (uint64_t)s->num_y > INT_MAX ||
1275
229
            s->num_x * (uint64_t)s->avctx->width  > INT_MAX ||
1276
229
            s->num_y * (uint64_t)s->avctx->height > INT_MAX ||
1277
229
            s->num_x > s->avctx->width ||
1278
229
            s->num_y > s->avctx->height
1279
        ) {
1280
            av_log(s->avctx,AV_LOG_ERROR,"Invalid numx/y\n");
1281
            s->num_x = s->num_y = 0;
1282
            return AVERROR_INVALIDDATA;
1283
        }
1284
229
        if (s->ld_picture) {
1285
31
            s->lowdelay.bytes.num = get_interleaved_ue_golomb(gb);
1286
31
            s->lowdelay.bytes.den = get_interleaved_ue_golomb(gb);
1287
31
            if (s->lowdelay.bytes.den <= 0) {
1288
                av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
1289
                return AVERROR_INVALIDDATA;
1290
            }
1291
198
        } else if (s->hq_picture) {
1292
198
            s->highquality.prefix_bytes = get_interleaved_ue_golomb(gb);
1293
198
            s->highquality.size_scaler  = get_interleaved_ue_golomb(gb);
1294
198
            if (s->highquality.prefix_bytes >= INT_MAX / 8) {
1295
                av_log(s->avctx,AV_LOG_ERROR,"too many prefix bytes\n");
1296
                return AVERROR_INVALIDDATA;
1297
            }
1298
        }
1299
1300
        /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1301
229
        if (get_bits1(gb)) {
1302
            av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1303
            /* custom quantization matrix */
1304
            for (level = 0; level < s->wavelet_depth; level++) {
1305
                for (i = !!level; i < 4; i++) {
1306
                    s->lowdelay.quant[level][i] = get_interleaved_ue_golomb(gb);
1307
                }
1308
            }
1309
        } else {
1310
229
            if (s->wavelet_depth > 4) {
1311
                av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1312
                return AVERROR_INVALIDDATA;
1313
            }
1314
            /* default quantization matrix */
1315
1114
            for (level = 0; level < s->wavelet_depth; level++)
1316
4425
                for (i = 0; i < 4; i++) {
1317
3540
                    s->lowdelay.quant[level][i] = ff_dirac_default_qmat[s->wavelet_idx][level][i];
1318
                    /* haar with no shift differs for different depths */
1319
3540
                    if (s->wavelet_idx == 3)
1320
                        s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1321
                }
1322
        }
1323
    }
1324
260
    return 0;
1325
}
1326
1327
2320
static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1328
{
1329
    static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1330
1331
2320
    if (!(x|y))
1332
29
        return 0;
1333
2291
    else if (!y)
1334
261
        return sbsplit[-1];
1335
2030
    else if (!x)
1336
203
        return sbsplit[-stride];
1337
1338
1827
    return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1339
}
1340
1341
8493
static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1342
{
1343
    int pred;
1344
1345
8493
    if (!(x|y))
1346
57
        return 0;
1347
8436
    else if (!y)
1348
545
        return block[-1].ref & refmask;
1349
7891
    else if (!x)
1350
399
        return block[-stride].ref & refmask;
1351
1352
    /* return the majority */
1353
7492
    pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1354
7492
    return (pred >> 1) & refmask;
1355
}
1356
1357
754
static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1358
{
1359
754
    int i, n = 0;
1360
1361
754
    memset(block->u.dc, 0, sizeof(block->u.dc));
1362
1363

754
    if (x && !(block[-1].ref & 3)) {
1364
1752
        for (i = 0; i < 3; i++)
1365
1314
            block->u.dc[i] += block[-1].u.dc[i];
1366
438
        n++;
1367
    }
1368
1369

754
    if (y && !(block[-stride].ref & 3)) {
1370
1616
        for (i = 0; i < 3; i++)
1371
1212
            block->u.dc[i] += block[-stride].u.dc[i];
1372
404
        n++;
1373
    }
1374
1375

754
    if (x && y && !(block[-1-stride].ref & 3)) {
1376
1372
        for (i = 0; i < 3; i++)
1377
1029
            block->u.dc[i] += block[-1-stride].u.dc[i];
1378
343
        n++;
1379
    }
1380
1381
754
    if (n == 2) {
1382
880
        for (i = 0; i < 3; i++)
1383
660
            block->u.dc[i] = (block->u.dc[i]+1)>>1;
1384
534
    } else if (n == 3) {
1385
656
        for (i = 0; i < 3; i++)
1386
492
            block->u.dc[i] = divide3(block->u.dc[i]);
1387
    }
1388
754
}
1389
1390
5951
static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1391
{
1392
    int16_t *pred[3];
1393
5951
    int refmask = ref+1;
1394
5951
    int mask = refmask | DIRAC_REF_MASK_GLOBAL; /*  exclude gmc blocks */
1395
5951
    int n = 0;
1396
1397

5951
    if (x && (block[-1].ref & mask) == refmask)
1398
4890
        pred[n++] = block[-1].u.mv[ref];
1399
1400

5951
    if (y && (block[-stride].ref & mask) == refmask)
1401
4719
        pred[n++] = block[-stride].u.mv[ref];
1402
1403

5951
    if (x && y && (block[-stride-1].ref & mask) == refmask)
1404
4313
        pred[n++] = block[-stride-1].u.mv[ref];
1405
1406

5951
    switch (n) {
1407
304
    case 0:
1408
304
        block->u.mv[ref][0] = 0;
1409
304
        block->u.mv[ref][1] = 0;
1410
304
        break;
1411
1266
    case 1:
1412
1266
        block->u.mv[ref][0] = pred[0][0];
1413
1266
        block->u.mv[ref][1] = pred[0][1];
1414
1266
        break;
1415
487
    case 2:
1416
487
        block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1417
487
        block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1418
487
        break;
1419
3894
    case 3:
1420
3894
        block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1421
3894
        block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1422
3894
        break;
1423
    }
1424
5951
}
1425
1426
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1427
{
1428
    int ez      = s->globalmc[ref].zrs_exp;
1429
    int ep      = s->globalmc[ref].perspective_exp;
1430
    int (*A)[2] = s->globalmc[ref].zrs;
1431
    int *b      = s->globalmc[ref].pan_tilt;
1432
    int *c      = s->globalmc[ref].perspective;
1433
1434
    int64_t m   = (1<<ep) - (c[0]*(int64_t)x + c[1]*(int64_t)y);
1435
    int64_t mx  = m * (int64_t)((A[0][0] * (int64_t)x + A[0][1]*(int64_t)y) + (1LL<<ez) * b[0]);
1436
    int64_t my  = m * (int64_t)((A[1][0] * (int64_t)x + A[1][1]*(int64_t)y) + (1LL<<ez) * b[1]);
1437
1438
    block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1439
    block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1440
}
1441
1442
4348
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
1443
                                int stride, int x, int y)
1444
{
1445
    int i;
1446
1447
4348
    block->ref  = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1448
4348
    block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1449
1450
4348
    if (s->num_refs == 2) {
1451
4145
        block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1452
4145
        block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1453
    }
1454
1455
4348
    if (!block->ref) {
1456
754
        pred_block_dc(block, stride, x, y);
1457
3016
        for (i = 0; i < 3; i++)
1458
2262
            block->u.dc[i] += (unsigned)dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1459
754
        return;
1460
    }
1461
1462
3594
    if (s->globalmc_flag) {
1463
        block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1464
        block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1465
    }
1466
1467
10636
    for (i = 0; i < s->num_refs; i++)
1468
7042
        if (block->ref & (i+1)) {
1469
5951
            if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1470
                global_mv(s, block, x, y, i);
1471
            } else {
1472
5951
                pred_mv(block, stride, x, y, i);
1473
5951
                block->u.mv[i][0] += (unsigned)dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1474
5951
                block->u.mv[i][1] += (unsigned)dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1475
            }
1476
        }
1477
}
1478
1479
/**
1480
 * Copies the current block to the other blocks covered by the current superblock split mode
1481
 */
1482
4348
static void propagate_block_data(DiracBlock *block, int stride, int size)
1483
{
1484
    int x, y;
1485
4348
    DiracBlock *dst = block;
1486
1487
11112
    for (x = 1; x < size; x++)
1488
6764
        dst[x] = *block;
1489
1490
11112
    for (y = 1; y < size; y++) {
1491
6764
        dst += stride;
1492
32772
        for (x = 0; x < size; x++)
1493
26008
            dst[x] = *block;
1494
    }
1495
4348
}
1496
1497
/**
1498
 * Dirac Specification ->
1499
 * 12. Block motion data syntax
1500
 */
1501
29
static int dirac_unpack_block_motion_data(DiracContext *s)
1502
{
1503
29
    GetBitContext *gb = &s->gb;
1504
29
    uint8_t *sbsplit = s->sbsplit;
1505
    int i, x, y, q, p;
1506
    DiracArith arith[8];
1507
1508
29
    align_get_bits(gb);
1509
1510
    /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1511
29
    s->sbwidth  = DIVRNDUP(s->seq.width,  4*s->plane[0].xbsep);
1512
29
    s->sbheight = DIVRNDUP(s->seq.height, 4*s->plane[0].ybsep);
1513
29
    s->blwidth  = 4 * s->sbwidth;
1514
29
    s->blheight = 4 * s->sbheight;
1515
1516
    /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1517
       decode superblock split modes */
1518
29
    ff_dirac_init_arith_decoder(arith, gb, get_interleaved_ue_golomb(gb));     /* get_interleaved_ue_golomb(gb) is the length */
1519
261
    for (y = 0; y < s->sbheight; y++) {
1520
2552
        for (x = 0; x < s->sbwidth; x++) {
1521
2320
            unsigned int split  = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1522
2320
            if (split > 2)
1523
                return AVERROR_INVALIDDATA;
1524
2320
            sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1525
        }
1526
232
        sbsplit += s->sbwidth;
1527
    }
1528
1529
    /* setup arith decoding */
1530
29
    ff_dirac_init_arith_decoder(arith, gb, get_interleaved_ue_golomb(gb));
1531
86
    for (i = 0; i < s->num_refs; i++) {
1532
57
        ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, get_interleaved_ue_golomb(gb));
1533
57
        ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, get_interleaved_ue_golomb(gb));
1534
    }
1535
116
    for (i = 0; i < 3; i++)
1536
87
        ff_dirac_init_arith_decoder(arith+1+i, gb, get_interleaved_ue_golomb(gb));
1537
1538
261
    for (y = 0; y < s->sbheight; y++)
1539
2552
        for (x = 0; x < s->sbwidth; x++) {
1540
2320
            int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1541
2320
            int step   = 4 >> s->sbsplit[y * s->sbwidth + x];
1542
1543
5098
            for (q = 0; q < blkcnt; q++)
1544
7126
                for (p = 0; p < blkcnt; p++) {
1545
4348
                    int bx = 4 * x + p*step;
1546
4348
                    int by = 4 * y + q*step;
1547
4348
                    DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1548
4348
                    decode_block_params(s, arith, block, s->blwidth, bx, by);
1549
4348
                    propagate_block_data(block, s->blwidth, step);
1550
                }
1551
        }
1552
1553
259
    for (i = 0; i < 4 + 2*s->num_refs; i++) {
1554
230
        if (arith[i].error)
1555
            return arith[i].error;
1556
    }
1557
1558
29
    return 0;
1559
}
1560
1561
72384
static int weight(int i, int blen, int offset)
1562
{
1563
#define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) :        \
1564
    (1 + (6*(i) + offset - 1) / (2*offset - 1))
1565
1566
72384
    if (i < 2*offset)
1567

36192
        return ROLLOFF(i);
1568
36192
    else if (i > blen-1 - 2*offset)
1569

36192
        return ROLLOFF(blen-1 - i);
1570
    return 8;
1571
}
1572
1573
8352
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1574
                                 int left, int right, int wy)
1575
{
1576
    int x;
1577

25056
    for (x = 0; left && x < p->xblen >> 1; x++)
1578
16704
        obmc_weight[x] = wy*8;
1579
75168
    for (; x < p->xblen >> right; x++)
1580
66816
        obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1581
25056
    for (; x < p->xblen; x++)
1582
16704
        obmc_weight[x] = wy*8;
1583
175392
    for (; x < stride; x++)
1584
167040
        obmc_weight[x] = 0;
1585
8352
}
1586
1587
783
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1588
                             int left, int right, int top, int bottom)
1589
{
1590
    int y;
1591

2175
    for (y = 0; top && y < p->yblen >> 1; y++) {
1592
1392
        init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1593
1392
        obmc_weight += stride;
1594
    }
1595
6351
    for (; y < p->yblen >> bottom; y++) {
1596
5568
        int wy = weight(y, p->yblen, p->yoffset);
1597
5568
        init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1598
5568
        obmc_weight += stride;
1599
    }
1600
2175
    for (; y < p->yblen; y++) {
1601
1392
        init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1602
1392
        obmc_weight += stride;
1603
    }
1604
783
}
1605
1606
2784
static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1607
{
1608
2784
    int top = !by;
1609
2784
    int bottom = by == s->blheight-1;
1610
1611
    /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1612

2784
    if (top || bottom || by == 1) {
1613
261
        init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1614
261
        init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1615
261
        init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1616
    }
1617
2784
}
1618
1619
static const uint8_t epel_weights[4][4][4] = {
1620
    {{ 16,  0,  0,  0 },
1621
     { 12,  4,  0,  0 },
1622
     {  8,  8,  0,  0 },
1623
     {  4, 12,  0,  0 }},
1624
    {{ 12,  0,  4,  0 },
1625
     {  9,  3,  3,  1 },
1626
     {  6,  6,  2,  2 },
1627
     {  3,  9,  1,  3 }},
1628
    {{  8,  0,  8,  0 },
1629
     {  6,  2,  6,  2 },
1630
     {  4,  4,  4,  4 },
1631
     {  2,  6,  2,  6 }},
1632
    {{  4,  0, 12,  0 },
1633
     {  3,  1,  9,  3 },
1634
     {  2,  2,  6,  6 },
1635
     {  1,  3,  3,  9 }}
1636
};
1637
1638
/**
1639
 * For block x,y, determine which of the hpel planes to do bilinear
1640
 * interpolation from and set src[] to the location in each hpel plane
1641
 * to MC from.
1642
 *
1643
 * @return the index of the put_dirac_pixels_tab function to use
1644
 *  0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1645
 */
1646
199452
static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
1647
                     int x, int y, int ref, int plane)
1648
{
1649
199452
    Plane *p = &s->plane[plane];
1650
199452
    uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1651
199452
    int motion_x = block->u.mv[ref][0];
1652
199452
    int motion_y = block->u.mv[ref][1];
1653
199452
    int mx, my, i, epel, nplanes = 0;
1654
1655
199452
    if (plane) {
1656
132968
        motion_x >>= s->chroma_x_shift;
1657
132968
        motion_y >>= s->chroma_y_shift;
1658
    }
1659
1660
199452
    mx         = motion_x & ~(-1U << s->mv_precision);
1661
199452
    my         = motion_y & ~(-1U << s->mv_precision);
1662
199452
    motion_x >>= s->mv_precision;
1663
199452
    motion_y >>= s->mv_precision;
1664
    /* normalize subpel coordinates to epel */
1665
    /* TODO: template this function? */
1666
199452
    mx      <<= 3 - s->mv_precision;
1667
199452
    my      <<= 3 - s->mv_precision;
1668
1669
199452
    x += motion_x;
1670
199452
    y += motion_y;
1671
199452
    epel = (mx|my)&1;
1672
1673
    /* hpel position */
1674
199452
    if (!((mx|my)&3)) {
1675
199452
        nplanes = 1;
1676
199452
        src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1677
    } else {
1678
        /* qpel or epel */
1679
        nplanes = 4;
1680
        for (i = 0; i < 4; i++)
1681
            src[i] = ref_hpel[i] + y*p->stride + x;
1682
1683
        /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1684
           we increment x/y because the edge changes for half of the pixels */
1685
        if (mx > 4) {
1686
            src[0] += 1;
1687
            src[2] += 1;
1688
            x++;
1689
        }
1690
        if (my > 4) {
1691
            src[0] += p->stride;
1692
            src[1] += p->stride;
1693
            y++;
1694
        }
1695
1696
        /* hpel planes are:
1697
           [0]: F  [1]: H
1698
           [2]: V  [3]: C */
1699
        if (!epel) {
1700
            /* check if we really only need 2 planes since either mx or my is
1701
               a hpel position. (epel weights of 0 handle this there) */
1702
            if (!(mx&3)) {
1703
                /* mx == 0: average [0] and [2]
1704
                   mx == 4: average [1] and [3] */
1705
                src[!mx] = src[2 + !!mx];
1706
                nplanes = 2;
1707
            } else if (!(my&3)) {
1708
                src[0] = src[(my>>1)  ];
1709
                src[1] = src[(my>>1)+1];
1710
                nplanes = 2;
1711
            }
1712
        } else {
1713
            /* adjust the ordering if needed so the weights work */
1714
            if (mx > 4) {
1715
                FFSWAP(const uint8_t *, src[0], src[1]);
1716
                FFSWAP(const uint8_t *, src[2], src[3]);
1717
            }
1718
            if (my > 4) {
1719
                FFSWAP(const uint8_t *, src[0], src[2]);
1720
                FFSWAP(const uint8_t *, src[1], src[3]);
1721
            }
1722
            src[4] = epel_weights[my&3][mx&3];
1723
        }
1724
    }
1725
1726
    /* fixme: v/h _edge_pos */
1727
199452
    if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1728

199293
        y + p->yblen > p->height+EDGE_WIDTH/2 ||
1729
191702
        x < 0 || y < 0) {
1730
27830
        for (i = 0; i < nplanes; i++) {
1731
13915
            s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1732
                                     p->stride, p->stride,
1733
13915
                                     p->xblen, p->yblen, x, y,
1734
13915
                                     p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1735
13915
            src[i] = s->edge_emu_buffer[i];
1736
        }
1737
    }
1738
199452
    return (nplanes>>1) + epel;
1739
}
1740
1741
2262
static void add_dc(uint16_t *dst, int dc, int stride,
1742
                   uint8_t *obmc_weight, int xblen, int yblen)
1743
{
1744
    int x, y;
1745
2262
    dc += 128;
1746
1747
26390
    for (y = 0; y < yblen; y++) {
1748
168896
        for (x = 0; x < xblen; x += 2) {
1749
144768
            dst[x  ] += dc * obmc_weight[x  ];
1750
144768
            dst[x+1] += dc * obmc_weight[x+1];
1751
        }
1752
24128
        dst          += stride;
1753
24128
        obmc_weight  += MAX_BLOCKSIZE;
1754
    }
1755
2262
}
1756
1757
107880
static void block_mc(DiracContext *s, DiracBlock *block,
1758
                     uint16_t *mctmp, uint8_t *obmc_weight,
1759
                     int plane, int dstx, int dsty)
1760
{
1761
107880
    Plane *p = &s->plane[plane];
1762
    const uint8_t *src[5];
1763
    int idx;
1764
1765

107880
    switch (block->ref&3) {
1766
2262
    case 0: /* DC */
1767
2262
        add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1768
2262
        return;
1769
11784
    case 1:
1770
    case 2:
1771
11784
        idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1772
11784
        s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1773
11784
        if (s->weight_func)
1774
            s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1775
                           s->weight[0] + s->weight[1], p->yblen);
1776
11784
        break;
1777
93834
    case 3:
1778
93834
        idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1779
93834
        s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1780
93834
        idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1781
93834
        if (s->biweight_func) {
1782
            /* fixme: +32 is a quick hack */
1783
            s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1784
            s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1785
                             s->weight[0], s->weight[1], p->yblen);
1786
        } else
1787
93834
            s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1788
93834
        break;
1789
    }
1790
105618
    s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1791
}
1792
1793
2697
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1794
{
1795
2697
    Plane *p = &s->plane[plane];
1796
2697
    int x, dstx = p->xbsep - p->xoffset;
1797
1798
2697
    block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1799
2697
    mctmp += p->xbsep;
1800
1801
105183
    for (x = 1; x < s->blwidth-1; x++) {
1802
102486
        block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1803
102486
        dstx  += p->xbsep;
1804
102486
        mctmp += p->xbsep;
1805
    }
1806
2697
    block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1807
2697
}
1808
1809
87
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1810
{
1811
87
    int idx = 0;
1812
87
    if (xblen > 8)
1813
29
        idx = 1;
1814
87
    if (xblen > 16)
1815
        idx = 2;
1816
1817
87
    memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1818
87
    memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1819
87
    s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1820

87
    if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1821
        s->weight_func   = s->diracdsp.weight_dirac_pixels_tab[idx];
1822
        s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1823
    } else {
1824
87
        s->weight_func   = NULL;
1825
87
        s->biweight_func = NULL;
1826
    }
1827
87
}
1828
1829
171
static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1830
{
1831
    /* chroma allocates an edge of 8 when subsampled
1832
       which for 4:2:2 means an h edge of 16 and v edge of 8
1833
       just use 8 for everything for the moment */
1834
171
    int i, edge = EDGE_WIDTH/2;
1835
1836
171
    ref->hpel[plane][0] = ref->avframe->data[plane];
1837
171
    s->mpvencdsp.draw_edges(ref->hpel[plane][0], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM); /* EDGE_TOP | EDGE_BOTTOM values just copied to make it build, this needs to be ensured */
1838
1839
    /* no need for hpel if we only have fpel vectors */
1840
171
    if (!s->mv_precision)
1841
171
        return 0;
1842
1843
    for (i = 1; i < 4; i++) {
1844
        if (!ref->hpel_base[plane][i])
1845
            ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1846
        if (!ref->hpel_base[plane][i]) {
1847
            return AVERROR(ENOMEM);
1848
        }
1849
        /* we need to be 16-byte aligned even for chroma */
1850
        ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1851
    }
1852
1853
    if (!ref->interpolated[plane]) {
1854
        s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1855
                                      ref->hpel[plane][3], ref->hpel[plane][0],
1856
                                      ref->avframe->linesize[plane], width, height);
1857
        s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1858
        s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1859
        s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1860
    }
1861
    ref->interpolated[plane] = 1;
1862
1863
    return 0;
1864
}
1865
1866
/**
1867
 * Dirac Specification ->
1868
 * 13.0 Transform data syntax. transform_data()
1869
 */
1870
260
static int dirac_decode_frame_internal(DiracContext *s)
1871
{
1872
    DWTContext d;
1873
    int y, i, comp, dsty;
1874
    int ret;
1875
1876
260
    if (s->low_delay) {
1877
        /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1878
229
        if (!s->hq_picture) {
1879
124
            for (comp = 0; comp < 3; comp++) {
1880
93
                Plane *p = &s->plane[comp];
1881
93
                memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height);
1882
            }
1883
        }
1884
229
        if (!s->zero_res) {
1885
229
            if ((ret = decode_lowdelay(s)) < 0)
1886
                return ret;
1887
        }
1888
    }
1889
1890
1040
    for (comp = 0; comp < 3; comp++) {
1891
780
        Plane *p       = &s->plane[comp];
1892
780
        uint8_t *frame = s->current_picture->avframe->data[comp];
1893
1894
        /* FIXME: small resolutions */
1895
3900
        for (i = 0; i < 4; i++)
1896
3120
            s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1897
1898

780
        if (!s->zero_res && !s->low_delay)
1899
        {
1900
93
            memset(p->idwt.buf, 0, p->idwt.stride * p->idwt.height);
1901
93
            ret = decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1902
93
            if (ret < 0)
1903
                return ret;
1904
        }
1905
780
        ret = ff_spatial_idwt_init(&d, &p->idwt, s->wavelet_idx+2,
1906
780
                                   s->wavelet_depth, s->bit_depth);
1907
780
        if (ret < 0)
1908
            return ret;
1909
1910
780
        if (!s->num_refs) { /* intra */
1911
11436
            for (y = 0; y < p->height; y += 16) {
1912
10743
                int idx = (s->bit_depth - 8) >> 1;
1913
10743
                ff_spatial_idwt_slice2(&d, y+16); /* decode */
1914
10743
                s->diracdsp.put_signed_rect_clamped[idx](frame + y*p->stride,
1915
10743
                                                         p->stride,
1916
10743
                                                         p->idwt.buf + y*p->idwt.stride,
1917
                                                         p->idwt.stride, p->width, 16);
1918
            }
1919
        } else { /* inter */
1920
87
            int rowheight = p->ybsep*p->stride;
1921
1922
87
            select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1923
1924
258
            for (i = 0; i < s->num_refs; i++) {
1925
171
                int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1926
171
                if (ret < 0)
1927
                    return ret;
1928
            }
1929
1930
87
            memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1931
1932
87
            dsty = -p->yoffset;
1933
2784
            for (y = 0; y < s->blheight; y++) {
1934
2784
                int h     = 0,
1935
2784
                    start = FFMAX(dsty, 0);
1936
2784
                uint16_t *mctmp    = s->mctmp + y*rowheight;
1937
2784
                DiracBlock *blocks = s->blmotion + y*s->blwidth;
1938
1939
2784
                init_obmc_weights(s, p, y);
1940
1941

2784
                if (y == s->blheight-1 || start+p->ybsep > p->height)
1942
174
                    h = p->height - start;
1943
                else
1944
2610
                    h = p->ybsep - (start - dsty);
1945
2784
                if (h < 0)
1946
87
                    break;
1947
1948
2697
                memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1949
2697
                mc_row(s, blocks, mctmp, comp, dsty);
1950
1951
2697
                mctmp += (start - dsty)*p->stride + p->xoffset;
1952
2697
                ff_spatial_idwt_slice2(&d, start + h); /* decode */
1953
                /* NOTE: add_rect_clamped hasn't been templated hence the shifts.
1954
                 * idwt.stride is passed as pixels, not in bytes as in the rest of the decoder */
1955
2697
                s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1956
2697
                                             (int16_t*)(p->idwt.buf) + start*(p->idwt.stride >> 1), (p->idwt.stride >> 1), p->width, h);
1957
1958
2697
                dsty += p->ybsep;
1959
            }
1960
        }
1961
    }
1962
1963
1964
260
    return 0;
1965
}
1966
1967
260
static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
1968
{
1969
    int ret, i;
1970
    int chroma_x_shift, chroma_y_shift;
1971
260
    ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift,
1972
                                           &chroma_y_shift);
1973
260
    if (ret < 0)
1974
        return ret;
1975
1976
260
    f->width  = avctx->width  + 2 * EDGE_WIDTH;
1977
260
    f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1978
260
    ret = ff_get_buffer(avctx, f, flags);
1979
260
    if (ret < 0)
1980
        return ret;
1981
1982
1040
    for (i = 0; f->data[i]; i++) {
1983

780
        int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1984
780
                     f->linesize[i] + 32;
1985
780
        f->data[i] += offset;
1986
    }
1987
260
    f->width  = avctx->width;
1988
260
    f->height = avctx->height;
1989
1990
260
    return 0;
1991
}
1992
1993
/**
1994
 * Dirac Specification ->
1995
 * 11.1.1 Picture Header. picture_header()
1996
 */
1997
260
static int dirac_decode_picture_header(DiracContext *s)
1998
{
1999
    unsigned retire, picnum;
2000
    int i, j, ret;
2001
    int64_t refdist, refnum;
2002
260
    GetBitContext *gb = &s->gb;
2003
2004
    /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
2005
260
    picnum = s->current_picture->avframe->display_picture_number = get_bits_long(gb, 32);
2006
2007
2008
260
    av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
2009
2010
    /* if this is the first keyframe after a sequence header, start our
2011
       reordering from here */
2012
260
    if (s->frame_number < 0)
2013
70
        s->frame_number = picnum;
2014
2015
260
    s->ref_pics[0] = s->ref_pics[1] = NULL;
2016
317
    for (i = 0; i < s->num_refs; i++) {
2017
57
        refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
2018
57
        refdist = INT64_MAX;
2019
2020
        /* find the closest reference to the one we want */
2021
        /* Jordi: this is needed if the referenced picture hasn't yet arrived */
2022

184
        for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
2023
127
            if (s->ref_frames[j]
2024
127
                && FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
2025
127
                s->ref_pics[i] = s->ref_frames[j];
2026
127
                refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
2027
            }
2028
2029

57
        if (!s->ref_pics[i] || refdist)
2030
            av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
2031
2032
        /* if there were no references at all, allocate one */
2033
57
        if (!s->ref_pics[i])
2034
            for (j = 0; j < MAX_FRAMES; j++)
2035
                if (!s->all_frames[j].avframe->data[0]) {
2036
                    s->ref_pics[i] = &s->all_frames[j];
2037
                    ret = get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
2038
                    if (ret < 0)
2039
                        return ret;
2040
                    break;
2041
                }
2042
2043
57
        if (!s->ref_pics[i]) {
2044
            av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
2045
            return AVERROR_INVALIDDATA;
2046
        }
2047
2048
    }
2049
2050
    /* retire the reference frames that are not used anymore */
2051
260
    if (s->current_picture->reference) {
2052
10
        retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
2053
10
        if (retire != picnum) {
2054
6
            DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
2055
2056
6
            if (retire_pic)
2057
6
                retire_pic->reference &= DELAYED_PIC_REF;
2058
            else
2059
                av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
2060
        }
2061
2062
        /* if reference array is full, remove the oldest as per the spec */
2063
10
        while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
2064
            av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
2065
            remove_frame(s->ref_frames, s->ref_frames[0]->avframe->display_picture_number)->reference &= DELAYED_PIC_REF;
2066
        }
2067
    }
2068
2069
260
    if (s->num_refs) {
2070
29
        ret = dirac_unpack_prediction_parameters(s);  /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
2071
29
        if (ret < 0)
2072
            return ret;
2073
29
        ret = dirac_unpack_block_motion_data(s);      /* [DIRAC_STD] 12. Block motion data syntax                       */
2074
29
        if (ret < 0)
2075
            return ret;
2076
    }
2077
260
    ret = dirac_unpack_idwt_params(s);                /* [DIRAC_STD] 11.3 Wavelet transform data                        */
2078
260
    if (ret < 0)
2079
        return ret;
2080
2081
260
    init_planes(s);
2082
260
    return 0;
2083
}
2084
2085
36
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
2086
{
2087
36
    DiracFrame *out = s->delay_frames[0];
2088
36
    int i, out_idx  = 0;
2089
    int ret;
2090
2091
    /* find frame with lowest picture number */
2092
36
    for (i = 1; s->delay_frames[i]; i++)
2093
        if (s->delay_frames[i]->avframe->display_picture_number < out->avframe->display_picture_number) {
2094
            out     = s->delay_frames[i];
2095
            out_idx = i;
2096
        }
2097
2098
37
    for (i = out_idx; s->delay_frames[i]; i++)
2099
1
        s->delay_frames[i] = s->delay_frames[i+1];
2100
2101
36
    if (out) {
2102
1
        out->reference ^= DELAYED_PIC_REF;
2103
1
        if((ret = av_frame_ref(picture, out->avframe)) < 0)
2104
            return ret;
2105
1
        *got_frame = 1;
2106
    }
2107
2108
36
    return 0;
2109
}
2110
2111
/**
2112
 * Dirac Specification ->
2113
 * 9.6 Parse Info Header Syntax. parse_info()
2114
 * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
2115
 */
2116
#define DATA_UNIT_HEADER_SIZE 13
2117
2118
/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
2119
   inside the function parse_sequence() */
2120
757
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
2121
{
2122
757
    DiracContext *s   = avctx->priv_data;
2123
757
    DiracFrame *pic   = NULL;
2124
    AVDiracSeqHeader *dsh;
2125
    int ret, i;
2126
    uint8_t parse_code;
2127
    unsigned tmp;
2128
2129
757
    if (size < DATA_UNIT_HEADER_SIZE)
2130
        return AVERROR_INVALIDDATA;
2131
2132
757
    parse_code = buf[4];
2133
2134
757
    init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
2135
2136
757
    if (parse_code == DIRAC_PCODE_SEQ_HEADER) {
2137
231
        if (s->seen_sequence_header)
2138
161
            return 0;
2139
2140
        /* [DIRAC_STD] 10. Sequence header */
2141
70
        ret = av_dirac_parse_sequence_header(&dsh, buf + DATA_UNIT_HEADER_SIZE, size - DATA_UNIT_HEADER_SIZE, avctx);
2142
70
        if (ret < 0) {
2143
            av_log(avctx, AV_LOG_ERROR, "error parsing sequence header");
2144
            return ret;
2145
        }
2146
2147
70
        if (CALC_PADDING((int64_t)dsh->width, MAX_DWT_LEVELS) * CALC_PADDING((int64_t)dsh->height, MAX_DWT_LEVELS) * 5LL > avctx->max_pixels)
2148
            ret = AVERROR(ERANGE);
2149
70
        if (ret >= 0)
2150
70
            ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
2151
70
        if (ret < 0) {
2152
            av_freep(&dsh);
2153
            return ret;
2154
        }
2155
2156
70
        ff_set_sar(avctx, dsh->sample_aspect_ratio);
2157
70
        avctx->pix_fmt         = dsh->pix_fmt;
2158
70
        avctx->color_range     = dsh->color_range;
2159
70
        avctx->color_trc       = dsh->color_trc;
2160
70
        avctx->color_primaries = dsh->color_primaries;
2161
70
        avctx->colorspace      = dsh->colorspace;
2162
70
        avctx->profile         = dsh->profile;
2163
70
        avctx->level           = dsh->level;
2164
70
        avctx->framerate       = dsh->framerate;
2165
70
        s->bit_depth           = dsh->bit_depth;
2166
70
        s->version.major       = dsh->version.major;
2167
70
        s->version.minor       = dsh->version.minor;
2168
70
        s->seq                 = *dsh;
2169
70
        av_freep(&dsh);
2170
2171
70
        s->pshift = s->bit_depth > 8;
2172
2173
70
        ret = av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
2174
                                               &s->chroma_x_shift,
2175
                                               &s->chroma_y_shift);
2176
70
        if (ret < 0)
2177
            return ret;
2178
2179
70
        ret = alloc_sequence_buffers(s);
2180
70
        if (ret < 0)
2181
            return ret;
2182
2183
70
        s->seen_sequence_header = 1;
2184
526
    } else if (parse_code == DIRAC_PCODE_END_SEQ) { /* [DIRAC_STD] End of Sequence */
2185
        free_sequence_buffers(s);
2186
        s->seen_sequence_header = 0;
2187
526
    } else if (parse_code == DIRAC_PCODE_AUX) {
2188
266
        if (buf[13] == 1) {     /* encoder implementation/version */
2189
            int ver[3];
2190
            /* versions older than 1.0.8 don't store quant delta for
2191
               subbands with only one codeblock */
2192
4
            if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
2193

4
                if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
2194
                    s->old_delta_quant = 1;
2195
        }
2196
260
    } else if (parse_code & 0x8) {  /* picture data unit */
2197
260
        if (!s->seen_sequence_header) {
2198
            av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
2199
            return AVERROR_INVALIDDATA;
2200
        }
2201
2202
        /* find an unused frame */
2203
3900
        for (i = 0; i < MAX_FRAMES; i++)
2204
3640
            if (s->all_frames[i].avframe->data[0] == NULL)
2205
3559
                pic = &s->all_frames[i];
2206
260
        if (!pic) {
2207
            av_log(avctx, AV_LOG_ERROR, "framelist full\n");
2208
            return AVERROR_INVALIDDATA;
2209
        }
2210
2211
260
        av_frame_unref(pic->avframe);
2212
2213
        /* [DIRAC_STD] Defined in 9.6.1 ... */
2214
260
        tmp            =  parse_code & 0x03;                   /* [DIRAC_STD] num_refs()      */
2215
260
        if (tmp > 2) {
2216
            av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
2217
            return AVERROR_INVALIDDATA;
2218
        }
2219
260
        s->num_refs      = tmp;
2220
260
        s->is_arith      = (parse_code & 0x48) == 0x08;          /* [DIRAC_STD] using_ac()            */
2221
260
        s->low_delay     = (parse_code & 0x88) == 0x88;          /* [DIRAC_STD] is_low_delay()        */
2222
260
        s->core_syntax   = (parse_code & 0x88) == 0x08;          /* [DIRAC_STD] is_core_syntax()      */
2223
260
        s->ld_picture    = (parse_code & 0xF8) == 0xC8;          /* [DIRAC_STD] is_ld_picture()       */
2224
260
        s->hq_picture    = (parse_code & 0xF8) == 0xE8;          /* [DIRAC_STD] is_hq_picture()       */
2225
260
        s->dc_prediction = (parse_code & 0x28) == 0x08;          /* [DIRAC_STD] using_dc_prediction() */
2226
260
        pic->reference   = (parse_code & 0x0C) == 0x0C;          /* [DIRAC_STD] is_reference()        */
2227
260
        pic->avframe->key_frame = s->num_refs == 0;              /* [DIRAC_STD] is_intra()            */
2228
260
        pic->avframe->pict_type = s->num_refs + 1;               /* Definition of AVPictureType in avutil.h */
2229
2230
        /* VC-2 Low Delay has a different parse code than the Dirac Low Delay */
2231

260
        if (s->version.minor == 2 && parse_code == 0x88)
2232
31
            s->ld_picture = 1;
2233
2234

260
        if (s->low_delay && !(s->ld_picture || s->hq_picture) ) {
2235
            av_log(avctx, AV_LOG_ERROR, "Invalid low delay flag\n");
2236
            return AVERROR_INVALIDDATA;
2237
        }
2238
2239
260
        if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
2240
            return ret;
2241
260
        s->current_picture = pic;
2242
260
        s->plane[0].stride = pic->avframe->linesize[0];
2243
260
        s->plane[1].stride = pic->avframe->linesize[1];
2244
260
        s->plane[2].stride = pic->avframe->linesize[2];
2245
2246
260
        if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)
2247
            return AVERROR(ENOMEM);
2248
2249
        /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
2250
260
        ret = dirac_decode_picture_header(s);
2251
260
        if (ret < 0)
2252
            return ret;
2253
2254
        /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
2255
260
        ret = dirac_decode_frame_internal(s);
2256
260
        if (ret < 0)
2257
            return ret;
2258
    }
2259
596
    return 0;
2260
}
2261
2262
298
static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
2263
{
2264
298
    DiracContext *s     = avctx->priv_data;
2265
298
    AVFrame *picture    = data;
2266
298
    uint8_t *buf        = pkt->data;
2267
298
    int buf_size        = pkt->size;
2268
298
    int i, buf_idx      = 0;
2269
    int ret;
2270
    unsigned data_unit_size;
2271
2272
    /* release unused frames */
2273
4470
    for (i = 0; i < MAX_FRAMES; i++)
2274

4172
        if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].reference) {
2275
222
            av_frame_unref(s->all_frames[i].avframe);
2276
222
            memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
2277
        }
2278
2279
298
    s->current_picture = NULL;
2280
298
    *got_frame = 0;
2281
2282
    /* end of stream, so flush delayed pics */
2283
298
    if (buf_size == 0)
2284
36
        return get_delayed_pic(s, (AVFrame *)data, got_frame);
2285
2286
    for (;;) {
2287
        /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
2288
          [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
2289
          BBCD start code search */
2290
1019
        for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
2291

757
            if (buf[buf_idx  ] == 'B' && buf[buf_idx+1] == 'B' &&
2292

757
                buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
2293
757
                break;
2294
        }
2295
        /* BBCD found or end of data */
2296
1019
        if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
2297
262
            break;
2298
2299
757
        data_unit_size = AV_RB32(buf+buf_idx+5);
2300

757
        if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
2301
            if(data_unit_size > buf_size - buf_idx)
2302
            av_log(s->avctx, AV_LOG_ERROR,
2303
                   "Data unit with size %d is larger than input buffer, discarding\n",
2304
                   data_unit_size);
2305
            buf_idx += 4;
2306
            continue;
2307
        }
2308
        /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
2309
757
        ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size);
2310
757
        if (ret < 0)
2311
        {
2312
            av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
2313
            return ret;
2314
        }
2315
757
        buf_idx += data_unit_size;
2316
    }
2317
2318
262
    if (!s->current_picture)
2319
2
        return buf_size;
2320
2321
260
    if (s->current_picture->avframe->display_picture_number > s->frame_number) {
2322
8
        DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
2323
2324
8
        s->current_picture->reference |= DELAYED_PIC_REF;
2325
2326
8
        if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
2327
            int min_num = s->delay_frames[0]->avframe->display_picture_number;
2328
            /* Too many delayed frames, so we display the frame with the lowest pts */
2329
            av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
2330
2331
            for (i = 1; s->delay_frames[i]; i++)
2332
                if (s->delay_frames[i]->avframe->display_picture_number < min_num)
2333
                    min_num = s->delay_frames[i]->avframe->display_picture_number;
2334
2335
            delayed_frame = remove_frame(s->delay_frames, min_num);
2336
            add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
2337
        }
2338
2339
8
        if (delayed_frame) {
2340
7
            delayed_frame->reference ^= DELAYED_PIC_REF;
2341
7
            if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
2342
                return ret;
2343
7
            *got_frame = 1;
2344
        }
2345
252
    } else if (s->current_picture->avframe->display_picture_number == s->frame_number) {
2346
        /* The right frame at the right time :-) */
2347
252
        if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
2348
            return ret;
2349
252
        *got_frame = 1;
2350
    }
2351
2352
260
    if (*got_frame)
2353
259
        s->frame_number = picture->display_picture_number + 1LL;
2354
2355
260
    return buf_idx;
2356
}
2357
2358
AVCodec ff_dirac_decoder = {
2359
    .name           = "dirac",
2360
    .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
2361
    .type           = AVMEDIA_TYPE_VIDEO,
2362
    .id             = AV_CODEC_ID_DIRAC,
2363
    .priv_data_size = sizeof(DiracContext),
2364
    .init           = dirac_decode_init,
2365
    .close          = dirac_decode_end,
2366
    .decode         = dirac_decode_frame,
2367
    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DR1,
2368
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
2369
    .flush          = dirac_decode_flush,
2370
};