2
* Copyright (C) 2007 Marco Gerards <marco@gnu.org>
3
* Copyright (C) 2009 David Conrad
4
* Copyright (C) 2011 Jordi Ortiz
6
* This file is part of FFmpeg.
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.
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.
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
26
* @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
31
#include "bytestream.h"
34
#include "dirac_arith.h"
35
#include "mpeg12data.h"
36
#include "libavcodec/mpegvideo.h"
37
#include "mpegvideoencdsp.h"
38
#include "dirac_dwt.h"
44
* The spec limits the number of wavelet decompositions to 4 for both
45
* level 1 (VC-2) and 128 (long-gop default).
46
* 5 decompositions is the maximum before >16-bit buffers are needed.
47
* Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
48
* the others to 4 decompositions (or 3 for the fidelity filter).
50
* We use this instead of MAX_DECOMPOSITIONS to save some memory.
52
#define MAX_DWT_LEVELS 5
55
* The spec limits this to 3 for frame coding, but in practice can be as high as 6
57
#define MAX_REFERENCE_FRAMES 8
58
#define MAX_DELAY 5 /* limit for main profile for frame coding (TODO: field coding) */
59
#define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
60
#define MAX_QUANT 68 /* max quant for VC-2 */
61
#define MAX_BLOCKSIZE 32 /* maximum xblen/yblen we support */
64
* DiracBlock->ref flags, if set then the block does MC from the given ref
66
#define DIRAC_REF_MASK_REF1 1
67
#define DIRAC_REF_MASK_REF2 2
68
#define DIRAC_REF_MASK_GLOBAL 4
71
* Value of Picture.reference when Picture is not a reference picture, but
72
* is held for delayed output.
74
#define DELAYED_PIC_REF 4
76
#define CALC_PADDING(size, depth) \
77
(((size + (1 << depth) - 1) >> depth) << depth)
79
#define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
83
int interpolated[3]; /* 1 if hpel[] is valid */
85
uint8_t *hpel_base[3][4];
92
} u; /* anonymous unions aren't in C99 :( */
96
typedef struct SubBand {
104
struct SubBand *parent;
108
const uint8_t *coeff_data;
111
typedef struct Plane {
120
IDWTELEM *idwt_buf_base;
126
/* block separation (block n+1 starts after this many pixels in block n) */
129
/* amount of overspill on each edge (half of the overlap between blocks) */
133
SubBand band[MAX_DWT_LEVELS][4];
136
typedef struct DiracContext {
137
AVCodecContext *avctx;
138
MpegvideoEncDSPContext mpvencdsp;
139
VideoDSPContext vdsp;
140
DiracDSPContext diracdsp;
142
dirac_source_params source;
143
int seen_sequence_header;
144
int frame_number; /* number of the next frame to display */
149
int zero_res; /* zero residue flag */
150
int is_arith; /* whether coeffs use arith or golomb coding */
151
int low_delay; /* use the low delay syntax */
152
int globalmc_flag; /* use global motion compensation */
153
int num_refs; /* number of reference pictures */
155
/* wavelet decoding */
156
unsigned wavelet_depth; /* depth of the IDWT */
157
unsigned wavelet_idx;
160
* schroedinger older than 1.0.8 doesn't store
161
* quant delta if only one codebook exists in a band
163
unsigned old_delta_quant;
164
unsigned codeblock_mode;
169
} codeblock[MAX_DWT_LEVELS+1];
172
unsigned num_x; /* number of horizontal slices */
173
unsigned num_y; /* number of vertical slices */
174
AVRational bytes; /* average bytes per slice */
175
uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
179
int pan_tilt[2]; /* pan/tilt vector */
180
int zrs[2][2]; /* zoom/rotate/shear matrix */
181
int perspective[2]; /* perspective vector */
183
unsigned perspective_exp;
186
/* motion compensation */
187
uint8_t mv_precision; /* [DIRAC_STD] REFS_WT_PRECISION */
188
int16_t weight[2]; /* [DIRAC_STD] REF1_WT and REF2_WT */
189
unsigned weight_log2denom; /* [DIRAC_STD] REFS_WT_PRECISION */
191
int blwidth; /* number of blocks (horizontally) */
192
int blheight; /* number of blocks (vertically) */
193
int sbwidth; /* number of superblocks (horizontally) */
194
int sbheight; /* number of superblocks (vertically) */
197
DiracBlock *blmotion;
199
uint8_t *edge_emu_buffer[4];
200
uint8_t *edge_emu_buffer_base;
202
uint16_t *mctmp; /* buffer holding the MC data multiplied by OBMC weights */
206
DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
208
void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
209
void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
210
void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
211
dirac_weight_func weight_func;
212
dirac_biweight_func biweight_func;
214
DiracFrame *current_picture;
215
DiracFrame *ref_pics[2];
217
DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
218
DiracFrame *delay_frames[MAX_DELAY+1];
219
DiracFrame all_frames[MAX_FRAMES];
223
* Dirac Specification ->
224
* Parse code values. 9.6.1 Table 9.1
226
enum dirac_parse_code {
227
pc_seq_header = 0x00,
241
static const uint8_t default_qmat[][4][4] = {
242
{ { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
243
{ { 4, 2, 2, 0}, { 0, 4, 4, 2}, { 0, 5, 5, 3}, { 0, 7, 7, 5} },
244
{ { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
245
{ { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
246
{ { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
247
{ { 0, 4, 4, 8}, { 0, 8, 8, 12}, { 0, 13, 13, 17}, { 0, 17, 17, 21} },
248
{ { 3, 1, 1, 0}, { 0, 4, 4, 2}, { 0, 6, 6, 5}, { 0, 9, 9, 7} },
251
static const int qscale_tab[MAX_QUANT+1] = {
252
4, 5, 6, 7, 8, 10, 11, 13,
253
16, 19, 23, 27, 32, 38, 45, 54,
254
64, 76, 91, 108, 128, 152, 181, 215,
255
256, 304, 362, 431, 512, 609, 724, 861,
256
1024, 1218, 1448, 1722, 2048, 2435, 2896, 3444,
257
4096, 4871, 5793, 6889, 8192, 9742, 11585, 13777,
258
16384, 19484, 23170, 27554, 32768, 38968, 46341, 55109,
262
static const int qoffset_intra_tab[MAX_QUANT+1] = {
263
1, 2, 3, 4, 4, 5, 6, 7,
264
8, 10, 12, 14, 16, 19, 23, 27,
265
32, 38, 46, 54, 64, 76, 91, 108,
266
128, 152, 181, 216, 256, 305, 362, 431,
267
512, 609, 724, 861, 1024, 1218, 1448, 1722,
268
2048, 2436, 2897, 3445, 4096, 4871, 5793, 6889,
269
8192, 9742, 11585, 13777, 16384, 19484, 23171, 27555,
273
static const int qoffset_inter_tab[MAX_QUANT+1] = {
274
1, 2, 2, 3, 3, 4, 4, 5,
275
6, 7, 9, 10, 12, 14, 17, 20,
276
24, 29, 34, 41, 48, 57, 68, 81,
277
96, 114, 136, 162, 192, 228, 272, 323,
278
384, 457, 543, 646, 768, 913, 1086, 1292,
279
1536, 1827, 2172, 2583, 3072, 3653, 4344, 5166,
280
6144, 7307, 8689, 10333, 12288, 14613, 17378, 20666,
284
/* magic number division by 3 from schroedinger */
285
static inline int divide3(int x)
287
return ((x+1)*21845 + 10922) >> 16;
290
static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
292
DiracFrame *remove_pic = NULL;
293
int i, remove_idx = -1;
295
for (i = 0; framelist[i]; i++)
296
if (framelist[i]->avframe->display_picture_number == picnum) {
297
remove_pic = framelist[i];
302
for (i = remove_idx; framelist[i]; i++)
303
framelist[i] = framelist[i+1];
308
static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
311
for (i = 0; i < maxframes; i++)
313
framelist[i] = frame;
319
static int alloc_sequence_buffers(DiracContext *s)
321
int sbwidth = DIVRNDUP(s->source.width, 4);
322
int sbheight = DIVRNDUP(s->source.height, 4);
323
int i, w, h, top_padding;
325
/* todo: think more about this / use or set Plane here */
326
for (i = 0; i < 3; i++) {
327
int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
328
int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
329
w = s->source.width >> (i ? s->chroma_x_shift : 0);
330
h = s->source.height >> (i ? s->chroma_y_shift : 0);
332
/* we allocate the max we support here since num decompositions can
333
* change from frame to frame. Stride is aligned to 16 for SIMD, and
334
* 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
335
* MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
337
top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
338
w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
339
h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
341
s->plane[i].idwt_buf_base = av_mallocz_array((w+max_xblen), h * sizeof(IDWTELEM));
342
s->plane[i].idwt_tmp = av_malloc_array((w+16), sizeof(IDWTELEM));
343
s->plane[i].idwt_buf = s->plane[i].idwt_buf_base + top_padding*w;
344
if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
345
return AVERROR(ENOMEM);
348
/* fixme: allocate using real stride here */
349
s->sbsplit = av_malloc_array(sbwidth, sbheight);
350
s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));
352
if (!s->sbsplit || !s->blmotion)
353
return AVERROR(ENOMEM);
357
static int alloc_buffers(DiracContext *s, int stride)
359
int w = s->source.width;
360
int h = s->source.height;
362
av_assert0(stride >= w);
365
if (s->buffer_stride >= stride)
367
s->buffer_stride = 0;
369
av_freep(&s->edge_emu_buffer_base);
370
memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));
372
av_freep(&s->mcscratch);
374
s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE);
376
s->mctmp = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
377
s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE);
379
if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)
380
return AVERROR(ENOMEM);
382
s->buffer_stride = stride;
386
static void free_sequence_buffers(DiracContext *s)
390
for (i = 0; i < MAX_FRAMES; i++) {
391
if (s->all_frames[i].avframe->data[0]) {
392
av_frame_unref(s->all_frames[i].avframe);
393
memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
396
for (j = 0; j < 3; j++)
397
for (k = 1; k < 4; k++)
398
av_freep(&s->all_frames[i].hpel_base[j][k]);
401
memset(s->ref_frames, 0, sizeof(s->ref_frames));
402
memset(s->delay_frames, 0, sizeof(s->delay_frames));
404
for (i = 0; i < 3; i++) {
405
av_freep(&s->plane[i].idwt_buf_base);
406
av_freep(&s->plane[i].idwt_tmp);
409
s->buffer_stride = 0;
410
av_freep(&s->sbsplit);
411
av_freep(&s->blmotion);
412
av_freep(&s->edge_emu_buffer_base);
415
av_freep(&s->mcscratch);
418
static av_cold int dirac_decode_init(AVCodecContext *avctx)
420
DiracContext *s = avctx->priv_data;
424
s->frame_number = -1;
426
ff_diracdsp_init(&s->diracdsp);
427
ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
428
ff_videodsp_init(&s->vdsp, 8);
430
for (i = 0; i < MAX_FRAMES; i++) {
431
s->all_frames[i].avframe = av_frame_alloc();
432
if (!s->all_frames[i].avframe) {
434
av_frame_free(&s->all_frames[--i].avframe);
435
return AVERROR(ENOMEM);
442
static void dirac_decode_flush(AVCodecContext *avctx)
444
DiracContext *s = avctx->priv_data;
445
free_sequence_buffers(s);
446
s->seen_sequence_header = 0;
447
s->frame_number = -1;
450
static av_cold int dirac_decode_end(AVCodecContext *avctx)
452
DiracContext *s = avctx->priv_data;
455
dirac_decode_flush(avctx);
456
for (i = 0; i < MAX_FRAMES; i++)
457
av_frame_free(&s->all_frames[i].avframe);
462
#define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
464
static inline void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset,
465
SubBand *b, IDWTELEM *buf, int x, int y)
469
int pred_ctx = CTX_ZPZN_F1;
471
/* Check if the parent subband has a 0 in the corresponding position */
473
pred_ctx += !!b->parent->ibuf[b->parent->stride * (y>>1) + (x>>1)] << 1;
475
if (b->orientation == subband_hl)
476
sign_pred = buf[-b->stride];
478
/* Determine if the pixel has only zeros in its neighbourhood */
480
pred_ctx += !(buf[-1] | buf[-b->stride] | buf[-1-b->stride]);
481
if (b->orientation == subband_lh)
484
pred_ctx += !buf[-b->stride];
487
coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA);
489
coeff = (coeff * qfactor + qoffset + 2) >> 2;
490
sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred));
491
coeff = (coeff ^ -sign) + sign;
496
static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
500
coeff = svq3_get_ue_golomb(gb);
502
coeff = (coeff * qfactor + qoffset + 2) >> 2;
503
sign = get_bits1(gb);
504
coeff = (coeff ^ -sign) + sign;
510
* Decode the coeffs in the rectangle defined by left, right, top, bottom
511
* [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
513
static inline void codeblock(DiracContext *s, SubBand *b,
514
GetBitContext *gb, DiracArith *c,
515
int left, int right, int top, int bottom,
516
int blockcnt_one, int is_arith)
518
int x, y, zero_block;
519
int qoffset, qfactor;
522
/* check for any coded coefficients in this codeblock */
525
zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
527
zero_block = get_bits1(gb);
533
if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
534
int quant = b->quant;
536
quant += dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
538
quant += dirac_get_se_golomb(gb);
540
av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
546
b->quant = FFMIN(b->quant, MAX_QUANT);
548
qfactor = qscale_tab[b->quant];
549
/* TODO: context pointer? */
551
qoffset = qoffset_intra_tab[b->quant];
553
qoffset = qoffset_inter_tab[b->quant];
555
buf = b->ibuf + top * b->stride;
556
for (y = top; y < bottom; y++) {
557
for (x = left; x < right; x++) {
558
/* [DIRAC_STD] 13.4.4 Subband coefficients. coeff_unpack() */
560
coeff_unpack_arith(c, qfactor, qoffset, b, buf+x, x, y);
562
buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
569
* Dirac Specification ->
570
* 13.3 intra_dc_prediction(band)
572
static inline void intra_dc_prediction(SubBand *b)
574
IDWTELEM *buf = b->ibuf;
577
for (x = 1; x < b->width; x++)
581
for (y = 1; y < b->height; y++) {
582
buf[0] += buf[-b->stride];
584
for (x = 1; x < b->width; x++) {
585
int pred = buf[x - 1] + buf[x - b->stride] + buf[x - b->stride-1];
586
buf[x] += divide3(pred);
593
* Dirac Specification ->
594
* 13.4.2 Non-skipped subbands. subband_coeffs()
596
static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
598
int cb_x, cb_y, left, right, top, bottom;
601
int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width;
602
int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
603
int blockcnt_one = (cb_width + cb_height) == 2;
608
init_get_bits8(&gb, b->coeff_data, b->length);
611
ff_dirac_init_arith_decoder(&c, &gb, b->length);
614
for (cb_y = 0; cb_y < cb_height; cb_y++) {
615
bottom = (b->height * (cb_y+1LL)) / cb_height;
617
for (cb_x = 0; cb_x < cb_width; cb_x++) {
618
right = (b->width * (cb_x+1LL)) / cb_width;
619
codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
625
if (b->orientation == subband_ll && s->num_refs == 0)
626
intra_dc_prediction(b);
629
static int decode_subband_arith(AVCodecContext *avctx, void *b)
631
DiracContext *s = avctx->priv_data;
632
decode_subband_internal(s, b, 1);
636
static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
638
DiracContext *s = avctx->priv_data;
640
decode_subband_internal(s, *b, 0);
645
* Dirac Specification ->
646
* [DIRAC_STD] 13.4.1 core_transform_data()
648
static void decode_component(DiracContext *s, int comp)
650
AVCodecContext *avctx = s->avctx;
651
SubBand *bands[3*MAX_DWT_LEVELS+1];
652
enum dirac_subband orientation;
653
int level, num_bands = 0;
655
/* Unpack all subbands at all levels. */
656
for (level = 0; level < s->wavelet_depth; level++) {
657
for (orientation = !!level; orientation < 4; orientation++) {
658
SubBand *b = &s->plane[comp].band[level][orientation];
659
bands[num_bands++] = b;
661
align_get_bits(&s->gb);
662
/* [DIRAC_STD] 13.4.2 subband() */
663
b->length = svq3_get_ue_golomb(&s->gb);
665
b->quant = svq3_get_ue_golomb(&s->gb);
666
align_get_bits(&s->gb);
667
b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
668
b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
669
skip_bits_long(&s->gb, b->length*8);
672
/* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
674
avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
675
NULL, 4-!!level, sizeof(SubBand));
677
/* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
679
avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
682
/* [DIRAC_STD] 13.5.5.2 Luma slice subband data. luma_slice_band(level,orient,sx,sy) --> if b2 == NULL */
683
/* [DIRAC_STD] 13.5.5.3 Chroma slice subband data. chroma_slice_band(level,orient,sx,sy) --> if b2 != NULL */
684
static void lowdelay_subband(DiracContext *s, GetBitContext *gb, int quant,
685
int slice_x, int slice_y, int bits_end,
686
SubBand *b1, SubBand *b2)
688
int left = b1->width * slice_x / s->lowdelay.num_x;
689
int right = b1->width *(slice_x+1) / s->lowdelay.num_x;
690
int top = b1->height * slice_y / s->lowdelay.num_y;
691
int bottom = b1->height *(slice_y+1) / s->lowdelay.num_y;
693
int qfactor = qscale_tab[FFMIN(quant, MAX_QUANT)];
694
int qoffset = qoffset_intra_tab[FFMIN(quant, MAX_QUANT)];
696
IDWTELEM *buf1 = b1->ibuf + top * b1->stride;
697
IDWTELEM *buf2 = b2 ? b2->ibuf + top * b2->stride : NULL;
699
/* we have to constantly check for overread since the spec explicitly
700
requires this, with the meaning that all remaining coeffs are set to 0 */
701
if (get_bits_count(gb) >= bits_end)
704
for (y = top; y < bottom; y++) {
705
for (x = left; x < right; x++) {
706
buf1[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
707
if (get_bits_count(gb) >= bits_end)
710
buf2[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
711
if (get_bits_count(gb) >= bits_end)
721
struct lowdelay_slice {
730
* Dirac Specification ->
731
* 13.5.2 Slices. slice(sx,sy)
733
static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
735
DiracContext *s = avctx->priv_data;
736
struct lowdelay_slice *slice = arg;
737
GetBitContext *gb = &slice->gb;
738
enum dirac_subband orientation;
739
int level, quant, chroma_bits, chroma_end;
741
int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */
742
int length_bits = av_log2(8 * slice->bytes)+1;
743
int luma_bits = get_bits_long(gb, length_bits);
744
int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
746
/* [DIRAC_STD] 13.5.5.2 luma_slice_band */
747
for (level = 0; level < s->wavelet_depth; level++)
748
for (orientation = !!level; orientation < 4; orientation++) {
749
quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
750
lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
751
&s->plane[0].band[level][orientation], NULL);
754
/* consume any unused bits from luma */
755
skip_bits_long(gb, get_bits_count(gb) - luma_end);
757
chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
758
chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
759
/* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
760
for (level = 0; level < s->wavelet_depth; level++)
761
for (orientation = !!level; orientation < 4; orientation++) {
762
quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
763
lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
764
&s->plane[1].band[level][orientation],
765
&s->plane[2].band[level][orientation]);
772
* Dirac Specification ->
773
* 13.5.1 low_delay_transform_data()
775
static int decode_lowdelay(DiracContext *s)
777
AVCodecContext *avctx = s->avctx;
778
int slice_x, slice_y, bytes, bufsize;
780
struct lowdelay_slice *slices;
783
slices = av_mallocz_array(s->lowdelay.num_x, s->lowdelay.num_y * sizeof(struct lowdelay_slice));
785
return AVERROR(ENOMEM);
787
align_get_bits(&s->gb);
788
/*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
789
buf = s->gb.buffer + get_bits_count(&s->gb)/8;
790
bufsize = get_bits_left(&s->gb);
792
for (slice_y = 0; bufsize > 0 && slice_y < s->lowdelay.num_y; slice_y++)
793
for (slice_x = 0; bufsize > 0 && slice_x < s->lowdelay.num_x; slice_x++) {
794
bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
795
- slice_num * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
797
slices[slice_num].bytes = bytes;
798
slices[slice_num].slice_x = slice_x;
799
slices[slice_num].slice_y = slice_y;
800
init_get_bits(&slices[slice_num].gb, buf, bufsize);
804
if (bufsize/8 >= bytes)
810
avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
811
sizeof(struct lowdelay_slice)); /* [DIRAC_STD] 13.5.2 Slices */
812
intra_dc_prediction(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
813
intra_dc_prediction(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
814
intra_dc_prediction(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
819
static void init_planes(DiracContext *s)
821
int i, w, h, level, orientation;
823
for (i = 0; i < 3; i++) {
824
Plane *p = &s->plane[i];
826
p->width = s->source.width >> (i ? s->chroma_x_shift : 0);
827
p->height = s->source.height >> (i ? s->chroma_y_shift : 0);
828
p->idwt_width = w = CALC_PADDING(p->width , s->wavelet_depth);
829
p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
830
p->idwt_stride = FFALIGN(p->idwt_width, 8);
832
for (level = s->wavelet_depth-1; level >= 0; level--) {
835
for (orientation = !!level; orientation < 4; orientation++) {
836
SubBand *b = &p->band[level][orientation];
838
b->ibuf = p->idwt_buf;
840
b->stride = p->idwt_stride << (s->wavelet_depth - level);
843
b->orientation = orientation;
848
b->ibuf += b->stride>>1;
851
b->parent = &p->band[level-1][orientation];
856
p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
857
p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
858
p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
859
p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
862
p->xoffset = (p->xblen - p->xbsep)/2;
863
p->yoffset = (p->yblen - p->ybsep)/2;
868
* Unpack the motion compensation parameters
869
* Dirac Specification ->
870
* 11.2 Picture prediction data. picture_prediction()
872
static int dirac_unpack_prediction_parameters(DiracContext *s)
874
static const uint8_t default_blen[] = { 4, 12, 16, 24 };
876
GetBitContext *gb = &s->gb;
880
/* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
881
/* Luma and Chroma are equal. 11.2.3 */
882
idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
885
av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
886
return AVERROR_INVALIDDATA;
890
s->plane[0].xblen = svq3_get_ue_golomb(gb);
891
s->plane[0].yblen = svq3_get_ue_golomb(gb);
892
s->plane[0].xbsep = svq3_get_ue_golomb(gb);
893
s->plane[0].ybsep = svq3_get_ue_golomb(gb);
895
/*[DIRAC_STD] preset_block_params(index). Table 11.1 */
896
s->plane[0].xblen = default_blen[idx-1];
897
s->plane[0].yblen = default_blen[idx-1];
898
s->plane[0].xbsep = 4 * idx;
899
s->plane[0].ybsep = 4 * idx;
901
/*[DIRAC_STD] 11.2.4 motion_data_dimensions()
902
Calculated in function dirac_unpack_block_motion_data */
904
if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
905
s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
906
!s->plane[0].xblen || !s->plane[0].yblen) {
907
av_log(s->avctx, AV_LOG_ERROR,
908
"invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
909
s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
910
return AVERROR_INVALIDDATA;
912
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) {
913
av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
914
return AVERROR_INVALIDDATA;
916
if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
917
av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
918
return AVERROR_INVALIDDATA;
920
if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
921
av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
922
return AVERROR_PATCHWELCOME;
925
/*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
926
Read motion vector precision */
927
s->mv_precision = svq3_get_ue_golomb(gb);
928
if (s->mv_precision > 3) {
929
av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
930
return AVERROR_INVALIDDATA;
933
/*[DIRAC_STD] 11.2.6 Global motion. global_motion()
934
Read the global motion compensation parameters */
935
s->globalmc_flag = get_bits1(gb);
936
if (s->globalmc_flag) {
937
memset(s->globalmc, 0, sizeof(s->globalmc));
938
/* [DIRAC_STD] pan_tilt(gparams) */
939
for (ref = 0; ref < s->num_refs; ref++) {
941
s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
942
s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
944
/* [DIRAC_STD] zoom_rotate_shear(gparams)
945
zoom/rotation/shear parameters */
947
s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
948
s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
949
s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
950
s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
951
s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
953
s->globalmc[ref].zrs[0][0] = 1;
954
s->globalmc[ref].zrs[1][1] = 1;
956
/* [DIRAC_STD] perspective(gparams) */
958
s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
959
s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
960
s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
965
/*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
966
Picture prediction mode, not currently used. */
967
if (svq3_get_ue_golomb(gb)) {
968
av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
969
return AVERROR_INVALIDDATA;
972
/* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
973
just data read, weight calculation will be done later on. */
974
s->weight_log2denom = 1;
979
s->weight_log2denom = svq3_get_ue_golomb(gb);
980
s->weight[0] = dirac_get_se_golomb(gb);
981
if (s->num_refs == 2)
982
s->weight[1] = dirac_get_se_golomb(gb);
988
* Dirac Specification ->
989
* 11.3 Wavelet transform data. wavelet_transform()
991
static int dirac_unpack_idwt_params(DiracContext *s)
993
GetBitContext *gb = &s->gb;
997
#define CHECKEDREAD(dst, cond, errmsg) \
998
tmp = svq3_get_ue_golomb(gb); \
1000
av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1001
return AVERROR_INVALIDDATA; \
1007
s->zero_res = s->num_refs ? get_bits1(gb) : 0;
1011
/*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
1012
CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
1014
CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
1016
if (!s->low_delay) {
1017
/* Codeblock parameters (core syntax only) */
1018
if (get_bits1(gb)) {
1019
for (i = 0; i <= s->wavelet_depth; i++) {
1020
CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n")
1021
CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n")
1024
CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
1026
for (i = 0; i <= s->wavelet_depth; i++)
1027
s->codeblock[i].width = s->codeblock[i].height = 1;
1029
/* Slice parameters + quantization matrix*/
1030
/*[DIRAC_STD] 11.3.4 Slice coding Parameters (low delay syntax only). slice_parameters() */
1031
s->lowdelay.num_x = svq3_get_ue_golomb(gb);
1032
s->lowdelay.num_y = svq3_get_ue_golomb(gb);
1033
s->lowdelay.bytes.num = svq3_get_ue_golomb(gb);
1034
s->lowdelay.bytes.den = svq3_get_ue_golomb(gb);
1036
if (s->lowdelay.bytes.den <= 0) {
1037
av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
1038
return AVERROR_INVALIDDATA;
1041
/* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1042
if (get_bits1(gb)) {
1043
av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1044
/* custom quantization matrix */
1045
s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
1046
for (level = 0; level < s->wavelet_depth; level++) {
1047
s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
1048
s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
1049
s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
1052
if (s->wavelet_depth > 4) {
1053
av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1054
return AVERROR_INVALIDDATA;
1056
/* default quantization matrix */
1057
for (level = 0; level < s->wavelet_depth; level++)
1058
for (i = 0; i < 4; i++) {
1059
s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1060
/* haar with no shift differs for different depths */
1061
if (s->wavelet_idx == 3)
1062
s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1069
static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1071
static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1078
return sbsplit[-stride];
1080
return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1083
static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1090
return block[-1].ref & refmask;
1092
return block[-stride].ref & refmask;
1094
/* return the majority */
1095
pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1096
return (pred >> 1) & refmask;
1099
static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1103
memset(block->u.dc, 0, sizeof(block->u.dc));
1105
if (x && !(block[-1].ref & 3)) {
1106
for (i = 0; i < 3; i++)
1107
block->u.dc[i] += block[-1].u.dc[i];
1111
if (y && !(block[-stride].ref & 3)) {
1112
for (i = 0; i < 3; i++)
1113
block->u.dc[i] += block[-stride].u.dc[i];
1117
if (x && y && !(block[-1-stride].ref & 3)) {
1118
for (i = 0; i < 3; i++)
1119
block->u.dc[i] += block[-1-stride].u.dc[i];
1124
for (i = 0; i < 3; i++)
1125
block->u.dc[i] = (block->u.dc[i]+1)>>1;
1126
} else if (n == 3) {
1127
for (i = 0; i < 3; i++)
1128
block->u.dc[i] = divide3(block->u.dc[i]);
1132
static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1135
int refmask = ref+1;
1136
int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */
1139
if (x && (block[-1].ref & mask) == refmask)
1140
pred[n++] = block[-1].u.mv[ref];
1142
if (y && (block[-stride].ref & mask) == refmask)
1143
pred[n++] = block[-stride].u.mv[ref];
1145
if (x && y && (block[-stride-1].ref & mask) == refmask)
1146
pred[n++] = block[-stride-1].u.mv[ref];
1150
block->u.mv[ref][0] = 0;
1151
block->u.mv[ref][1] = 0;
1154
block->u.mv[ref][0] = pred[0][0];
1155
block->u.mv[ref][1] = pred[0][1];
1158
block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1159
block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1162
block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1163
block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1168
static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1170
int ez = s->globalmc[ref].zrs_exp;
1171
int ep = s->globalmc[ref].perspective_exp;
1172
int (*A)[2] = s->globalmc[ref].zrs;
1173
int *b = s->globalmc[ref].pan_tilt;
1174
int *c = s->globalmc[ref].perspective;
1176
int m = (1<<ep) - (c[0]*x + c[1]*y);
1177
int mx = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1178
int my = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1180
block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1181
block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1184
static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
1185
int stride, int x, int y)
1189
block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1190
block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1192
if (s->num_refs == 2) {
1193
block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1194
block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1198
pred_block_dc(block, stride, x, y);
1199
for (i = 0; i < 3; i++)
1200
block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1204
if (s->globalmc_flag) {
1205
block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1206
block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1209
for (i = 0; i < s->num_refs; i++)
1210
if (block->ref & (i+1)) {
1211
if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1212
global_mv(s, block, x, y, i);
1214
pred_mv(block, stride, x, y, i);
1215
block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1216
block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1222
* Copies the current block to the other blocks covered by the current superblock split mode
1224
static void propagate_block_data(DiracBlock *block, int stride, int size)
1227
DiracBlock *dst = block;
1229
for (x = 1; x < size; x++)
1232
for (y = 1; y < size; y++) {
1234
for (x = 0; x < size; x++)
1240
* Dirac Specification ->
1241
* 12. Block motion data syntax
1243
static int dirac_unpack_block_motion_data(DiracContext *s)
1245
GetBitContext *gb = &s->gb;
1246
uint8_t *sbsplit = s->sbsplit;
1248
DiracArith arith[8];
1252
/* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1253
s->sbwidth = DIVRNDUP(s->source.width, 4*s->plane[0].xbsep);
1254
s->sbheight = DIVRNDUP(s->source.height, 4*s->plane[0].ybsep);
1255
s->blwidth = 4 * s->sbwidth;
1256
s->blheight = 4 * s->sbheight;
1258
/* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1259
decode superblock split modes */
1260
ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb)); /* svq3_get_ue_golomb(gb) is the length */
1261
for (y = 0; y < s->sbheight; y++) {
1262
for (x = 0; x < s->sbwidth; x++) {
1263
unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1265
return AVERROR_INVALIDDATA;
1266
sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1268
sbsplit += s->sbwidth;
1271
/* setup arith decoding */
1272
ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));
1273
for (i = 0; i < s->num_refs; i++) {
1274
ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1275
ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1277
for (i = 0; i < 3; i++)
1278
ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1280
for (y = 0; y < s->sbheight; y++)
1281
for (x = 0; x < s->sbwidth; x++) {
1282
int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1283
int step = 4 >> s->sbsplit[y * s->sbwidth + x];
1285
for (q = 0; q < blkcnt; q++)
1286
for (p = 0; p < blkcnt; p++) {
1287
int bx = 4 * x + p*step;
1288
int by = 4 * y + q*step;
1289
DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1290
decode_block_params(s, arith, block, s->blwidth, bx, by);
1291
propagate_block_data(block, s->blwidth, step);
1298
static int weight(int i, int blen, int offset)
1300
#define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1301
(1 + (6*(i) + offset - 1) / (2*offset - 1))
1305
else if (i > blen-1 - 2*offset)
1306
return ROLLOFF(blen-1 - i);
1310
static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1311
int left, int right, int wy)
1314
for (x = 0; left && x < p->xblen >> 1; x++)
1315
obmc_weight[x] = wy*8;
1316
for (; x < p->xblen >> right; x++)
1317
obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1318
for (; x < p->xblen; x++)
1319
obmc_weight[x] = wy*8;
1320
for (; x < stride; x++)
1324
static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1325
int left, int right, int top, int bottom)
1328
for (y = 0; top && y < p->yblen >> 1; y++) {
1329
init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1330
obmc_weight += stride;
1332
for (; y < p->yblen >> bottom; y++) {
1333
int wy = weight(y, p->yblen, p->yoffset);
1334
init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1335
obmc_weight += stride;
1337
for (; y < p->yblen; y++) {
1338
init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1339
obmc_weight += stride;
1343
static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1346
int bottom = by == s->blheight-1;
1348
/* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1349
if (top || bottom || by == 1) {
1350
init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1351
init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1352
init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1356
static const uint8_t epel_weights[4][4][4] = {
1376
* For block x,y, determine which of the hpel planes to do bilinear
1377
* interpolation from and set src[] to the location in each hpel plane
1380
* @return the index of the put_dirac_pixels_tab function to use
1381
* 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1383
static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
1384
int x, int y, int ref, int plane)
1386
Plane *p = &s->plane[plane];
1387
uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1388
int motion_x = block->u.mv[ref][0];
1389
int motion_y = block->u.mv[ref][1];
1390
int mx, my, i, epel, nplanes = 0;
1393
motion_x >>= s->chroma_x_shift;
1394
motion_y >>= s->chroma_y_shift;
1397
mx = motion_x & ~(-1U << s->mv_precision);
1398
my = motion_y & ~(-1U << s->mv_precision);
1399
motion_x >>= s->mv_precision;
1400
motion_y >>= s->mv_precision;
1401
/* normalize subpel coordinates to epel */
1402
/* TODO: template this function? */
1403
mx <<= 3 - s->mv_precision;
1404
my <<= 3 - s->mv_precision;
1413
src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1417
for (i = 0; i < 4; i++)
1418
src[i] = ref_hpel[i] + y*p->stride + x;
1420
/* if we're interpolating in the right/bottom halves, adjust the planes as needed
1421
we increment x/y because the edge changes for half of the pixels */
1428
src[0] += p->stride;
1429
src[1] += p->stride;
1437
/* check if we really only need 2 planes since either mx or my is
1438
a hpel position. (epel weights of 0 handle this there) */
1440
/* mx == 0: average [0] and [2]
1441
mx == 4: average [1] and [3] */
1442
src[!mx] = src[2 + !!mx];
1444
} else if (!(my&3)) {
1445
src[0] = src[(my>>1) ];
1446
src[1] = src[(my>>1)+1];
1450
/* adjust the ordering if needed so the weights work */
1452
FFSWAP(const uint8_t *, src[0], src[1]);
1453
FFSWAP(const uint8_t *, src[2], src[3]);
1456
FFSWAP(const uint8_t *, src[0], src[2]);
1457
FFSWAP(const uint8_t *, src[1], src[3]);
1459
src[4] = epel_weights[my&3][mx&3];
1463
/* fixme: v/h _edge_pos */
1464
if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1465
y + p->yblen > p->height+EDGE_WIDTH/2 ||
1467
for (i = 0; i < nplanes; i++) {
1468
s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1469
p->stride, p->stride,
1470
p->xblen, p->yblen, x, y,
1471
p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1472
src[i] = s->edge_emu_buffer[i];
1475
return (nplanes>>1) + epel;
1478
static void add_dc(uint16_t *dst, int dc, int stride,
1479
uint8_t *obmc_weight, int xblen, int yblen)
1484
for (y = 0; y < yblen; y++) {
1485
for (x = 0; x < xblen; x += 2) {
1486
dst[x ] += dc * obmc_weight[x ];
1487
dst[x+1] += dc * obmc_weight[x+1];
1490
obmc_weight += MAX_BLOCKSIZE;
1494
static void block_mc(DiracContext *s, DiracBlock *block,
1495
uint16_t *mctmp, uint8_t *obmc_weight,
1496
int plane, int dstx, int dsty)
1498
Plane *p = &s->plane[plane];
1499
const uint8_t *src[5];
1502
switch (block->ref&3) {
1504
add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1508
idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1509
s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1511
s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1512
s->weight[0] + s->weight[1], p->yblen);
1515
idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1516
s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1517
idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1518
if (s->biweight_func) {
1519
/* fixme: +32 is a quick hack */
1520
s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1521
s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1522
s->weight[0], s->weight[1], p->yblen);
1524
s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1527
s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1530
static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1532
Plane *p = &s->plane[plane];
1533
int x, dstx = p->xbsep - p->xoffset;
1535
block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1538
for (x = 1; x < s->blwidth-1; x++) {
1539
block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1543
block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1546
static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1554
memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1555
memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1556
s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1557
if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1558
s->weight_func = s->diracdsp.weight_dirac_pixels_tab[idx];
1559
s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1561
s->weight_func = NULL;
1562
s->biweight_func = NULL;
1566
static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1568
/* chroma allocates an edge of 8 when subsampled
1569
which for 4:2:2 means an h edge of 16 and v edge of 8
1570
just use 8 for everything for the moment */
1571
int i, edge = EDGE_WIDTH/2;
1573
ref->hpel[plane][0] = ref->avframe->data[plane];
1574
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 */
1576
/* no need for hpel if we only have fpel vectors */
1577
if (!s->mv_precision)
1580
for (i = 1; i < 4; i++) {
1581
if (!ref->hpel_base[plane][i])
1582
ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1583
if (!ref->hpel_base[plane][i]) {
1584
return AVERROR(ENOMEM);
1586
/* we need to be 16-byte aligned even for chroma */
1587
ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1590
if (!ref->interpolated[plane]) {
1591
s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1592
ref->hpel[plane][3], ref->hpel[plane][0],
1593
ref->avframe->linesize[plane], width, height);
1594
s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1595
s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1596
s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1598
ref->interpolated[plane] = 1;
1604
* Dirac Specification ->
1605
* 13.0 Transform data syntax. transform_data()
1607
static int dirac_decode_frame_internal(DiracContext *s)
1610
int y, i, comp, dsty;
1614
/* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1615
for (comp = 0; comp < 3; comp++) {
1616
Plane *p = &s->plane[comp];
1617
memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1620
if ((ret = decode_lowdelay(s)) < 0)
1625
for (comp = 0; comp < 3; comp++) {
1626
Plane *p = &s->plane[comp];
1627
uint8_t *frame = s->current_picture->avframe->data[comp];
1629
/* FIXME: small resolutions */
1630
for (i = 0; i < 4; i++)
1631
s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1633
if (!s->zero_res && !s->low_delay)
1635
memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1636
decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1638
ret = ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
1639
s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp);
1643
if (!s->num_refs) { /* intra */
1644
for (y = 0; y < p->height; y += 16) {
1645
ff_spatial_idwt_slice2(&d, y+16); /* decode */
1646
s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
1647
p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1649
} else { /* inter */
1650
int rowheight = p->ybsep*p->stride;
1652
select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1654
for (i = 0; i < s->num_refs; i++) {
1655
int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1660
memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1663
for (y = 0; y < s->blheight; y++) {
1665
start = FFMAX(dsty, 0);
1666
uint16_t *mctmp = s->mctmp + y*rowheight;
1667
DiracBlock *blocks = s->blmotion + y*s->blwidth;
1669
init_obmc_weights(s, p, y);
1671
if (y == s->blheight-1 || start+p->ybsep > p->height)
1672
h = p->height - start;
1674
h = p->ybsep - (start - dsty);
1678
memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1679
mc_row(s, blocks, mctmp, comp, dsty);
1681
mctmp += (start - dsty)*p->stride + p->xoffset;
1682
ff_spatial_idwt_slice2(&d, start + h); /* decode */
1683
s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1684
p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
1695
static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
1698
int chroma_x_shift, chroma_y_shift;
1699
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift, &chroma_y_shift);
1701
f->width = avctx->width + 2 * EDGE_WIDTH;
1702
f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1703
ret = ff_get_buffer(avctx, f, flags);
1707
for (i = 0; f->data[i]; i++) {
1708
int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1709
f->linesize[i] + 32;
1710
f->data[i] += offset;
1712
f->width = avctx->width;
1713
f->height = avctx->height;
1719
* Dirac Specification ->
1720
* 11.1.1 Picture Header. picture_header()
1722
static int dirac_decode_picture_header(DiracContext *s)
1724
unsigned retire, picnum;
1726
int64_t refdist, refnum;
1727
GetBitContext *gb = &s->gb;
1729
/* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1730
picnum = s->current_picture->avframe->display_picture_number = get_bits_long(gb, 32);
1733
av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1735
/* if this is the first keyframe after a sequence header, start our
1736
reordering from here */
1737
if (s->frame_number < 0)
1738
s->frame_number = picnum;
1740
s->ref_pics[0] = s->ref_pics[1] = NULL;
1741
for (i = 0; i < s->num_refs; i++) {
1742
refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1743
refdist = INT64_MAX;
1745
/* find the closest reference to the one we want */
1746
/* Jordi: this is needed if the referenced picture hasn't yet arrived */
1747
for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1748
if (s->ref_frames[j]
1749
&& FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
1750
s->ref_pics[i] = s->ref_frames[j];
1751
refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
1754
if (!s->ref_pics[i] || refdist)
1755
av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1757
/* if there were no references at all, allocate one */
1758
if (!s->ref_pics[i])
1759
for (j = 0; j < MAX_FRAMES; j++)
1760
if (!s->all_frames[j].avframe->data[0]) {
1761
s->ref_pics[i] = &s->all_frames[j];
1762
get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
1766
if (!s->ref_pics[i]) {
1767
av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
1768
return AVERROR_INVALIDDATA;
1773
/* retire the reference frames that are not used anymore */
1774
if (s->current_picture->avframe->reference) {
1775
retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1776
if (retire != picnum) {
1777
DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1780
retire_pic->avframe->reference &= DELAYED_PIC_REF;
1782
av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1785
/* if reference array is full, remove the oldest as per the spec */
1786
while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
1787
av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1788
remove_frame(s->ref_frames, s->ref_frames[0]->avframe->display_picture_number)->avframe->reference &= DELAYED_PIC_REF;
1793
ret = dirac_unpack_prediction_parameters(s); /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1796
ret = dirac_unpack_block_motion_data(s); /* [DIRAC_STD] 12. Block motion data syntax */
1800
ret = dirac_unpack_idwt_params(s); /* [DIRAC_STD] 11.3 Wavelet transform data */
1808
static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
1810
DiracFrame *out = s->delay_frames[0];
1814
/* find frame with lowest picture number */
1815
for (i = 1; s->delay_frames[i]; i++)
1816
if (s->delay_frames[i]->avframe->display_picture_number < out->avframe->display_picture_number) {
1817
out = s->delay_frames[i];
1821
for (i = out_idx; s->delay_frames[i]; i++)
1822
s->delay_frames[i] = s->delay_frames[i+1];
1825
out->avframe->reference ^= DELAYED_PIC_REF;
1827
if((ret = av_frame_ref(picture, out->avframe)) < 0)
1835
* Dirac Specification ->
1836
* 9.6 Parse Info Header Syntax. parse_info()
1837
* 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1839
#define DATA_UNIT_HEADER_SIZE 13
1841
/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1842
inside the function parse_sequence() */
1843
static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1845
DiracContext *s = avctx->priv_data;
1846
DiracFrame *pic = NULL;
1847
int ret, i, parse_code;
1850
if (size < DATA_UNIT_HEADER_SIZE)
1851
return AVERROR_INVALIDDATA;
1853
parse_code = buf[4];
1855
init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1857
if (parse_code == pc_seq_header) {
1858
if (s->seen_sequence_header)
1861
/* [DIRAC_STD] 10. Sequence header */
1862
ret = avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source);
1866
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1868
ret = alloc_sequence_buffers(s);
1872
s->seen_sequence_header = 1;
1873
} else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
1874
free_sequence_buffers(s);
1875
s->seen_sequence_header = 0;
1876
} else if (parse_code == pc_aux_data) {
1877
if (buf[13] == 1) { /* encoder implementation/version */
1879
/* versions older than 1.0.8 don't store quant delta for
1880
subbands with only one codeblock */
1881
if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
1882
if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
1883
s->old_delta_quant = 1;
1885
} else if (parse_code & 0x8) { /* picture data unit */
1886
if (!s->seen_sequence_header) {
1887
av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
1888
return AVERROR_INVALIDDATA;
1891
/* find an unused frame */
1892
for (i = 0; i < MAX_FRAMES; i++)
1893
if (s->all_frames[i].avframe->data[0] == NULL)
1894
pic = &s->all_frames[i];
1896
av_log(avctx, AV_LOG_ERROR, "framelist full\n");
1897
return AVERROR_INVALIDDATA;
1900
av_frame_unref(pic->avframe);
1902
/* [DIRAC_STD] Defined in 9.6.1 ... */
1903
tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */
1905
av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
1906
return AVERROR_INVALIDDATA;
1909
s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */
1910
s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */
1911
pic->avframe->reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */
1912
pic->avframe->key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */
1913
pic->avframe->pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */
1915
if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
1917
s->current_picture = pic;
1918
s->plane[0].stride = pic->avframe->linesize[0];
1919
s->plane[1].stride = pic->avframe->linesize[1];
1920
s->plane[2].stride = pic->avframe->linesize[2];
1922
if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)
1923
return AVERROR(ENOMEM);
1925
/* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
1926
ret = dirac_decode_picture_header(s);
1930
/* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
1931
ret = dirac_decode_frame_internal(s);
1938
static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1940
DiracContext *s = avctx->priv_data;
1941
AVFrame *picture = data;
1942
uint8_t *buf = pkt->data;
1943
int buf_size = pkt->size;
1946
unsigned data_unit_size;
1948
/* release unused frames */
1949
for (i = 0; i < MAX_FRAMES; i++)
1950
if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].avframe->reference) {
1951
av_frame_unref(s->all_frames[i].avframe);
1952
memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
1955
s->current_picture = NULL;
1958
/* end of stream, so flush delayed pics */
1960
return get_delayed_pic(s, (AVFrame *)data, got_frame);
1963
/*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
1964
[DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
1965
BBCD start code search */
1966
for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
1967
if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' &&
1968
buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
1971
/* BBCD found or end of data */
1972
if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
1975
data_unit_size = AV_RB32(buf+buf_idx+5);
1976
if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
1977
if(data_unit_size > buf_size - buf_idx)
1978
av_log(s->avctx, AV_LOG_ERROR,
1979
"Data unit with size %d is larger than input buffer, discarding\n",
1984
/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
1985
ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size);
1988
av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
1991
buf_idx += data_unit_size;
1994
if (!s->current_picture)
1997
if (s->current_picture->avframe->display_picture_number > s->frame_number) {
1998
DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
2000
s->current_picture->avframe->reference |= DELAYED_PIC_REF;
2002
if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
2003
int min_num = s->delay_frames[0]->avframe->display_picture_number;
2004
/* Too many delayed frames, so we display the frame with the lowest pts */
2005
av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
2007
for (i = 1; s->delay_frames[i]; i++)
2008
if (s->delay_frames[i]->avframe->display_picture_number < min_num)
2009
min_num = s->delay_frames[i]->avframe->display_picture_number;
2011
delayed_frame = remove_frame(s->delay_frames, min_num);
2012
add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
2015
if (delayed_frame) {
2016
delayed_frame->avframe->reference ^= DELAYED_PIC_REF;
2017
if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
2021
} else if (s->current_picture->avframe->display_picture_number == s->frame_number) {
2022
/* The right frame at the right time :-) */
2023
if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
2029
s->frame_number = picture->display_picture_number + 1;
2034
AVCodec ff_dirac_decoder = {
2036
.long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
2037
.type = AVMEDIA_TYPE_VIDEO,
2038
.id = AV_CODEC_ID_DIRAC,
2039
.priv_data_size = sizeof(DiracContext),
2040
.init = dirac_decode_init,
2041
.close = dirac_decode_end,
2042
.decode = dirac_decode_frame,
2043
.capabilities = CODEC_CAP_DELAY,
2044
.flush = dirac_decode_flush,
added
removed
ffmpeg/libavcodec/diracdec.c
