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

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

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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


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) {
1143
        av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
1144
        return AVERROR_INVALIDDATA;
1145
    }
1146

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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