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 255 /* 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];
93 } u; /* anonymous unions aren't in C99 :( */
97 typedef struct SubBand {
100 int stride; /* in bytes */
106 struct SubBand *parent;
110 const uint8_t *coeff_data;
113 typedef struct Plane {
122 uint8_t *idwt_buf_base;
128 /* block separation (block n+1 starts after this many pixels in block n) */
131 /* amount of overspill on each edge (half of the overlap between blocks) */
135 SubBand band[MAX_DWT_LEVELS][4];
138 typedef struct DiracContext {
139 AVCodecContext *avctx;
140 MpegvideoEncDSPContext mpvencdsp;
141 VideoDSPContext vdsp;
142 DiracDSPContext diracdsp;
143 DiracVersionInfo version;
145 AVDiracSeqHeader seq;
146 int seen_sequence_header;
147 int frame_number; /* number of the next frame to display */
152 int bit_depth; /* bit depth */
153 int pshift; /* pixel shift = bit_depth > 8 */
155 int zero_res; /* zero residue flag */
156 int is_arith; /* whether coeffs use arith or golomb coding */
157 int core_syntax; /* use core syntax only */
158 int low_delay; /* use the low delay syntax */
159 int hq_picture; /* high quality picture, enables low_delay */
160 int ld_picture; /* use low delay picture, turns on low_delay */
161 int dc_prediction; /* has dc prediction */
162 int globalmc_flag; /* use global motion compensation */
163 int num_refs; /* number of reference pictures */
165 /* wavelet decoding */
166 unsigned wavelet_depth; /* depth of the IDWT */
167 unsigned wavelet_idx;
170 * schroedinger older than 1.0.8 doesn't store
171 * quant delta if only one codebook exists in a band
173 unsigned old_delta_quant;
174 unsigned codeblock_mode;
176 unsigned num_x; /* number of horizontal slices */
177 unsigned num_y; /* number of vertical slices */
182 } codeblock[MAX_DWT_LEVELS+1];
185 AVRational bytes; /* average bytes per slice */
186 uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
190 unsigned prefix_bytes;
191 unsigned size_scaler;
195 int pan_tilt[2]; /* pan/tilt vector */
196 int zrs[2][2]; /* zoom/rotate/shear matrix */
197 int perspective[2]; /* perspective vector */
199 unsigned perspective_exp;
202 /* motion compensation */
203 uint8_t mv_precision; /* [DIRAC_STD] REFS_WT_PRECISION */
204 int16_t weight[2]; /* [DIRAC_STD] REF1_WT and REF2_WT */
205 unsigned weight_log2denom; /* [DIRAC_STD] REFS_WT_PRECISION */
207 int blwidth; /* number of blocks (horizontally) */
208 int blheight; /* number of blocks (vertically) */
209 int sbwidth; /* number of superblocks (horizontally) */
210 int sbheight; /* number of superblocks (vertically) */
213 DiracBlock *blmotion;
215 uint8_t *edge_emu_buffer[4];
216 uint8_t *edge_emu_buffer_base;
218 uint16_t *mctmp; /* buffer holding the MC data multiplied by OBMC weights */
222 DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
224 void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
225 void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
226 void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
227 dirac_weight_func weight_func;
228 dirac_biweight_func biweight_func;
230 DiracFrame *current_picture;
231 DiracFrame *ref_pics[2];
233 DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
234 DiracFrame *delay_frames[MAX_DELAY+1];
235 DiracFrame all_frames[MAX_FRAMES];
246 static const uint8_t default_qmat[][4][4] = {
247 { { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
248 { { 4, 2, 2, 0}, { 0, 4, 4, 2}, { 0, 5, 5, 3}, { 0, 7, 7, 5} },
249 { { 5, 3, 3, 0}, { 0, 4, 4, 1}, { 0, 5, 5, 2}, { 0, 6, 6, 3} },
250 { { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
251 { { 8, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0}, { 0, 4, 4, 0} },
252 { { 0, 4, 4, 8}, { 0, 8, 8, 12}, { 0, 13, 13, 17}, { 0, 17, 17, 21} },
253 { { 3, 1, 1, 0}, { 0, 4, 4, 2}, { 0, 6, 6, 5}, { 0, 9, 9, 7} },
256 static const int32_t qscale_tab[116] = {
257 4, 5, 6, 7, 8, 10, 11, 13,
258 16, 19, 23, 27, 32, 38, 45, 54,
259 64, 76, 91, 108, 128, 152, 181, 215,
260 256, 304, 362, 431, 512, 609, 724, 861,
261 1024, 1218, 1448, 1722, 2048, 2435, 2896, 3444,
262 4096, 4871, 5793, 6889, 8192, 9742, 11585, 13777,
263 16384, 19484, 23170, 27554, 32768, 38968, 46341, 55109,
264 65536, 77936, 92682, 110218, 131072, 155872, 185364, 220436,
265 262144, 311744, 370728, 440872, 524288, 623487, 741455, 881744,
266 1048576, 1246974, 1482910, 1763488, 2097152, 2493948, 2965821, 3526975,
267 4194304, 4987896, 5931642, 7053950, 8388608, 9975792, 11863283, 14107901,
268 16777216, 19951585, 23726566, 28215802, 33554432, 39903169, 47453133, 56431603,
269 67108864, 79806339, 94906266, 112863206, 134217728, 159612677, 189812531, 225726413,
270 268435456, 319225354, 379625062, 451452825, 536870912, 638450708, 759250125, 902905651,
271 1073741824,1276901417,1518500250,1805811301,/*2147483648,2553802834,3037000500,3611622603,
275 static const int32_t qoffset_intra_tab[120] = {
276 1, 2, 3, 4, 4, 5, 6, 7,
277 8, 10, 12, 14, 16, 19, 23, 27,
278 32, 38, 46, 54, 64, 76, 91, 108,
279 128, 152, 181, 216, 256, 305, 362, 431,
280 512, 609, 724, 861, 1024, 1218, 1448, 1722,
281 2048, 2436, 2897, 3445, 4096, 4871, 5793, 6889,
282 8192, 9742, 11585, 13777, 16384, 19484, 23171, 27555,
283 32768, 38968, 46341, 55109, 65536, 77936, 92682, 110218,
284 131072, 155872, 185364, 220436, 262144, 311744, 370728, 440872,
285 524288, 623487, 741455, 881744, 1048576, 1246974, 1482911, 1763488,
286 2097152, 2493948, 2965821, 3526975, 4194304, 4987896, 5931642, 7053951,
287 8388608, 9975793, 11863283, 14107901, 16777216, 19951585, 23726567, 28215802,
288 33554432, 39903170, 47453133, 56431603, 67108864, 79806339, 94906266, 112863207,
289 134217728, 159612677, 189812531, 225726413, 268435456, 319225354, 379625063, 451452826,
290 536870912, 638450709, 759250125, 902905651,1073741824,1276901417,1518500250,1805811302,
291 /*2147483648, 2553802834, 3037000500, 3611622603, 4294967296,*/
294 static const int qoffset_inter_tab[122] = {
295 1, 2, 2, 3, 3, 4, 4, 5,
296 6, 7, 9, 10, 12, 14, 17, 20,
297 24, 29, 34, 41, 48, 57, 68, 81,
298 96, 114, 136, 162, 192, 228, 272, 323,
299 384, 457, 543, 646, 768, 913, 1086, 1292,
300 1536, 1827, 2172, 2583, 3072, 3653, 4344, 5166,
301 6144, 7307, 8689, 10333, 12288, 14613, 17378, 20666,
302 24576, 29226, 34756, 41332, 49152, 58452, 69512, 82664,
303 98304, 116904, 139023, 165327, 196608, 233808, 278046, 330654,
304 393216, 467615, 556091, 661308, 786432, 935231, 1112183, 1322616,
305 1572864, 1870461, 2224366, 2645231, 3145728, 3740922, 4448731, 5290463,
306 6291456, 7481844, 8897462, 10580926, 12582912, 14963688, 17794925, 21161851,
307 25165824, 29927377, 35589850, 42323702, 50331648, 59854754, 71179699, 84647405,
308 100663296, 119709508, 142359398, 169294809, 201326592, 239419016, 284718797, 338589619,
309 402653184, 478838031, 569437594, 677179238, 805306368, 957676063,1138875188,1354358476,
310 1610612736, 1915352125, /*2277750375, 2708716952, 3221225472, 3830704250,*/
313 /* magic number division by 3 from schroedinger */
314 static inline int divide3(int x)
316 return ((x+1)*21845 + 10922) >> 16;
319 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
321 DiracFrame *remove_pic = NULL;
322 int i, remove_idx = -1;
324 for (i = 0; framelist[i]; i++)
325 if (framelist[i]->avframe->display_picture_number == picnum) {
326 remove_pic = framelist[i];
331 for (i = remove_idx; framelist[i]; i++)
332 framelist[i] = framelist[i+1];
337 static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
340 for (i = 0; i < maxframes; i++)
342 framelist[i] = frame;
348 static int alloc_sequence_buffers(DiracContext *s)
350 int sbwidth = DIVRNDUP(s->seq.width, 4);
351 int sbheight = DIVRNDUP(s->seq.height, 4);
352 int i, w, h, top_padding;
354 /* todo: think more about this / use or set Plane here */
355 for (i = 0; i < 3; i++) {
356 int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
357 int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
358 w = s->seq.width >> (i ? s->chroma_x_shift : 0);
359 h = s->seq.height >> (i ? s->chroma_y_shift : 0);
361 /* we allocate the max we support here since num decompositions can
362 * change from frame to frame. Stride is aligned to 16 for SIMD, and
363 * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
364 * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
366 top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
367 w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
368 h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
370 s->plane[i].idwt_buf_base = av_mallocz_array((w+max_xblen), h * (2 << s->pshift));
371 s->plane[i].idwt_tmp = av_malloc_array((w+16), 2 << s->pshift);
372 s->plane[i].idwt_buf = s->plane[i].idwt_buf_base + (top_padding*w)*(2 << s->pshift);
373 if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
374 return AVERROR(ENOMEM);
377 /* fixme: allocate using real stride here */
378 s->sbsplit = av_malloc_array(sbwidth, sbheight);
379 s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));
381 if (!s->sbsplit || !s->blmotion)
382 return AVERROR(ENOMEM);
386 static int alloc_buffers(DiracContext *s, int stride)
388 int w = s->seq.width;
389 int h = s->seq.height;
391 av_assert0(stride >= w);
394 if (s->buffer_stride >= stride)
396 s->buffer_stride = 0;
398 av_freep(&s->edge_emu_buffer_base);
399 memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));
401 av_freep(&s->mcscratch);
403 s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE);
405 s->mctmp = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
406 s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE);
408 if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)
409 return AVERROR(ENOMEM);
411 s->buffer_stride = stride;
415 static void free_sequence_buffers(DiracContext *s)
419 for (i = 0; i < MAX_FRAMES; i++) {
420 if (s->all_frames[i].avframe->data[0]) {
421 av_frame_unref(s->all_frames[i].avframe);
422 memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
425 for (j = 0; j < 3; j++)
426 for (k = 1; k < 4; k++)
427 av_freep(&s->all_frames[i].hpel_base[j][k]);
430 memset(s->ref_frames, 0, sizeof(s->ref_frames));
431 memset(s->delay_frames, 0, sizeof(s->delay_frames));
433 for (i = 0; i < 3; i++) {
434 av_freep(&s->plane[i].idwt_buf_base);
435 av_freep(&s->plane[i].idwt_tmp);
438 s->buffer_stride = 0;
439 av_freep(&s->sbsplit);
440 av_freep(&s->blmotion);
441 av_freep(&s->edge_emu_buffer_base);
444 av_freep(&s->mcscratch);
447 static av_cold int dirac_decode_init(AVCodecContext *avctx)
449 DiracContext *s = avctx->priv_data;
453 s->frame_number = -1;
455 ff_diracdsp_init(&s->diracdsp);
456 ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
457 ff_videodsp_init(&s->vdsp, 8);
459 for (i = 0; i < MAX_FRAMES; i++) {
460 s->all_frames[i].avframe = av_frame_alloc();
461 if (!s->all_frames[i].avframe) {
463 av_frame_free(&s->all_frames[--i].avframe);
464 return AVERROR(ENOMEM);
471 static void dirac_decode_flush(AVCodecContext *avctx)
473 DiracContext *s = avctx->priv_data;
474 free_sequence_buffers(s);
475 s->seen_sequence_header = 0;
476 s->frame_number = -1;
479 static av_cold int dirac_decode_end(AVCodecContext *avctx)
481 DiracContext *s = avctx->priv_data;
484 dirac_decode_flush(avctx);
485 for (i = 0; i < MAX_FRAMES; i++)
486 av_frame_free(&s->all_frames[i].avframe);
491 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
493 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
499 UPDATE_CACHE(re, gb);
500 buf = GET_CACHE(re, gb);
502 if (buf & 0x80000000) {
503 LAST_SKIP_BITS(re,gb,1);
504 CLOSE_READER(re, gb);
508 if (buf & 0xAA800000) {
510 SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
512 coeff = ff_interleaved_ue_golomb_vlc_code[buf];
519 FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
521 if (ff_interleaved_golomb_vlc_len[buf] != 9) {
522 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
523 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
526 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
527 UPDATE_CACHE(re, gb);
528 buf = GET_CACHE(re, gb);
529 } while (ret<0x8000000U && BITS_AVAILABLE(re, gb));
534 coeff = (coeff * qfactor + qoffset) >> 2;
535 sign = SHOW_SBITS(re, gb, 1);
536 LAST_SKIP_BITS(re, gb, 1);
537 coeff = (coeff ^ sign) - sign;
539 CLOSE_READER(re, gb);
543 #define UNPACK_ARITH(n, type) \
544 static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
545 SubBand *b, type *buf, int x, int y) \
547 int coeff, sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
548 const int mstride = -(b->stride >> (1+b->pshift)); \
550 const type *pbuf = (type *)b->parent->ibuf; \
551 const int stride = b->parent->stride >> (1+b->parent->pshift); \
552 pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \
554 if (b->orientation == subband_hl) \
555 sign_pred = buf[mstride]; \
557 pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \
558 if (b->orientation == subband_lh) \
559 sign_pred = buf[-1]; \
561 pred_ctx += !buf[mstride]; \
563 coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \
565 coeff = (coeff * qfactor + qoffset) >> 2; \
566 sign = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \
567 coeff = (coeff ^ -sign) + sign; \
572 UNPACK_ARITH(8, int16_t)
573 UNPACK_ARITH(10, int32_t)
576 * Decode the coeffs in the rectangle defined by left, right, top, bottom
577 * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
579 static inline void codeblock(DiracContext *s, SubBand *b,
580 GetBitContext *gb, DiracArith *c,
581 int left, int right, int top, int bottom,
582 int blockcnt_one, int is_arith)
584 int x, y, zero_block;
585 int qoffset, qfactor;
588 /* check for any coded coefficients in this codeblock */
591 zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
593 zero_block = get_bits1(gb);
599 if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
600 int quant = b->quant;
602 quant += dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
604 quant += dirac_get_se_golomb(gb);
606 av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
612 if (b->quant > 115) {
613 av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", b->quant);
618 qfactor = qscale_tab[b->quant];
619 /* TODO: context pointer? */
621 qoffset = qoffset_intra_tab[b->quant] + 2;
623 qoffset = qoffset_inter_tab[b->quant] + 2;
625 buf = b->ibuf + top * b->stride;
627 for (y = top; y < bottom; y++) {
628 for (x = left; x < right; x++) {
630 coeff_unpack_arith_10(c, qfactor, qoffset, b, (int32_t*)(buf)+x, x, y);
632 coeff_unpack_arith_8(c, qfactor, qoffset, b, (int16_t*)(buf)+x, x, y);
638 for (y = top; y < bottom; y++) {
639 for (x = left; x < right; x++) {
640 int val = coeff_unpack_golomb(gb, qfactor, qoffset);
642 AV_WN32(&buf[4*x], val);
644 AV_WN16(&buf[2*x], val);
653 * Dirac Specification ->
654 * 13.3 intra_dc_prediction(band)
656 #define INTRA_DC_PRED(n, type) \
657 static inline void intra_dc_prediction_##n(SubBand *b) \
659 type *buf = (type*)b->ibuf; \
662 for (x = 1; x < b->width; x++) \
663 buf[x] += buf[x-1]; \
664 buf += (b->stride >> (1+b->pshift)); \
666 for (y = 1; y < b->height; y++) { \
667 buf[0] += buf[-(b->stride >> (1+b->pshift))]; \
669 for (x = 1; x < b->width; x++) { \
670 int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \
671 buf[x] += divide3(pred); \
673 buf += (b->stride >> (1+b->pshift)); \
677 INTRA_DC_PRED(8, int16_t)
678 INTRA_DC_PRED(10, int32_t)
681 * Dirac Specification ->
682 * 13.4.2 Non-skipped subbands. subband_coeffs()
684 static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
686 int cb_x, cb_y, left, right, top, bottom;
689 int cb_width = s->codeblock[b->level + (b->orientation != subband_ll)].width;
690 int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
691 int blockcnt_one = (cb_width + cb_height) == 2;
696 init_get_bits8(&gb, b->coeff_data, b->length);
699 ff_dirac_init_arith_decoder(&c, &gb, b->length);
702 for (cb_y = 0; cb_y < cb_height; cb_y++) {
703 bottom = (b->height * (cb_y+1LL)) / cb_height;
705 for (cb_x = 0; cb_x < cb_width; cb_x++) {
706 right = (b->width * (cb_x+1LL)) / cb_width;
707 codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
713 if (b->orientation == subband_ll && s->num_refs == 0) {
715 intra_dc_prediction_10(b);
717 intra_dc_prediction_8(b);
722 static int decode_subband_arith(AVCodecContext *avctx, void *b)
724 DiracContext *s = avctx->priv_data;
725 decode_subband_internal(s, b, 1);
729 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
731 DiracContext *s = avctx->priv_data;
733 decode_subband_internal(s, *b, 0);
738 * Dirac Specification ->
739 * [DIRAC_STD] 13.4.1 core_transform_data()
741 static void decode_component(DiracContext *s, int comp)
743 AVCodecContext *avctx = s->avctx;
744 SubBand *bands[3*MAX_DWT_LEVELS+1];
745 enum dirac_subband orientation;
746 int level, num_bands = 0;
748 /* Unpack all subbands at all levels. */
749 for (level = 0; level < s->wavelet_depth; level++) {
750 for (orientation = !!level; orientation < 4; orientation++) {
751 SubBand *b = &s->plane[comp].band[level][orientation];
752 bands[num_bands++] = b;
754 align_get_bits(&s->gb);
755 /* [DIRAC_STD] 13.4.2 subband() */
756 b->length = svq3_get_ue_golomb(&s->gb);
758 b->quant = svq3_get_ue_golomb(&s->gb);
759 align_get_bits(&s->gb);
760 b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
761 b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
762 skip_bits_long(&s->gb, b->length*8);
765 /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
767 avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
768 NULL, 4-!!level, sizeof(SubBand));
770 /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
772 avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
775 #define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \
776 type *buf = (type *)buf1; \
777 buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
778 if (get_bits_count(gb) >= ebits) \
781 buf = (type *)buf2; \
782 buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
783 if (get_bits_count(gb) >= ebits) \
787 static void decode_subband(DiracContext *s, GetBitContext *gb, int quant,
788 int slice_x, int slice_y, int bits_end,
789 SubBand *b1, SubBand *b2)
791 int left = b1->width * slice_x / s->num_x;
792 int right = b1->width *(slice_x+1) / s->num_x;
793 int top = b1->height * slice_y / s->num_y;
794 int bottom = b1->height *(slice_y+1) / s->num_y;
796 int qfactor, qoffset;
798 uint8_t *buf1 = b1->ibuf + top * b1->stride;
799 uint8_t *buf2 = b2 ? b2->ibuf + top * b2->stride: NULL;
803 av_log(s->avctx, AV_LOG_ERROR, "Unsupported quant %d\n", quant);
806 qfactor = qscale_tab[quant & 0x7f];
807 qoffset = qoffset_intra_tab[quant & 0x7f] + 2;
808 /* we have to constantly check for overread since the spec explicitly
809 requires this, with the meaning that all remaining coeffs are set to 0 */
810 if (get_bits_count(gb) >= bits_end)
814 for (y = top; y < bottom; y++) {
815 for (x = left; x < right; x++) {
816 PARSE_VALUES(int32_t, x, gb, bits_end, buf1, buf2);
824 for (y = top; y < bottom; y++) {
825 for (x = left; x < right; x++) {
826 PARSE_VALUES(int16_t, x, gb, bits_end, buf1, buf2);
835 /* Used by Low Delay and High Quality profiles */
836 typedef struct DiracSlice {
845 * Dirac Specification ->
846 * 13.5.2 Slices. slice(sx,sy)
848 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
850 DiracContext *s = avctx->priv_data;
851 DiracSlice *slice = arg;
852 GetBitContext *gb = &slice->gb;
853 enum dirac_subband orientation;
854 int level, quant, chroma_bits, chroma_end;
856 int quant_base = get_bits(gb, 7); /*[DIRAC_STD] qindex */
857 int length_bits = av_log2(8 * slice->bytes)+1;
858 int luma_bits = get_bits_long(gb, length_bits);
859 int luma_end = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
861 /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
862 for (level = 0; level < s->wavelet_depth; level++)
863 for (orientation = !!level; orientation < 4; orientation++) {
864 quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
865 decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
866 &s->plane[0].band[level][orientation], NULL);
869 /* consume any unused bits from luma */
870 skip_bits_long(gb, get_bits_count(gb) - luma_end);
872 chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
873 chroma_end = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
874 /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
875 for (level = 0; level < s->wavelet_depth; level++)
876 for (orientation = !!level; orientation < 4; orientation++) {
877 quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
878 decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
879 &s->plane[1].band[level][orientation],
880 &s->plane[2].band[level][orientation]);
887 * VC-2 Specification ->
888 * 13.5.3 hq_slice(sx,sy)
890 static int decode_hq_slice(AVCodecContext *avctx, void *arg)
892 int i, quant, level, orientation, quant_idx;
893 uint8_t quants[MAX_DWT_LEVELS][4];
894 DiracContext *s = avctx->priv_data;
895 DiracSlice *slice = arg;
896 GetBitContext *gb = &slice->gb;
898 skip_bits_long(gb, 8*s->highquality.prefix_bytes);
899 quant_idx = get_bits(gb, 8);
901 /* Slice quantization (slice_quantizers() in the specs) */
902 for (level = 0; level < s->wavelet_depth; level++) {
903 for (orientation = !!level; orientation < 4; orientation++) {
904 quant = FFMAX(quant_idx - s->lowdelay.quant[level][orientation], 0);
905 quants[level][orientation] = quant;
909 /* Luma + 2 Chroma planes */
910 for (i = 0; i < 3; i++) {
911 int length = s->highquality.size_scaler * get_bits(gb, 8);
912 int bits_left = 8 * length;
913 int bits_end = get_bits_count(gb) + bits_left;
914 for (level = 0; level < s->wavelet_depth; level++) {
915 for (orientation = !!level; orientation < 4; orientation++) {
916 decode_subband(s, gb, quants[level][orientation], slice->slice_x, slice->slice_y, bits_end,
917 &s->plane[i].band[level][orientation], NULL);
920 skip_bits_long(gb, bits_end - get_bits_count(gb));
927 * Dirac Specification ->
928 * 13.5.1 low_delay_transform_data()
930 static int decode_lowdelay(DiracContext *s)
932 AVCodecContext *avctx = s->avctx;
933 int slice_x, slice_y, bytes = 0, bufsize;
938 slices = av_mallocz_array(s->num_x, s->num_y * sizeof(DiracSlice));
940 return AVERROR(ENOMEM);
942 align_get_bits(&s->gb);
943 /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
944 buf = s->gb.buffer + get_bits_count(&s->gb)/8;
945 bufsize = get_bits_left(&s->gb);
950 for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
951 for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
952 bytes = s->highquality.prefix_bytes + 1;
953 for (i = 0; i < 3; i++) {
954 if (bytes <= bufsize/8)
955 bytes += buf[bytes] * s->highquality.size_scaler + 1;
958 slices[slice_num].bytes = bytes;
959 slices[slice_num].slice_x = slice_x;
960 slices[slice_num].slice_y = slice_y;
961 init_get_bits(&slices[slice_num].gb, buf, bufsize);
965 if (bufsize/8 >= bytes)
971 avctx->execute(avctx, decode_hq_slice, slices, NULL, slice_num,
974 for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
975 for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
976 bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
977 - slice_num * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
978 slices[slice_num].bytes = bytes;
979 slices[slice_num].slice_x = slice_x;
980 slices[slice_num].slice_y = slice_y;
981 init_get_bits(&slices[slice_num].gb, buf, bufsize);
985 if (bufsize/8 >= bytes)
991 avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
992 sizeof(DiracSlice)); /* [DIRAC_STD] 13.5.2 Slices */
995 if (s->dc_prediction) {
997 intra_dc_prediction_10(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
998 intra_dc_prediction_10(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
999 intra_dc_prediction_10(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
1001 intra_dc_prediction_8(&s->plane[0].band[0][0]);
1002 intra_dc_prediction_8(&s->plane[1].band[0][0]);
1003 intra_dc_prediction_8(&s->plane[2].band[0][0]);
1010 static void init_planes(DiracContext *s)
1012 int i, w, h, level, orientation;
1014 for (i = 0; i < 3; i++) {
1015 Plane *p = &s->plane[i];
1017 p->width = s->seq.width >> (i ? s->chroma_x_shift : 0);
1018 p->height = s->seq.height >> (i ? s->chroma_y_shift : 0);
1019 p->idwt_width = w = CALC_PADDING(p->width , s->wavelet_depth);
1020 p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
1021 p->idwt_stride = FFALIGN(p->idwt_width, 8) << (1 + s->pshift);
1023 for (level = s->wavelet_depth-1; level >= 0; level--) {
1026 for (orientation = !!level; orientation < 4; orientation++) {
1027 SubBand *b = &p->band[level][orientation];
1029 b->pshift = s->pshift;
1030 b->ibuf = p->idwt_buf;
1032 b->stride = p->idwt_stride << (s->wavelet_depth - level);
1035 b->orientation = orientation;
1037 if (orientation & 1)
1038 b->ibuf += w << (1+b->pshift);
1039 if (orientation > 1)
1040 b->ibuf += (b->stride>>1);
1043 b->parent = &p->band[level-1][orientation];
1048 p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
1049 p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
1050 p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
1051 p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
1054 p->xoffset = (p->xblen - p->xbsep)/2;
1055 p->yoffset = (p->yblen - p->ybsep)/2;
1060 * Unpack the motion compensation parameters
1061 * Dirac Specification ->
1062 * 11.2 Picture prediction data. picture_prediction()
1064 static int dirac_unpack_prediction_parameters(DiracContext *s)
1066 static const uint8_t default_blen[] = { 4, 12, 16, 24 };
1068 GetBitContext *gb = &s->gb;
1072 /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
1073 /* Luma and Chroma are equal. 11.2.3 */
1074 idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
1077 av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
1078 return AVERROR_INVALIDDATA;
1082 s->plane[0].xblen = svq3_get_ue_golomb(gb);
1083 s->plane[0].yblen = svq3_get_ue_golomb(gb);
1084 s->plane[0].xbsep = svq3_get_ue_golomb(gb);
1085 s->plane[0].ybsep = svq3_get_ue_golomb(gb);
1087 /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
1088 s->plane[0].xblen = default_blen[idx-1];
1089 s->plane[0].yblen = default_blen[idx-1];
1090 s->plane[0].xbsep = 4 * idx;
1091 s->plane[0].ybsep = 4 * idx;
1093 /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
1094 Calculated in function dirac_unpack_block_motion_data */
1096 if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
1097 s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
1098 !s->plane[0].xblen || !s->plane[0].yblen) {
1099 av_log(s->avctx, AV_LOG_ERROR,
1100 "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
1101 s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
1102 return AVERROR_INVALIDDATA;
1104 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) {
1105 av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
1106 return AVERROR_INVALIDDATA;
1108 if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
1109 av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
1110 return AVERROR_INVALIDDATA;
1112 if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
1113 av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
1114 return AVERROR_PATCHWELCOME;
1117 /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
1118 Read motion vector precision */
1119 s->mv_precision = svq3_get_ue_golomb(gb);
1120 if (s->mv_precision > 3) {
1121 av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
1122 return AVERROR_INVALIDDATA;
1125 /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
1126 Read the global motion compensation parameters */
1127 s->globalmc_flag = get_bits1(gb);
1128 if (s->globalmc_flag) {
1129 memset(s->globalmc, 0, sizeof(s->globalmc));
1130 /* [DIRAC_STD] pan_tilt(gparams) */
1131 for (ref = 0; ref < s->num_refs; ref++) {
1132 if (get_bits1(gb)) {
1133 s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
1134 s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
1136 /* [DIRAC_STD] zoom_rotate_shear(gparams)
1137 zoom/rotation/shear parameters */
1138 if (get_bits1(gb)) {
1139 s->globalmc[ref].zrs_exp = svq3_get_ue_golomb(gb);
1140 s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
1141 s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
1142 s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
1143 s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
1145 s->globalmc[ref].zrs[0][0] = 1;
1146 s->globalmc[ref].zrs[1][1] = 1;
1148 /* [DIRAC_STD] perspective(gparams) */
1149 if (get_bits1(gb)) {
1150 s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
1151 s->globalmc[ref].perspective[0] = dirac_get_se_golomb(gb);
1152 s->globalmc[ref].perspective[1] = dirac_get_se_golomb(gb);
1157 /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
1158 Picture prediction mode, not currently used. */
1159 if (svq3_get_ue_golomb(gb)) {
1160 av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
1161 return AVERROR_INVALIDDATA;
1164 /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
1165 just data read, weight calculation will be done later on. */
1166 s->weight_log2denom = 1;
1170 if (get_bits1(gb)) {
1171 s->weight_log2denom = svq3_get_ue_golomb(gb);
1172 s->weight[0] = dirac_get_se_golomb(gb);
1173 if (s->num_refs == 2)
1174 s->weight[1] = dirac_get_se_golomb(gb);
1180 * Dirac Specification ->
1181 * 11.3 Wavelet transform data. wavelet_transform()
1183 static int dirac_unpack_idwt_params(DiracContext *s)
1185 GetBitContext *gb = &s->gb;
1189 #define CHECKEDREAD(dst, cond, errmsg) \
1190 tmp = svq3_get_ue_golomb(gb); \
1192 av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1193 return AVERROR_INVALIDDATA; \
1199 s->zero_res = s->num_refs ? get_bits1(gb) : 0;
1203 /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
1204 CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
1206 CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
1208 if (!s->low_delay) {
1209 /* Codeblock parameters (core syntax only) */
1210 if (get_bits1(gb)) {
1211 for (i = 0; i <= s->wavelet_depth; i++) {
1212 CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n")
1213 CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n")
1216 CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
1219 for (i = 0; i <= s->wavelet_depth; i++)
1220 s->codeblock[i].width = s->codeblock[i].height = 1;
1224 s->num_x = svq3_get_ue_golomb(gb);
1225 s->num_y = svq3_get_ue_golomb(gb);
1226 if (s->ld_picture) {
1227 s->lowdelay.bytes.num = svq3_get_ue_golomb(gb);
1228 s->lowdelay.bytes.den = svq3_get_ue_golomb(gb);
1229 if (s->lowdelay.bytes.den <= 0) {
1230 av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
1231 return AVERROR_INVALIDDATA;
1233 } else if (s->hq_picture) {
1234 s->highquality.prefix_bytes = svq3_get_ue_golomb(gb);
1235 s->highquality.size_scaler = svq3_get_ue_golomb(gb);
1238 /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1239 if (get_bits1(gb)) {
1240 av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1241 /* custom quantization matrix */
1242 s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
1243 for (level = 0; level < s->wavelet_depth; level++) {
1244 s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
1245 s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
1246 s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
1249 if (s->wavelet_depth > 4) {
1250 av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1251 return AVERROR_INVALIDDATA;
1253 /* default quantization matrix */
1254 for (level = 0; level < s->wavelet_depth; level++)
1255 for (i = 0; i < 4; i++) {
1256 s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1257 /* haar with no shift differs for different depths */
1258 if (s->wavelet_idx == 3)
1259 s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1266 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1268 static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1275 return sbsplit[-stride];
1277 return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1280 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1287 return block[-1].ref & refmask;
1289 return block[-stride].ref & refmask;
1291 /* return the majority */
1292 pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1293 return (pred >> 1) & refmask;
1296 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1300 memset(block->u.dc, 0, sizeof(block->u.dc));
1302 if (x && !(block[-1].ref & 3)) {
1303 for (i = 0; i < 3; i++)
1304 block->u.dc[i] += block[-1].u.dc[i];
1308 if (y && !(block[-stride].ref & 3)) {
1309 for (i = 0; i < 3; i++)
1310 block->u.dc[i] += block[-stride].u.dc[i];
1314 if (x && y && !(block[-1-stride].ref & 3)) {
1315 for (i = 0; i < 3; i++)
1316 block->u.dc[i] += block[-1-stride].u.dc[i];
1321 for (i = 0; i < 3; i++)
1322 block->u.dc[i] = (block->u.dc[i]+1)>>1;
1323 } else if (n == 3) {
1324 for (i = 0; i < 3; i++)
1325 block->u.dc[i] = divide3(block->u.dc[i]);
1329 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1332 int refmask = ref+1;
1333 int mask = refmask | DIRAC_REF_MASK_GLOBAL; /* exclude gmc blocks */
1336 if (x && (block[-1].ref & mask) == refmask)
1337 pred[n++] = block[-1].u.mv[ref];
1339 if (y && (block[-stride].ref & mask) == refmask)
1340 pred[n++] = block[-stride].u.mv[ref];
1342 if (x && y && (block[-stride-1].ref & mask) == refmask)
1343 pred[n++] = block[-stride-1].u.mv[ref];
1347 block->u.mv[ref][0] = 0;
1348 block->u.mv[ref][1] = 0;
1351 block->u.mv[ref][0] = pred[0][0];
1352 block->u.mv[ref][1] = pred[0][1];
1355 block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1356 block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1359 block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1360 block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1365 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1367 int ez = s->globalmc[ref].zrs_exp;
1368 int ep = s->globalmc[ref].perspective_exp;
1369 int (*A)[2] = s->globalmc[ref].zrs;
1370 int *b = s->globalmc[ref].pan_tilt;
1371 int *c = s->globalmc[ref].perspective;
1373 int m = (1<<ep) - (c[0]*x + c[1]*y);
1374 int mx = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1375 int my = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1377 block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1378 block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1381 static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
1382 int stride, int x, int y)
1386 block->ref = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1387 block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1389 if (s->num_refs == 2) {
1390 block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1391 block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1395 pred_block_dc(block, stride, x, y);
1396 for (i = 0; i < 3; i++)
1397 block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1401 if (s->globalmc_flag) {
1402 block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1403 block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1406 for (i = 0; i < s->num_refs; i++)
1407 if (block->ref & (i+1)) {
1408 if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1409 global_mv(s, block, x, y, i);
1411 pred_mv(block, stride, x, y, i);
1412 block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1413 block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1419 * Copies the current block to the other blocks covered by the current superblock split mode
1421 static void propagate_block_data(DiracBlock *block, int stride, int size)
1424 DiracBlock *dst = block;
1426 for (x = 1; x < size; x++)
1429 for (y = 1; y < size; y++) {
1431 for (x = 0; x < size; x++)
1437 * Dirac Specification ->
1438 * 12. Block motion data syntax
1440 static int dirac_unpack_block_motion_data(DiracContext *s)
1442 GetBitContext *gb = &s->gb;
1443 uint8_t *sbsplit = s->sbsplit;
1445 DiracArith arith[8];
1449 /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1450 s->sbwidth = DIVRNDUP(s->seq.width, 4*s->plane[0].xbsep);
1451 s->sbheight = DIVRNDUP(s->seq.height, 4*s->plane[0].ybsep);
1452 s->blwidth = 4 * s->sbwidth;
1453 s->blheight = 4 * s->sbheight;
1455 /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1456 decode superblock split modes */
1457 ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb)); /* svq3_get_ue_golomb(gb) is the length */
1458 for (y = 0; y < s->sbheight; y++) {
1459 for (x = 0; x < s->sbwidth; x++) {
1460 unsigned int split = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1462 return AVERROR_INVALIDDATA;
1463 sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1465 sbsplit += s->sbwidth;
1468 /* setup arith decoding */
1469 ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));
1470 for (i = 0; i < s->num_refs; i++) {
1471 ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1472 ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1474 for (i = 0; i < 3; i++)
1475 ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1477 for (y = 0; y < s->sbheight; y++)
1478 for (x = 0; x < s->sbwidth; x++) {
1479 int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1480 int step = 4 >> s->sbsplit[y * s->sbwidth + x];
1482 for (q = 0; q < blkcnt; q++)
1483 for (p = 0; p < blkcnt; p++) {
1484 int bx = 4 * x + p*step;
1485 int by = 4 * y + q*step;
1486 DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1487 decode_block_params(s, arith, block, s->blwidth, bx, by);
1488 propagate_block_data(block, s->blwidth, step);
1495 static int weight(int i, int blen, int offset)
1497 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) : \
1498 (1 + (6*(i) + offset - 1) / (2*offset - 1))
1502 else if (i > blen-1 - 2*offset)
1503 return ROLLOFF(blen-1 - i);
1507 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1508 int left, int right, int wy)
1511 for (x = 0; left && x < p->xblen >> 1; x++)
1512 obmc_weight[x] = wy*8;
1513 for (; x < p->xblen >> right; x++)
1514 obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1515 for (; x < p->xblen; x++)
1516 obmc_weight[x] = wy*8;
1517 for (; x < stride; x++)
1521 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1522 int left, int right, int top, int bottom)
1525 for (y = 0; top && y < p->yblen >> 1; y++) {
1526 init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1527 obmc_weight += stride;
1529 for (; y < p->yblen >> bottom; y++) {
1530 int wy = weight(y, p->yblen, p->yoffset);
1531 init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1532 obmc_weight += stride;
1534 for (; y < p->yblen; y++) {
1535 init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1536 obmc_weight += stride;
1540 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1543 int bottom = by == s->blheight-1;
1545 /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1546 if (top || bottom || by == 1) {
1547 init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1548 init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1549 init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1553 static const uint8_t epel_weights[4][4][4] = {
1573 * For block x,y, determine which of the hpel planes to do bilinear
1574 * interpolation from and set src[] to the location in each hpel plane
1577 * @return the index of the put_dirac_pixels_tab function to use
1578 * 0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1580 static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
1581 int x, int y, int ref, int plane)
1583 Plane *p = &s->plane[plane];
1584 uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1585 int motion_x = block->u.mv[ref][0];
1586 int motion_y = block->u.mv[ref][1];
1587 int mx, my, i, epel, nplanes = 0;
1590 motion_x >>= s->chroma_x_shift;
1591 motion_y >>= s->chroma_y_shift;
1594 mx = motion_x & ~(-1U << s->mv_precision);
1595 my = motion_y & ~(-1U << s->mv_precision);
1596 motion_x >>= s->mv_precision;
1597 motion_y >>= s->mv_precision;
1598 /* normalize subpel coordinates to epel */
1599 /* TODO: template this function? */
1600 mx <<= 3 - s->mv_precision;
1601 my <<= 3 - s->mv_precision;
1610 src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1614 for (i = 0; i < 4; i++)
1615 src[i] = ref_hpel[i] + y*p->stride + x;
1617 /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1618 we increment x/y because the edge changes for half of the pixels */
1625 src[0] += p->stride;
1626 src[1] += p->stride;
1634 /* check if we really only need 2 planes since either mx or my is
1635 a hpel position. (epel weights of 0 handle this there) */
1637 /* mx == 0: average [0] and [2]
1638 mx == 4: average [1] and [3] */
1639 src[!mx] = src[2 + !!mx];
1641 } else if (!(my&3)) {
1642 src[0] = src[(my>>1) ];
1643 src[1] = src[(my>>1)+1];
1647 /* adjust the ordering if needed so the weights work */
1649 FFSWAP(const uint8_t *, src[0], src[1]);
1650 FFSWAP(const uint8_t *, src[2], src[3]);
1653 FFSWAP(const uint8_t *, src[0], src[2]);
1654 FFSWAP(const uint8_t *, src[1], src[3]);
1656 src[4] = epel_weights[my&3][mx&3];
1660 /* fixme: v/h _edge_pos */
1661 if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1662 y + p->yblen > p->height+EDGE_WIDTH/2 ||
1664 for (i = 0; i < nplanes; i++) {
1665 s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1666 p->stride, p->stride,
1667 p->xblen, p->yblen, x, y,
1668 p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1669 src[i] = s->edge_emu_buffer[i];
1672 return (nplanes>>1) + epel;
1675 static void add_dc(uint16_t *dst, int dc, int stride,
1676 uint8_t *obmc_weight, int xblen, int yblen)
1681 for (y = 0; y < yblen; y++) {
1682 for (x = 0; x < xblen; x += 2) {
1683 dst[x ] += dc * obmc_weight[x ];
1684 dst[x+1] += dc * obmc_weight[x+1];
1687 obmc_weight += MAX_BLOCKSIZE;
1691 static void block_mc(DiracContext *s, DiracBlock *block,
1692 uint16_t *mctmp, uint8_t *obmc_weight,
1693 int plane, int dstx, int dsty)
1695 Plane *p = &s->plane[plane];
1696 const uint8_t *src[5];
1699 switch (block->ref&3) {
1701 add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1705 idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1706 s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1708 s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1709 s->weight[0] + s->weight[1], p->yblen);
1712 idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1713 s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1714 idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1715 if (s->biweight_func) {
1716 /* fixme: +32 is a quick hack */
1717 s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1718 s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1719 s->weight[0], s->weight[1], p->yblen);
1721 s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1724 s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1727 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1729 Plane *p = &s->plane[plane];
1730 int x, dstx = p->xbsep - p->xoffset;
1732 block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1735 for (x = 1; x < s->blwidth-1; x++) {
1736 block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1740 block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1743 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1751 memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1752 memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1753 s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1754 if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1755 s->weight_func = s->diracdsp.weight_dirac_pixels_tab[idx];
1756 s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1758 s->weight_func = NULL;
1759 s->biweight_func = NULL;
1763 static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1765 /* chroma allocates an edge of 8 when subsampled
1766 which for 4:2:2 means an h edge of 16 and v edge of 8
1767 just use 8 for everything for the moment */
1768 int i, edge = EDGE_WIDTH/2;
1770 ref->hpel[plane][0] = ref->avframe->data[plane];
1771 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 */
1773 /* no need for hpel if we only have fpel vectors */
1774 if (!s->mv_precision)
1777 for (i = 1; i < 4; i++) {
1778 if (!ref->hpel_base[plane][i])
1779 ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1780 if (!ref->hpel_base[plane][i]) {
1781 return AVERROR(ENOMEM);
1783 /* we need to be 16-byte aligned even for chroma */
1784 ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1787 if (!ref->interpolated[plane]) {
1788 s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1789 ref->hpel[plane][3], ref->hpel[plane][0],
1790 ref->avframe->linesize[plane], width, height);
1791 s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1792 s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1793 s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1795 ref->interpolated[plane] = 1;
1801 * Dirac Specification ->
1802 * 13.0 Transform data syntax. transform_data()
1804 static int dirac_decode_frame_internal(DiracContext *s)
1807 int y, i, comp, dsty;
1811 /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1812 for (comp = 0; comp < 3; comp++) {
1813 Plane *p = &s->plane[comp];
1814 memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height);
1817 if ((ret = decode_lowdelay(s)) < 0)
1822 for (comp = 0; comp < 3; comp++) {
1823 Plane *p = &s->plane[comp];
1824 uint8_t *frame = s->current_picture->avframe->data[comp];
1826 /* FIXME: small resolutions */
1827 for (i = 0; i < 4; i++)
1828 s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1830 if (!s->zero_res && !s->low_delay)
1832 memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height);
1833 decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1835 ret = ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
1836 s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp, s->bit_depth);
1840 if (!s->num_refs) { /* intra */
1841 for (y = 0; y < p->height; y += 16) {
1842 int idx = (s->bit_depth - 8) >> 1;
1843 ff_spatial_idwt_slice2(&d, y+16); /* decode */
1844 s->diracdsp.put_signed_rect_clamped[idx](frame + y*p->stride,
1846 p->idwt_buf + y*p->idwt_stride,
1847 p->idwt_stride, p->width, 16);
1849 } else { /* inter */
1850 int rowheight = p->ybsep*p->stride;
1852 select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1854 for (i = 0; i < s->num_refs; i++) {
1855 int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1860 memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1863 for (y = 0; y < s->blheight; y++) {
1865 start = FFMAX(dsty, 0);
1866 uint16_t *mctmp = s->mctmp + y*rowheight;
1867 DiracBlock *blocks = s->blmotion + y*s->blwidth;
1869 init_obmc_weights(s, p, y);
1871 if (y == s->blheight-1 || start+p->ybsep > p->height)
1872 h = p->height - start;
1874 h = p->ybsep - (start - dsty);
1878 memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1879 mc_row(s, blocks, mctmp, comp, dsty);
1881 mctmp += (start - dsty)*p->stride + p->xoffset;
1882 ff_spatial_idwt_slice2(&d, start + h); /* decode */
1883 /* NOTE: add_rect_clamped hasn't been templated hence the shifts.
1884 * idwt_stride is passed as pixels, not in bytes as in the rest of the decoder */
1885 s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1886 (int16_t*)(p->idwt_buf) + start*(p->idwt_stride >> 1), (p->idwt_stride >> 1), p->width, h);
1897 static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
1900 int chroma_x_shift, chroma_y_shift;
1901 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift, &chroma_y_shift);
1903 f->width = avctx->width + 2 * EDGE_WIDTH;
1904 f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1905 ret = ff_get_buffer(avctx, f, flags);
1909 for (i = 0; f->data[i]; i++) {
1910 int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1911 f->linesize[i] + 32;
1912 f->data[i] += offset;
1914 f->width = avctx->width;
1915 f->height = avctx->height;
1921 * Dirac Specification ->
1922 * 11.1.1 Picture Header. picture_header()
1924 static int dirac_decode_picture_header(DiracContext *s)
1926 unsigned retire, picnum;
1928 int64_t refdist, refnum;
1929 GetBitContext *gb = &s->gb;
1931 /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1932 picnum = s->current_picture->avframe->display_picture_number = get_bits_long(gb, 32);
1935 av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1937 /* if this is the first keyframe after a sequence header, start our
1938 reordering from here */
1939 if (s->frame_number < 0)
1940 s->frame_number = picnum;
1942 s->ref_pics[0] = s->ref_pics[1] = NULL;
1943 for (i = 0; i < s->num_refs; i++) {
1944 refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1945 refdist = INT64_MAX;
1947 /* find the closest reference to the one we want */
1948 /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1949 for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1950 if (s->ref_frames[j]
1951 && FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
1952 s->ref_pics[i] = s->ref_frames[j];
1953 refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
1956 if (!s->ref_pics[i] || refdist)
1957 av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1959 /* if there were no references at all, allocate one */
1960 if (!s->ref_pics[i])
1961 for (j = 0; j < MAX_FRAMES; j++)
1962 if (!s->all_frames[j].avframe->data[0]) {
1963 s->ref_pics[i] = &s->all_frames[j];
1964 get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
1968 if (!s->ref_pics[i]) {
1969 av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
1970 return AVERROR_INVALIDDATA;
1975 /* retire the reference frames that are not used anymore */
1976 if (s->current_picture->reference) {
1977 retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1978 if (retire != picnum) {
1979 DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1982 retire_pic->reference &= DELAYED_PIC_REF;
1984 av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1987 /* if reference array is full, remove the oldest as per the spec */
1988 while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
1989 av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1990 remove_frame(s->ref_frames, s->ref_frames[0]->avframe->display_picture_number)->reference &= DELAYED_PIC_REF;
1995 ret = dirac_unpack_prediction_parameters(s); /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1998 ret = dirac_unpack_block_motion_data(s); /* [DIRAC_STD] 12. Block motion data syntax */
2002 ret = dirac_unpack_idwt_params(s); /* [DIRAC_STD] 11.3 Wavelet transform data */
2010 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
2012 DiracFrame *out = s->delay_frames[0];
2016 /* find frame with lowest picture number */
2017 for (i = 1; s->delay_frames[i]; i++)
2018 if (s->delay_frames[i]->avframe->display_picture_number < out->avframe->display_picture_number) {
2019 out = s->delay_frames[i];
2023 for (i = out_idx; s->delay_frames[i]; i++)
2024 s->delay_frames[i] = s->delay_frames[i+1];
2027 out->reference ^= DELAYED_PIC_REF;
2029 if((ret = av_frame_ref(picture, out->avframe)) < 0)
2037 * Dirac Specification ->
2038 * 9.6 Parse Info Header Syntax. parse_info()
2039 * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
2041 #define DATA_UNIT_HEADER_SIZE 13
2043 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
2044 inside the function parse_sequence() */
2045 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
2047 DiracContext *s = avctx->priv_data;
2048 DiracFrame *pic = NULL;
2049 AVDiracSeqHeader *dsh;
2054 if (size < DATA_UNIT_HEADER_SIZE)
2055 return AVERROR_INVALIDDATA;
2057 parse_code = buf[4];
2059 init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
2061 if (parse_code == DIRAC_PCODE_SEQ_HEADER) {
2062 if (s->seen_sequence_header)
2065 /* [DIRAC_STD] 10. Sequence header */
2066 ret = av_dirac_parse_sequence_header(&dsh, buf + DATA_UNIT_HEADER_SIZE, size - DATA_UNIT_HEADER_SIZE, avctx);
2068 av_log(avctx, AV_LOG_ERROR, "error parsing sequence header");
2072 ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
2078 ff_set_sar(avctx, dsh->sample_aspect_ratio);
2079 avctx->pix_fmt = dsh->pix_fmt;
2080 avctx->color_range = dsh->color_range;
2081 avctx->color_trc = dsh->color_trc;
2082 avctx->color_primaries = dsh->color_primaries;
2083 avctx->colorspace = dsh->colorspace;
2084 avctx->profile = dsh->profile;
2085 avctx->level = dsh->level;
2086 avctx->framerate = dsh->framerate;
2087 s->bit_depth = dsh->bit_depth;
2088 s->version.major = dsh->version.major;
2089 s->version.minor = dsh->version.minor;
2093 s->pshift = s->bit_depth > 8;
2095 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
2097 ret = alloc_sequence_buffers(s);
2101 s->seen_sequence_header = 1;
2102 } else if (parse_code == DIRAC_PCODE_END_SEQ) { /* [DIRAC_STD] End of Sequence */
2103 free_sequence_buffers(s);
2104 s->seen_sequence_header = 0;
2105 } else if (parse_code == DIRAC_PCODE_AUX) {
2106 if (buf[13] == 1) { /* encoder implementation/version */
2108 /* versions older than 1.0.8 don't store quant delta for
2109 subbands with only one codeblock */
2110 if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
2111 if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
2112 s->old_delta_quant = 1;
2114 } else if (parse_code & 0x8) { /* picture data unit */
2115 if (!s->seen_sequence_header) {
2116 av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
2117 return AVERROR_INVALIDDATA;
2120 /* find an unused frame */
2121 for (i = 0; i < MAX_FRAMES; i++)
2122 if (s->all_frames[i].avframe->data[0] == NULL)
2123 pic = &s->all_frames[i];
2125 av_log(avctx, AV_LOG_ERROR, "framelist full\n");
2126 return AVERROR_INVALIDDATA;
2129 av_frame_unref(pic->avframe);
2131 /* [DIRAC_STD] Defined in 9.6.1 ... */
2132 tmp = parse_code & 0x03; /* [DIRAC_STD] num_refs() */
2134 av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
2135 return AVERROR_INVALIDDATA;
2138 s->is_arith = (parse_code & 0x48) == 0x08; /* [DIRAC_STD] using_ac() */
2139 s->low_delay = (parse_code & 0x88) == 0x88; /* [DIRAC_STD] is_low_delay() */
2140 s->core_syntax = (parse_code & 0x88) == 0x08; /* [DIRAC_STD] is_core_syntax() */
2141 s->ld_picture = (parse_code & 0xF8) == 0xC8; /* [DIRAC_STD] is_ld_picture() */
2142 s->hq_picture = (parse_code & 0xF8) == 0xE8; /* [DIRAC_STD] is_hq_picture() */
2143 s->dc_prediction = (parse_code & 0x28) == 0x08; /* [DIRAC_STD] using_dc_prediction() */
2144 pic->reference = (parse_code & 0x0C) == 0x0C; /* [DIRAC_STD] is_reference() */
2145 pic->avframe->key_frame = s->num_refs == 0; /* [DIRAC_STD] is_intra() */
2146 pic->avframe->pict_type = s->num_refs + 1; /* Definition of AVPictureType in avutil.h */
2148 /* VC-2 Low Delay has a different parse code than the Dirac Low Delay */
2149 if (s->version.minor == 2 && parse_code == 0x88)
2152 if (s->low_delay && !(s->ld_picture || s->hq_picture) ) {
2153 av_log(avctx, AV_LOG_ERROR, "Invalid low delay flag\n");
2154 return AVERROR_INVALIDDATA;
2157 if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
2159 s->current_picture = pic;
2160 s->plane[0].stride = pic->avframe->linesize[0];
2161 s->plane[1].stride = pic->avframe->linesize[1];
2162 s->plane[2].stride = pic->avframe->linesize[2];
2164 if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)
2165 return AVERROR(ENOMEM);
2167 /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
2168 ret = dirac_decode_picture_header(s);
2172 /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
2173 ret = dirac_decode_frame_internal(s);
2180 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
2182 DiracContext *s = avctx->priv_data;
2183 AVFrame *picture = data;
2184 uint8_t *buf = pkt->data;
2185 int buf_size = pkt->size;
2188 unsigned data_unit_size;
2190 /* release unused frames */
2191 for (i = 0; i < MAX_FRAMES; i++)
2192 if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].reference) {
2193 av_frame_unref(s->all_frames[i].avframe);
2194 memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
2197 s->current_picture = NULL;
2200 /* end of stream, so flush delayed pics */
2202 return get_delayed_pic(s, (AVFrame *)data, got_frame);
2205 /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
2206 [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
2207 BBCD start code search */
2208 for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
2209 if (buf[buf_idx ] == 'B' && buf[buf_idx+1] == 'B' &&
2210 buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
2213 /* BBCD found or end of data */
2214 if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
2217 data_unit_size = AV_RB32(buf+buf_idx+5);
2218 if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
2219 if(data_unit_size > buf_size - buf_idx)
2220 av_log(s->avctx, AV_LOG_ERROR,
2221 "Data unit with size %d is larger than input buffer, discarding\n",
2226 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
2227 ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size);
2230 av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
2233 buf_idx += data_unit_size;
2236 if (!s->current_picture)
2239 if (s->current_picture->avframe->display_picture_number > s->frame_number) {
2240 DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
2242 s->current_picture->reference |= DELAYED_PIC_REF;
2244 if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
2245 int min_num = s->delay_frames[0]->avframe->display_picture_number;
2246 /* Too many delayed frames, so we display the frame with the lowest pts */
2247 av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
2249 for (i = 1; s->delay_frames[i]; i++)
2250 if (s->delay_frames[i]->avframe->display_picture_number < min_num)
2251 min_num = s->delay_frames[i]->avframe->display_picture_number;
2253 delayed_frame = remove_frame(s->delay_frames, min_num);
2254 add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
2257 if (delayed_frame) {
2258 delayed_frame->reference ^= DELAYED_PIC_REF;
2259 if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
2263 } else if (s->current_picture->avframe->display_picture_number == s->frame_number) {
2264 /* The right frame at the right time :-) */
2265 if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
2271 s->frame_number = picture->display_picture_number + 1;
2276 AVCodec ff_dirac_decoder = {
2278 .long_name = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
2279 .type = AVMEDIA_TYPE_VIDEO,
2280 .id = AV_CODEC_ID_DIRAC,
2281 .priv_data_size = sizeof(DiracContext),
2282 .init = dirac_decode_init,
2283 .close = dirac_decode_end,
2284 .decode = dirac_decode_frame,
2285 .capabilities = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_DR1,
2286 .flush = dirac_decode_flush,