c70a0c79020aee954e05e40843c0150fda7e0bac
[ffmpeg.git] / libavcodec / diracdec.c
1 /*
2  * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
3  * Copyright (C) 2009 David Conrad
4  * Copyright (C) 2011 Jordi Ortiz
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * Dirac Decoder
26  * @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
27  */
28
29 #include "avcodec.h"
30 #include "dsputil.h"
31 #include "get_bits.h"
32 #include "bytestream.h"
33 #include "golomb.h"
34 #include "dirac_arith.h"
35 #include "mpeg12data.h"
36 #include "dwt.h"
37 #include "dirac.h"
38 #include "diracdsp.h"
39
40 /**
41  * The spec limits the number of wavelet decompositions to 4 for both
42  * level 1 (VC-2) and 128 (long-gop default).
43  * 5 decompositions is the maximum before >16-bit buffers are needed.
44  * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
45  * the others to 4 decompositions (or 3 for the fidelity filter).
46  *
47  * We use this instead of MAX_DECOMPOSITIONS to save some memory.
48  */
49 #define MAX_DWT_LEVELS 5
50
51 /**
52  * The spec limits this to 3 for frame coding, but in practice can be as high as 6
53  */
54 #define MAX_REFERENCE_FRAMES 8
55 #define MAX_DELAY 5         /* limit for main profile for frame coding (TODO: field coding) */
56 #define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
57 #define MAX_QUANT 68        /* max quant for VC-2 */
58 #define MAX_BLOCKSIZE 32    /* maximum xblen/yblen we support */
59
60 /**
61  * DiracBlock->ref flags, if set then the block does MC from the given ref
62  */
63 #define DIRAC_REF_MASK_REF1   1
64 #define DIRAC_REF_MASK_REF2   2
65 #define DIRAC_REF_MASK_GLOBAL 4
66
67 /**
68  * Value of Picture.reference when Picture is not a reference picture, but
69  * is held for delayed output.
70  */
71 #define DELAYED_PIC_REF 4
72
73 #define ff_emulated_edge_mc ff_emulated_edge_mc_8 /* Fix: change the calls to this function regarding bit depth */
74
75 #define CALC_PADDING(size, depth)                       \
76     (((size + (1 << depth) - 1) >> depth) << depth)
77
78 #define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
79
80 typedef struct {
81     AVFrame avframe;
82     int interpolated[3];    /* 1 if hpel[] is valid */
83     uint8_t *hpel[3][4];
84     uint8_t *hpel_base[3][4];
85 } DiracFrame;
86
87 typedef struct {
88     union {
89         int16_t mv[2][2];
90         int16_t dc[3];
91     } u; /* anonymous unions aren't in C99 :( */
92     uint8_t ref;
93 } DiracBlock;
94
95 typedef struct SubBand {
96     int level;
97     int orientation;
98     int stride;
99     int width;
100     int height;
101     int quant;
102     IDWTELEM *ibuf;
103     struct SubBand *parent;
104
105     /* for low delay */
106     unsigned length;
107     const uint8_t *coeff_data;
108 } SubBand;
109
110 typedef struct Plane {
111     int width;
112     int height;
113     int stride;
114
115     int idwt_width;
116     int idwt_height;
117     int idwt_stride;
118     IDWTELEM *idwt_buf;
119     IDWTELEM *idwt_buf_base;
120     IDWTELEM *idwt_tmp;
121
122     /* block length */
123     uint8_t xblen;
124     uint8_t yblen;
125     /* block separation (block n+1 starts after this many pixels in block n) */
126     uint8_t xbsep;
127     uint8_t ybsep;
128     /* amount of overspill on each edge (half of the overlap between blocks) */
129     uint8_t xoffset;
130     uint8_t yoffset;
131
132     SubBand band[MAX_DWT_LEVELS][4];
133 } Plane;
134
135 typedef struct DiracContext {
136     AVCodecContext *avctx;
137     DSPContext dsp;
138     DiracDSPContext diracdsp;
139     GetBitContext gb;
140     dirac_source_params source;
141     int seen_sequence_header;
142     int frame_number;           /* number of the next frame to display       */
143     Plane plane[3];
144     int chroma_x_shift;
145     int chroma_y_shift;
146
147     int zero_res;               /* zero residue flag                         */
148     int is_arith;               /* whether coeffs use arith or golomb coding */
149     int low_delay;              /* use the low delay syntax                  */
150     int globalmc_flag;          /* use global motion compensation            */
151     int num_refs;               /* number of reference pictures              */
152
153     /* wavelet decoding */
154     unsigned wavelet_depth;     /* depth of the IDWT                         */
155     unsigned wavelet_idx;
156
157     /**
158      * schroedinger older than 1.0.8 doesn't store
159      * quant delta if only one codebook exists in a band
160      */
161     unsigned old_delta_quant;
162     unsigned codeblock_mode;
163
164     struct {
165         unsigned width;
166         unsigned height;
167     } codeblock[MAX_DWT_LEVELS+1];
168
169     struct {
170         unsigned num_x;         /* number of horizontal slices               */
171         unsigned num_y;         /* number of vertical slices                 */
172         AVRational bytes;       /* average bytes per slice                   */
173         uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
174     } lowdelay;
175
176     struct {
177         int pan_tilt[2];        /* pan/tilt vector                           */
178         int zrs[2][2];          /* zoom/rotate/shear matrix                  */
179         int perspective[2];     /* perspective vector                        */
180         unsigned zrs_exp;
181         unsigned perspective_exp;
182     } globalmc[2];
183
184     /* motion compensation */
185     uint8_t mv_precision;       /* [DIRAC_STD] REFS_WT_PRECISION             */
186     int16_t weight[2];          /* [DIRAC_STD] REF1_WT and REF2_WT           */
187     unsigned weight_log2denom;  /* [DIRAC_STD] REFS_WT_PRECISION             */
188
189     int blwidth;                /* number of blocks (horizontally)           */
190     int blheight;               /* number of blocks (vertically)             */
191     int sbwidth;                /* number of superblocks (horizontally)      */
192     int sbheight;               /* number of superblocks (vertically)        */
193
194     uint8_t *sbsplit;
195     DiracBlock *blmotion;
196
197     uint8_t *edge_emu_buffer[4];
198     uint8_t *edge_emu_buffer_base;
199
200     uint16_t *mctmp;            /* buffer holding the MC data multipled by OBMC weights */
201     uint8_t *mcscratch;
202
203     DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
204
205     void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
206     void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
207     void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
208     dirac_weight_func weight_func;
209     dirac_biweight_func biweight_func;
210
211     DiracFrame *current_picture;
212     DiracFrame *ref_pics[2];
213
214     DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
215     DiracFrame *delay_frames[MAX_DELAY+1];
216     DiracFrame all_frames[MAX_FRAMES];
217 } DiracContext;
218
219 /**
220  * Dirac Specification ->
221  * Parse code values. 9.6.1 Table 9.1
222  */
223 enum dirac_parse_code {
224     pc_seq_header         = 0x00,
225     pc_eos                = 0x10,
226     pc_aux_data           = 0x20,
227     pc_padding            = 0x30,
228 };
229
230 enum dirac_subband {
231     subband_ll = 0,
232     subband_hl = 1,
233     subband_lh = 2,
234     subband_hh = 3
235 };
236
237 static const uint8_t default_qmat[][4][4] = {
238     { { 5,  3,  3,  0}, { 0,  4,  4,  1}, { 0,  5,  5,  2}, { 0,  6,  6,  3} },
239     { { 4,  2,  2,  0}, { 0,  4,  4,  2}, { 0,  5,  5,  3}, { 0,  7,  7,  5} },
240     { { 5,  3,  3,  0}, { 0,  4,  4,  1}, { 0,  5,  5,  2}, { 0,  6,  6,  3} },
241     { { 8,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0} },
242     { { 8,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0} },
243     { { 0,  4,  4,  8}, { 0,  8,  8, 12}, { 0, 13, 13, 17}, { 0, 17, 17, 21} },
244     { { 3,  1,  1,  0}, { 0,  4,  4,  2}, { 0,  6,  6,  5}, { 0,  9,  9,  7} },
245 };
246
247 static const int qscale_tab[MAX_QUANT+1] = {
248     4,     5,     6,     7,     8,    10,    11,    13,
249     16,    19,    23,    27,    32,    38,    45,    54,
250     64,    76,    91,   108,   128,   152,   181,   215,
251     256,   304,   362,   431,   512,   609,   724,   861,
252     1024,  1218,  1448,  1722,  2048,  2435,  2896,  3444,
253     4096,  4871,  5793,  6889,  8192,  9742, 11585, 13777,
254     16384, 19484, 23170, 27554, 32768, 38968, 46341, 55109,
255     65536, 77936
256 };
257
258 static const int qoffset_intra_tab[MAX_QUANT+1] = {
259     1,     2,     3,     4,     4,     5,     6,     7,
260     8,    10,    12,    14,    16,    19,    23,    27,
261     32,    38,    46,    54,    64,    76,    91,   108,
262     128,   152,   181,   216,   256,   305,   362,   431,
263     512,   609,   724,   861,  1024,  1218,  1448,  1722,
264     2048,  2436,  2897,  3445,  4096,  4871,  5793,  6889,
265     8192,  9742, 11585, 13777, 16384, 19484, 23171, 27555,
266     32768, 38968
267 };
268
269 static const int qoffset_inter_tab[MAX_QUANT+1] = {
270     1,     2,     2,     3,     3,     4,     4,     5,
271     6,     7,     9,    10,    12,    14,    17,    20,
272     24,    29,    34,    41,    48,    57,    68,    81,
273     96,   114,   136,   162,   192,   228,   272,   323,
274     384,   457,   543,   646,   768,   913,  1086,  1292,
275     1536,  1827,  2172,  2583,  3072,  3653,  4344,  5166,
276     6144,  7307,  8689, 10333, 12288, 14613, 17378, 20666,
277     24576, 29226
278 };
279
280 /* magic number division by 3 from schroedinger */
281 static inline int divide3(int x)
282 {
283     return ((x+1)*21845 + 10922) >> 16;
284 }
285
286 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
287 {
288     DiracFrame *remove_pic = NULL;
289     int i, remove_idx = -1;
290
291     for (i = 0; framelist[i]; i++)
292         if (framelist[i]->avframe.display_picture_number == picnum) {
293             remove_pic = framelist[i];
294             remove_idx = i;
295         }
296
297     if (remove_pic)
298         for (i = remove_idx; framelist[i]; i++)
299             framelist[i] = framelist[i+1];
300
301     return remove_pic;
302 }
303
304 static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
305 {
306     int i;
307     for (i = 0; i < maxframes; i++)
308         if (!framelist[i]) {
309             framelist[i] = frame;
310             return 0;
311         }
312     return -1;
313 }
314
315 static int alloc_sequence_buffers(DiracContext *s)
316 {
317     int sbwidth  = DIVRNDUP(s->source.width,  4);
318     int sbheight = DIVRNDUP(s->source.height, 4);
319     int i, w, h, top_padding;
320
321     /* todo: think more about this / use or set Plane here */
322     for (i = 0; i < 3; i++) {
323         int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
324         int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
325         w = s->source.width  >> (i ? s->chroma_x_shift : 0);
326         h = s->source.height >> (i ? s->chroma_y_shift : 0);
327
328         /* we allocate the max we support here since num decompositions can
329          * change from frame to frame. Stride is aligned to 16 for SIMD, and
330          * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
331          * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
332          * on each side */
333         top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
334         w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
335         h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
336
337         s->plane[i].idwt_buf_base = av_mallocz((w+max_xblen)*h * sizeof(IDWTELEM));
338         s->plane[i].idwt_tmp      = av_malloc((w+16) * sizeof(IDWTELEM));
339         s->plane[i].idwt_buf      = s->plane[i].idwt_buf_base + top_padding*w;
340         if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
341             return AVERROR(ENOMEM);
342     }
343
344     w = s->source.width;
345     h = s->source.height;
346
347     /* fixme: allocate using real stride here */
348     s->sbsplit  = av_malloc(sbwidth * sbheight);
349     s->blmotion = av_malloc(sbwidth * sbheight * 16 * sizeof(*s->blmotion));
350     s->edge_emu_buffer_base = av_malloc((w+64)*MAX_BLOCKSIZE);
351
352     s->mctmp     = av_malloc((w+64+MAX_BLOCKSIZE) * (h*MAX_BLOCKSIZE) * sizeof(*s->mctmp));
353     s->mcscratch = av_malloc((w+64)*MAX_BLOCKSIZE);
354
355     if (!s->sbsplit || !s->blmotion)
356         return AVERROR(ENOMEM);
357     return 0;
358 }
359
360 static void free_sequence_buffers(DiracContext *s)
361 {
362     int i, j, k;
363
364     for (i = 0; i < MAX_FRAMES; i++) {
365         if (s->all_frames[i].avframe.data[0]) {
366             s->avctx->release_buffer(s->avctx, &s->all_frames[i].avframe);
367             memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
368         }
369
370         for (j = 0; j < 3; j++)
371             for (k = 1; k < 4; k++)
372                 av_freep(&s->all_frames[i].hpel_base[j][k]);
373     }
374
375     memset(s->ref_frames, 0, sizeof(s->ref_frames));
376     memset(s->delay_frames, 0, sizeof(s->delay_frames));
377
378     for (i = 0; i < 3; i++) {
379         av_freep(&s->plane[i].idwt_buf_base);
380         av_freep(&s->plane[i].idwt_tmp);
381     }
382
383     av_freep(&s->sbsplit);
384     av_freep(&s->blmotion);
385     av_freep(&s->edge_emu_buffer_base);
386
387     av_freep(&s->mctmp);
388     av_freep(&s->mcscratch);
389 }
390
391 static av_cold int dirac_decode_init(AVCodecContext *avctx)
392 {
393     DiracContext *s = avctx->priv_data;
394     s->avctx = avctx;
395     s->frame_number = -1;
396
397     if (avctx->flags&CODEC_FLAG_EMU_EDGE) {
398         av_log(avctx, AV_LOG_ERROR, "Edge emulation not supported!\n");
399         return AVERROR_PATCHWELCOME;
400     }
401
402     ff_dsputil_init(&s->dsp, avctx);
403     ff_diracdsp_init(&s->diracdsp);
404
405     return 0;
406 }
407
408 static void dirac_decode_flush(AVCodecContext *avctx)
409 {
410     DiracContext *s = avctx->priv_data;
411     free_sequence_buffers(s);
412     s->seen_sequence_header = 0;
413     s->frame_number = -1;
414 }
415
416 static av_cold int dirac_decode_end(AVCodecContext *avctx)
417 {
418     dirac_decode_flush(avctx);
419     return 0;
420 }
421
422 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
423
424 static inline void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset,
425                                       SubBand *b, IDWTELEM *buf, int x, int y)
426 {
427     int coeff, sign;
428     int sign_pred = 0;
429     int pred_ctx = CTX_ZPZN_F1;
430
431     /* Check if the parent subband has a 0 in the corresponding position */
432     if (b->parent)
433         pred_ctx += !!b->parent->ibuf[b->parent->stride * (y>>1) + (x>>1)] << 1;
434
435     if (b->orientation == subband_hl)
436         sign_pred = buf[-b->stride];
437
438     /* Determine if the pixel has only zeros in its neighbourhood */
439     if (x) {
440         pred_ctx += !(buf[-1] | buf[-b->stride] | buf[-1-b->stride]);
441         if (b->orientation == subband_lh)
442             sign_pred = buf[-1];
443     } else {
444         pred_ctx += !buf[-b->stride];
445     }
446
447     coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA);
448     if (coeff) {
449         coeff = (coeff * qfactor + qoffset + 2) >> 2;
450         sign  = dirac_get_arith_bit(c, SIGN_CTX(sign_pred));
451         coeff = (coeff ^ -sign) + sign;
452     }
453     *buf = coeff;
454 }
455
456 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
457 {
458     int sign, coeff;
459
460     coeff = svq3_get_ue_golomb(gb);
461     if (coeff) {
462         coeff = (coeff * qfactor + qoffset + 2) >> 2;
463         sign  = get_bits1(gb);
464         coeff = (coeff ^ -sign) + sign;
465     }
466     return coeff;
467 }
468
469 /**
470  * Decode the coeffs in the rectangle defined by left, right, top, bottom
471  * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
472  */
473 static inline void codeblock(DiracContext *s, SubBand *b,
474                              GetBitContext *gb, DiracArith *c,
475                              int left, int right, int top, int bottom,
476                              int blockcnt_one, int is_arith)
477 {
478     int x, y, zero_block;
479     int qoffset, qfactor;
480     IDWTELEM *buf;
481
482     /* check for any coded coefficients in this codeblock */
483     if (!blockcnt_one) {
484         if (is_arith)
485             zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
486         else
487             zero_block = get_bits1(gb);
488
489         if (zero_block)
490             return;
491     }
492
493     if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
494         int quant = b->quant;
495         if (is_arith)
496             quant += dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
497         else
498             quant += dirac_get_se_golomb(gb);
499         if (quant < 0) {
500             av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
501             return;
502         }
503         b->quant = quant;
504     }
505
506     b->quant = FFMIN(b->quant, MAX_QUANT);
507
508     qfactor = qscale_tab[b->quant];
509     /* TODO: context pointer? */
510     if (!s->num_refs)
511         qoffset = qoffset_intra_tab[b->quant];
512     else
513         qoffset = qoffset_inter_tab[b->quant];
514
515     buf = b->ibuf + top * b->stride;
516     for (y = top; y < bottom; y++) {
517         for (x = left; x < right; x++) {
518             /* [DIRAC_STD] 13.4.4 Subband coefficients. coeff_unpack() */
519             if (is_arith)
520                 coeff_unpack_arith(c, qfactor, qoffset, b, buf+x, x, y);
521             else
522                 buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
523         }
524         buf += b->stride;
525     }
526 }
527
528 /**
529  * Dirac Specification ->
530  * 13.3 intra_dc_prediction(band)
531  */
532 static inline void intra_dc_prediction(SubBand *b)
533 {
534     IDWTELEM *buf = b->ibuf;
535     int x, y;
536
537     for (x = 1; x < b->width; x++)
538         buf[x] += buf[x-1];
539     buf += b->stride;
540
541     for (y = 1; y < b->height; y++) {
542         buf[0] += buf[-b->stride];
543
544         for (x = 1; x < b->width; x++) {
545             int pred = buf[x - 1] + buf[x - b->stride] + buf[x - b->stride-1];
546             buf[x]  += divide3(pred);
547         }
548         buf += b->stride;
549     }
550 }
551
552 /**
553  * Dirac Specification ->
554  * 13.4.2 Non-skipped subbands.  subband_coeffs()
555  */
556 static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
557 {
558     int cb_x, cb_y, left, right, top, bottom;
559     DiracArith c;
560     GetBitContext gb;
561     int cb_width  = s->codeblock[b->level + (b->orientation != subband_ll)].width;
562     int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
563     int blockcnt_one = (cb_width + cb_height) == 2;
564
565     if (!b->length)
566         return;
567
568     init_get_bits(&gb, b->coeff_data, b->length*8);
569
570     if (is_arith)
571         ff_dirac_init_arith_decoder(&c, &gb, b->length);
572
573     top = 0;
574     for (cb_y = 0; cb_y < cb_height; cb_y++) {
575         bottom = (b->height * (cb_y+1)) / cb_height;
576         left = 0;
577         for (cb_x = 0; cb_x < cb_width; cb_x++) {
578             right = (b->width * (cb_x+1)) / cb_width;
579             codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
580             left = right;
581         }
582         top = bottom;
583     }
584
585     if (b->orientation == subband_ll && s->num_refs == 0)
586         intra_dc_prediction(b);
587 }
588
589 static int decode_subband_arith(AVCodecContext *avctx, void *b)
590 {
591     DiracContext *s = avctx->priv_data;
592     decode_subband_internal(s, b, 1);
593     return 0;
594 }
595
596 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
597 {
598     DiracContext *s = avctx->priv_data;
599     SubBand **b     = arg;
600     decode_subband_internal(s, *b, 0);
601     return 0;
602 }
603
604 /**
605  * Dirac Specification ->
606  * [DIRAC_STD] 13.4.1 core_transform_data()
607  */
608 static void decode_component(DiracContext *s, int comp)
609 {
610     AVCodecContext *avctx = s->avctx;
611     SubBand *bands[3*MAX_DWT_LEVELS+1];
612     enum dirac_subband orientation;
613     int level, num_bands = 0;
614
615     /* Unpack all subbands at all levels. */
616     for (level = 0; level < s->wavelet_depth; level++) {
617         for (orientation = !!level; orientation < 4; orientation++) {
618             SubBand *b = &s->plane[comp].band[level][orientation];
619             bands[num_bands++] = b;
620
621             align_get_bits(&s->gb);
622             /* [DIRAC_STD] 13.4.2 subband() */
623             b->length = svq3_get_ue_golomb(&s->gb);
624             if (b->length) {
625                 b->quant = svq3_get_ue_golomb(&s->gb);
626                 align_get_bits(&s->gb);
627                 b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
628                 b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
629                 skip_bits_long(&s->gb, b->length*8);
630             }
631         }
632         /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
633         if (s->is_arith)
634             avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
635                            NULL, 4-!!level, sizeof(SubBand));
636     }
637     /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
638     if (!s->is_arith)
639         avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
640 }
641
642 /* [DIRAC_STD] 13.5.5.2 Luma slice subband data. luma_slice_band(level,orient,sx,sy) --> if b2 == NULL */
643 /* [DIRAC_STD] 13.5.5.3 Chroma slice subband data. chroma_slice_band(level,orient,sx,sy) --> if b2 != NULL */
644 static void lowdelay_subband(DiracContext *s, GetBitContext *gb, int quant,
645                              int slice_x, int slice_y, int bits_end,
646                              SubBand *b1, SubBand *b2)
647 {
648     int left   = b1->width  * slice_x    / s->lowdelay.num_x;
649     int right  = b1->width  *(slice_x+1) / s->lowdelay.num_x;
650     int top    = b1->height * slice_y    / s->lowdelay.num_y;
651     int bottom = b1->height *(slice_y+1) / s->lowdelay.num_y;
652
653     int qfactor = qscale_tab[FFMIN(quant, MAX_QUANT)];
654     int qoffset = qoffset_intra_tab[FFMIN(quant, MAX_QUANT)];
655
656     IDWTELEM *buf1 =      b1->ibuf + top * b1->stride;
657     IDWTELEM *buf2 = b2 ? b2->ibuf + top * b2->stride : NULL;
658     int x, y;
659     /* we have to constantly check for overread since the spec explictly
660        requires this, with the meaning that all remaining coeffs are set to 0 */
661     if (get_bits_count(gb) >= bits_end)
662         return;
663
664     for (y = top; y < bottom; y++) {
665         for (x = left; x < right; x++) {
666             buf1[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
667             if (get_bits_count(gb) >= bits_end)
668                 return;
669             if (buf2) {
670                 buf2[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
671                 if (get_bits_count(gb) >= bits_end)
672                     return;
673             }
674         }
675         buf1 += b1->stride;
676         if (buf2)
677             buf2 += b2->stride;
678     }
679 }
680
681 struct lowdelay_slice {
682     GetBitContext gb;
683     int slice_x;
684     int slice_y;
685     int bytes;
686 };
687
688
689 /**
690  * Dirac Specification ->
691  * 13.5.2 Slices. slice(sx,sy)
692  */
693 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
694 {
695     DiracContext *s = avctx->priv_data;
696     struct lowdelay_slice *slice = arg;
697     GetBitContext *gb = &slice->gb;
698     enum dirac_subband orientation;
699     int level, quant, chroma_bits, chroma_end;
700
701     int quant_base  = get_bits(gb, 7); /*[DIRAC_STD] qindex */
702     int length_bits = av_log2(8 * slice->bytes)+1;
703     int luma_bits   = get_bits_long(gb, length_bits);
704     int luma_end    = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
705
706     /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
707     for (level = 0; level < s->wavelet_depth; level++)
708         for (orientation = !!level; orientation < 4; orientation++) {
709             quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
710             lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
711                              &s->plane[0].band[level][orientation], NULL);
712         }
713
714     /* consume any unused bits from luma */
715     skip_bits_long(gb, get_bits_count(gb) - luma_end);
716
717     chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
718     chroma_end  = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
719     /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
720     for (level = 0; level < s->wavelet_depth; level++)
721         for (orientation = !!level; orientation < 4; orientation++) {
722             quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
723             lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
724                              &s->plane[1].band[level][orientation],
725                              &s->plane[2].band[level][orientation]);
726         }
727
728     return 0;
729 }
730
731 /**
732  * Dirac Specification ->
733  * 13.5.1 low_delay_transform_data()
734  */
735 static void decode_lowdelay(DiracContext *s)
736 {
737     AVCodecContext *avctx = s->avctx;
738     int slice_x, slice_y, bytes, bufsize;
739     const uint8_t *buf;
740     struct lowdelay_slice *slices;
741     int slice_num = 0;
742
743     slices = av_mallocz(s->lowdelay.num_x * s->lowdelay.num_y * sizeof(struct lowdelay_slice));
744
745     align_get_bits(&s->gb);
746     /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
747     buf = s->gb.buffer + get_bits_count(&s->gb)/8;
748     bufsize = get_bits_left(&s->gb);
749
750     for (slice_y = 0; bufsize > 0 && slice_y < s->lowdelay.num_y; slice_y++)
751         for (slice_x = 0; bufsize > 0 && slice_x < s->lowdelay.num_x; slice_x++) {
752             bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
753                 - slice_num    * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
754
755             slices[slice_num].bytes   = bytes;
756             slices[slice_num].slice_x = slice_x;
757             slices[slice_num].slice_y = slice_y;
758             init_get_bits(&slices[slice_num].gb, buf, bufsize);
759             slice_num++;
760
761             buf     += bytes;
762             bufsize -= bytes*8;
763         }
764
765     avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
766                    sizeof(struct lowdelay_slice)); /* [DIRAC_STD] 13.5.2 Slices */
767     intra_dc_prediction(&s->plane[0].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
768     intra_dc_prediction(&s->plane[1].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
769     intra_dc_prediction(&s->plane[2].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
770     av_free(slices);
771 }
772
773 static void init_planes(DiracContext *s)
774 {
775     int i, w, h, level, orientation;
776
777     for (i = 0; i < 3; i++) {
778         Plane *p = &s->plane[i];
779
780         p->width       = s->source.width  >> (i ? s->chroma_x_shift : 0);
781         p->height      = s->source.height >> (i ? s->chroma_y_shift : 0);
782         p->idwt_width  = w = CALC_PADDING(p->width , s->wavelet_depth);
783         p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
784         p->idwt_stride = FFALIGN(p->idwt_width, 8);
785
786         for (level = s->wavelet_depth-1; level >= 0; level--) {
787             w = w>>1;
788             h = h>>1;
789             for (orientation = !!level; orientation < 4; orientation++) {
790                 SubBand *b = &p->band[level][orientation];
791
792                 b->ibuf   = p->idwt_buf;
793                 b->level  = level;
794                 b->stride = p->idwt_stride << (s->wavelet_depth - level);
795                 b->width  = w;
796                 b->height = h;
797                 b->orientation = orientation;
798
799                 if (orientation & 1)
800                     b->ibuf += w;
801                 if (orientation > 1)
802                     b->ibuf += b->stride>>1;
803
804                 if (level)
805                     b->parent = &p->band[level-1][orientation];
806             }
807         }
808
809         if (i > 0) {
810             p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
811             p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
812             p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
813             p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
814         }
815
816         p->xoffset = (p->xblen - p->xbsep)/2;
817         p->yoffset = (p->yblen - p->ybsep)/2;
818     }
819 }
820
821 /**
822  * Unpack the motion compensation parameters
823  * Dirac Specification ->
824  * 11.2 Picture prediction data. picture_prediction()
825  */
826 static int dirac_unpack_prediction_parameters(DiracContext *s)
827 {
828     static const uint8_t default_blen[] = { 4, 12, 16, 24 };
829     static const uint8_t default_bsep[] = { 4,  8, 12, 16 };
830
831     GetBitContext *gb = &s->gb;
832     unsigned idx, ref;
833
834     align_get_bits(gb);
835     /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
836     /* Luma and Chroma are equal. 11.2.3 */
837     idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
838
839     if (idx > 4) {
840         av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
841         return -1;
842     }
843
844     if (idx == 0) {
845         s->plane[0].xblen = svq3_get_ue_golomb(gb);
846         s->plane[0].yblen = svq3_get_ue_golomb(gb);
847         s->plane[0].xbsep = svq3_get_ue_golomb(gb);
848         s->plane[0].ybsep = svq3_get_ue_golomb(gb);
849     } else {
850         /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
851         s->plane[0].xblen = default_blen[idx-1];
852         s->plane[0].yblen = default_blen[idx-1];
853         s->plane[0].xbsep = default_bsep[idx-1];
854         s->plane[0].ybsep = default_bsep[idx-1];
855     }
856     /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
857       Calculated in function dirac_unpack_block_motion_data */
858
859     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) {
860         av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
861         return -1;
862     }
863     if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
864         av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
865         return -1;
866     }
867     if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
868         av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
869         return -1;
870     }
871
872     /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
873       Read motion vector precision */
874     s->mv_precision = svq3_get_ue_golomb(gb);
875     if (s->mv_precision > 3) {
876         av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
877         return -1;
878     }
879
880     /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
881       Read the global motion compensation parameters */
882     s->globalmc_flag = get_bits1(gb);
883     if (s->globalmc_flag) {
884         memset(s->globalmc, 0, sizeof(s->globalmc));
885         /* [DIRAC_STD] pan_tilt(gparams) */
886         for (ref = 0; ref < s->num_refs; ref++) {
887             if (get_bits1(gb)) {
888                 s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
889                 s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
890             }
891             /* [DIRAC_STD] zoom_rotate_shear(gparams)
892                zoom/rotation/shear parameters */
893             if (get_bits1(gb)) {
894                 s->globalmc[ref].zrs_exp   = svq3_get_ue_golomb(gb);
895                 s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
896                 s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
897                 s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
898                 s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
899             } else {
900                 s->globalmc[ref].zrs[0][0] = 1;
901                 s->globalmc[ref].zrs[1][1] = 1;
902             }
903             /* [DIRAC_STD] perspective(gparams) */
904             if (get_bits1(gb)) {
905                 s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
906                 s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
907                 s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
908             }
909         }
910     }
911
912     /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
913       Picture prediction mode, not currently used. */
914     if (svq3_get_ue_golomb(gb)) {
915         av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
916         return -1;
917     }
918
919     /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
920        just data read, weight calculation will be done later on. */
921     s->weight_log2denom = 1;
922     s->weight[0]        = 1;
923     s->weight[1]        = 1;
924
925     if (get_bits1(gb)) {
926         s->weight_log2denom = svq3_get_ue_golomb(gb);
927         s->weight[0] = dirac_get_se_golomb(gb);
928         if (s->num_refs == 2)
929             s->weight[1] = dirac_get_se_golomb(gb);
930     }
931     return 0;
932 }
933
934 /**
935  * Dirac Specification ->
936  * 11.3 Wavelet transform data. wavelet_transform()
937  */
938 static int dirac_unpack_idwt_params(DiracContext *s)
939 {
940     GetBitContext *gb = &s->gb;
941     int i, level;
942     unsigned tmp;
943
944 #define CHECKEDREAD(dst, cond, errmsg) \
945     tmp = svq3_get_ue_golomb(gb); \
946     if (cond) { \
947         av_log(s->avctx, AV_LOG_ERROR, errmsg); \
948         return -1; \
949     }\
950     dst = tmp;
951
952     align_get_bits(gb);
953
954     s->zero_res = s->num_refs ? get_bits1(gb) : 0;
955     if (s->zero_res)
956         return 0;
957
958     /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
959     CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
960
961     CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
962
963     if (!s->low_delay) {
964         /* Codeblock parameters (core syntax only) */
965         if (get_bits1(gb)) {
966             for (i = 0; i <= s->wavelet_depth; i++) {
967                 CHECKEDREAD(s->codeblock[i].width , tmp < 1, "codeblock width invalid\n")
968                 CHECKEDREAD(s->codeblock[i].height, tmp < 1, "codeblock height invalid\n")
969             }
970
971             CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
972         } else
973             for (i = 0; i <= s->wavelet_depth; i++)
974                 s->codeblock[i].width = s->codeblock[i].height = 1;
975     } else {
976         /* Slice parameters + quantization matrix*/
977         /*[DIRAC_STD] 11.3.4 Slice coding Parameters (low delay syntax only). slice_parameters() */
978         s->lowdelay.num_x     = svq3_get_ue_golomb(gb);
979         s->lowdelay.num_y     = svq3_get_ue_golomb(gb);
980         s->lowdelay.bytes.num = svq3_get_ue_golomb(gb);
981         s->lowdelay.bytes.den = svq3_get_ue_golomb(gb);
982
983         if (s->lowdelay.bytes.den <= 0) {
984             av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
985             return AVERROR_INVALIDDATA;
986         }
987
988         /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
989         if (get_bits1(gb)) {
990             av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
991             /* custom quantization matrix */
992             s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
993             for (level = 0; level < s->wavelet_depth; level++) {
994                 s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
995                 s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
996                 s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
997             }
998         } else {
999             /* default quantization matrix */
1000             for (level = 0; level < s->wavelet_depth; level++)
1001                 for (i = 0; i < 4; i++) {
1002                     s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1003                     /* haar with no shift differs for different depths */
1004                     if (s->wavelet_idx == 3)
1005                         s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1006                 }
1007         }
1008     }
1009     return 0;
1010 }
1011
1012 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1013 {
1014     static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1015
1016     if (!(x|y))
1017         return 0;
1018     else if (!y)
1019         return sbsplit[-1];
1020     else if (!x)
1021         return sbsplit[-stride];
1022
1023     return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1024 }
1025
1026 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1027 {
1028     int pred;
1029
1030     if (!(x|y))
1031         return 0;
1032     else if (!y)
1033         return block[-1].ref & refmask;
1034     else if (!x)
1035         return block[-stride].ref & refmask;
1036
1037     /* return the majority */
1038     pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1039     return (pred >> 1) & refmask;
1040 }
1041
1042 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1043 {
1044     int i, n = 0;
1045
1046     memset(block->u.dc, 0, sizeof(block->u.dc));
1047
1048     if (x && !(block[-1].ref & 3)) {
1049         for (i = 0; i < 3; i++)
1050             block->u.dc[i] += block[-1].u.dc[i];
1051         n++;
1052     }
1053
1054     if (y && !(block[-stride].ref & 3)) {
1055         for (i = 0; i < 3; i++)
1056             block->u.dc[i] += block[-stride].u.dc[i];
1057         n++;
1058     }
1059
1060     if (x && y && !(block[-1-stride].ref & 3)) {
1061         for (i = 0; i < 3; i++)
1062             block->u.dc[i] += block[-1-stride].u.dc[i];
1063         n++;
1064     }
1065
1066     if (n == 2) {
1067         for (i = 0; i < 3; i++)
1068             block->u.dc[i] = (block->u.dc[i]+1)>>1;
1069     } else if (n == 3) {
1070         for (i = 0; i < 3; i++)
1071             block->u.dc[i] = divide3(block->u.dc[i]);
1072     }
1073 }
1074
1075 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1076 {
1077     int16_t *pred[3];
1078     int refmask = ref+1;
1079     int mask = refmask | DIRAC_REF_MASK_GLOBAL; /*  exclude gmc blocks */
1080     int n = 0;
1081
1082     if (x && (block[-1].ref & mask) == refmask)
1083         pred[n++] = block[-1].u.mv[ref];
1084
1085     if (y && (block[-stride].ref & mask) == refmask)
1086         pred[n++] = block[-stride].u.mv[ref];
1087
1088     if (x && y && (block[-stride-1].ref & mask) == refmask)
1089         pred[n++] = block[-stride-1].u.mv[ref];
1090
1091     switch (n) {
1092     case 0:
1093         block->u.mv[ref][0] = 0;
1094         block->u.mv[ref][1] = 0;
1095         break;
1096     case 1:
1097         block->u.mv[ref][0] = pred[0][0];
1098         block->u.mv[ref][1] = pred[0][1];
1099         break;
1100     case 2:
1101         block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1102         block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1103         break;
1104     case 3:
1105         block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1106         block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1107         break;
1108     }
1109 }
1110
1111 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1112 {
1113     int ez      = s->globalmc[ref].zrs_exp;
1114     int ep      = s->globalmc[ref].perspective_exp;
1115     int (*A)[2] = s->globalmc[ref].zrs;
1116     int *b      = s->globalmc[ref].pan_tilt;
1117     int *c      = s->globalmc[ref].perspective;
1118
1119     int m       = (1<<ep) - (c[0]*x + c[1]*y);
1120     int mx      = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1121     int my      = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1122
1123     block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1124     block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1125 }
1126
1127 static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
1128                                 int stride, int x, int y)
1129 {
1130     int i;
1131
1132     block->ref  = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1133     block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1134
1135     if (s->num_refs == 2) {
1136         block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1137         block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1138     }
1139
1140     if (!block->ref) {
1141         pred_block_dc(block, stride, x, y);
1142         for (i = 0; i < 3; i++)
1143             block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1144         return;
1145     }
1146
1147     if (s->globalmc_flag) {
1148         block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1149         block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1150     }
1151
1152     for (i = 0; i < s->num_refs; i++)
1153         if (block->ref & (i+1)) {
1154             if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1155                 global_mv(s, block, x, y, i);
1156             } else {
1157                 pred_mv(block, stride, x, y, i);
1158                 block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1159                 block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1160             }
1161         }
1162 }
1163
1164 /**
1165  * Copies the current block to the other blocks covered by the current superblock split mode
1166  */
1167 static void propagate_block_data(DiracBlock *block, int stride, int size)
1168 {
1169     int x, y;
1170     DiracBlock *dst = block;
1171
1172     for (x = 1; x < size; x++)
1173         dst[x] = *block;
1174
1175     for (y = 1; y < size; y++) {
1176         dst += stride;
1177         for (x = 0; x < size; x++)
1178             dst[x] = *block;
1179     }
1180 }
1181
1182 /**
1183  * Dirac Specification ->
1184  * 12. Block motion data syntax
1185  */
1186 static int dirac_unpack_block_motion_data(DiracContext *s)
1187 {
1188     GetBitContext *gb = &s->gb;
1189     uint8_t *sbsplit = s->sbsplit;
1190     int i, x, y, q, p;
1191     DiracArith arith[8];
1192
1193     align_get_bits(gb);
1194
1195     /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1196     s->sbwidth  = DIVRNDUP(s->source.width,  4*s->plane[0].xbsep);
1197     s->sbheight = DIVRNDUP(s->source.height, 4*s->plane[0].ybsep);
1198     s->blwidth  = 4 * s->sbwidth;
1199     s->blheight = 4 * s->sbheight;
1200
1201     /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1202        decode superblock split modes */
1203     ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));     /* svq3_get_ue_golomb(gb) is the length */
1204     for (y = 0; y < s->sbheight; y++) {
1205         for (x = 0; x < s->sbwidth; x++) {
1206             unsigned int split  = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1207             if (split > 2)
1208                 return -1;
1209             sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1210         }
1211         sbsplit += s->sbwidth;
1212     }
1213
1214     /* setup arith decoding */
1215     ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));
1216     for (i = 0; i < s->num_refs; i++) {
1217         ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1218         ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1219     }
1220     for (i = 0; i < 3; i++)
1221         ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1222
1223     for (y = 0; y < s->sbheight; y++)
1224         for (x = 0; x < s->sbwidth; x++) {
1225             int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1226             int step   = 4 >> s->sbsplit[y * s->sbwidth + x];
1227
1228             for (q = 0; q < blkcnt; q++)
1229                 for (p = 0; p < blkcnt; p++) {
1230                     int bx = 4 * x + p*step;
1231                     int by = 4 * y + q*step;
1232                     DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1233                     decode_block_params(s, arith, block, s->blwidth, bx, by);
1234                     propagate_block_data(block, s->blwidth, step);
1235                 }
1236         }
1237
1238     return 0;
1239 }
1240
1241 static int weight(int i, int blen, int offset)
1242 {
1243 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) :        \
1244     (1 + (6*(i) + offset - 1) / (2*offset - 1))
1245
1246     if (i < 2*offset)
1247         return ROLLOFF(i);
1248     else if (i > blen-1 - 2*offset)
1249         return ROLLOFF(blen-1 - i);
1250     return 8;
1251 }
1252
1253 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1254                                  int left, int right, int wy)
1255 {
1256     int x;
1257     for (x = 0; left && x < p->xblen >> 1; x++)
1258         obmc_weight[x] = wy*8;
1259     for (; x < p->xblen >> right; x++)
1260         obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1261     for (; x < p->xblen; x++)
1262         obmc_weight[x] = wy*8;
1263     for (; x < stride; x++)
1264         obmc_weight[x] = 0;
1265 }
1266
1267 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1268                              int left, int right, int top, int bottom)
1269 {
1270     int y;
1271     for (y = 0; top && y < p->yblen >> 1; y++) {
1272         init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1273         obmc_weight += stride;
1274     }
1275     for (; y < p->yblen >> bottom; y++) {
1276         int wy = weight(y, p->yblen, p->yoffset);
1277         init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1278         obmc_weight += stride;
1279     }
1280     for (; y < p->yblen; y++) {
1281         init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1282         obmc_weight += stride;
1283     }
1284 }
1285
1286 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1287 {
1288     int top = !by;
1289     int bottom = by == s->blheight-1;
1290
1291     /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1292     if (top || bottom || by == 1) {
1293         init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1294         init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1295         init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1296     }
1297 }
1298
1299 static const uint8_t epel_weights[4][4][4] = {
1300     {{ 16,  0,  0,  0 },
1301      { 12,  4,  0,  0 },
1302      {  8,  8,  0,  0 },
1303      {  4, 12,  0,  0 }},
1304     {{ 12,  0,  4,  0 },
1305      {  9,  3,  3,  1 },
1306      {  6,  6,  2,  2 },
1307      {  3,  9,  1,  3 }},
1308     {{  8,  0,  8,  0 },
1309      {  6,  2,  6,  2 },
1310      {  4,  4,  4,  4 },
1311      {  2,  6,  2,  6 }},
1312     {{  4,  0, 12,  0 },
1313      {  3,  1,  9,  3 },
1314      {  2,  2,  6,  6 },
1315      {  1,  3,  3,  9 }}
1316 };
1317
1318 /**
1319  * For block x,y, determine which of the hpel planes to do bilinear
1320  * interpolation from and set src[] to the location in each hpel plane
1321  * to MC from.
1322  *
1323  * @return the index of the put_dirac_pixels_tab function to use
1324  *  0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1325  */
1326 static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
1327                      int x, int y, int ref, int plane)
1328 {
1329     Plane *p = &s->plane[plane];
1330     uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1331     int motion_x = block->u.mv[ref][0];
1332     int motion_y = block->u.mv[ref][1];
1333     int mx, my, i, epel, nplanes = 0;
1334
1335     if (plane) {
1336         motion_x >>= s->chroma_x_shift;
1337         motion_y >>= s->chroma_y_shift;
1338     }
1339
1340     mx         = motion_x & ~(-1 << s->mv_precision);
1341     my         = motion_y & ~(-1 << s->mv_precision);
1342     motion_x >>= s->mv_precision;
1343     motion_y >>= s->mv_precision;
1344     /* normalize subpel coordinates to epel */
1345     /* TODO: template this function? */
1346     mx      <<= 3 - s->mv_precision;
1347     my      <<= 3 - s->mv_precision;
1348
1349     x += motion_x;
1350     y += motion_y;
1351     epel = (mx|my)&1;
1352
1353     /* hpel position */
1354     if (!((mx|my)&3)) {
1355         nplanes = 1;
1356         src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1357     } else {
1358         /* qpel or epel */
1359         nplanes = 4;
1360         for (i = 0; i < 4; i++)
1361             src[i] = ref_hpel[i] + y*p->stride + x;
1362
1363         /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1364            we increment x/y because the edge changes for half of the pixels */
1365         if (mx > 4) {
1366             src[0] += 1;
1367             src[2] += 1;
1368             x++;
1369         }
1370         if (my > 4) {
1371             src[0] += p->stride;
1372             src[1] += p->stride;
1373             y++;
1374         }
1375
1376         /* hpel planes are:
1377            [0]: F  [1]: H
1378            [2]: V  [3]: C */
1379         if (!epel) {
1380             /* check if we really only need 2 planes since either mx or my is
1381                a hpel position. (epel weights of 0 handle this there) */
1382             if (!(mx&3)) {
1383                 /* mx == 0: average [0] and [2]
1384                    mx == 4: average [1] and [3] */
1385                 src[!mx] = src[2 + !!mx];
1386                 nplanes = 2;
1387             } else if (!(my&3)) {
1388                 src[0] = src[(my>>1)  ];
1389                 src[1] = src[(my>>1)+1];
1390                 nplanes = 2;
1391             }
1392         } else {
1393             /* adjust the ordering if needed so the weights work */
1394             if (mx > 4) {
1395                 FFSWAP(const uint8_t *, src[0], src[1]);
1396                 FFSWAP(const uint8_t *, src[2], src[3]);
1397             }
1398             if (my > 4) {
1399                 FFSWAP(const uint8_t *, src[0], src[2]);
1400                 FFSWAP(const uint8_t *, src[1], src[3]);
1401             }
1402             src[4] = epel_weights[my&3][mx&3];
1403         }
1404     }
1405
1406     /* fixme: v/h _edge_pos */
1407     if ((unsigned)x > FFMAX(p->width +EDGE_WIDTH/2 - p->xblen, 0) ||
1408         (unsigned)y > FFMAX(p->height+EDGE_WIDTH/2 - p->yblen, 0)) {
1409         for (i = 0; i < nplanes; i++) {
1410             ff_emulated_edge_mc(s->edge_emu_buffer[i], src[i], p->stride,
1411                                 p->xblen, p->yblen, x, y,
1412                                 p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1413             src[i] = s->edge_emu_buffer[i];
1414         }
1415     }
1416     return (nplanes>>1) + epel;
1417 }
1418
1419 static void add_dc(uint16_t *dst, int dc, int stride,
1420                    uint8_t *obmc_weight, int xblen, int yblen)
1421 {
1422     int x, y;
1423     dc += 128;
1424
1425     for (y = 0; y < yblen; y++) {
1426         for (x = 0; x < xblen; x += 2) {
1427             dst[x  ] += dc * obmc_weight[x  ];
1428             dst[x+1] += dc * obmc_weight[x+1];
1429         }
1430         dst          += stride;
1431         obmc_weight  += MAX_BLOCKSIZE;
1432     }
1433 }
1434
1435 static void block_mc(DiracContext *s, DiracBlock *block,
1436                      uint16_t *mctmp, uint8_t *obmc_weight,
1437                      int plane, int dstx, int dsty)
1438 {
1439     Plane *p = &s->plane[plane];
1440     const uint8_t *src[5];
1441     int idx;
1442
1443     switch (block->ref&3) {
1444     case 0: /* DC */
1445         add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1446         return;
1447     case 1:
1448     case 2:
1449         idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1450         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1451         if (s->weight_func)
1452             s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1453                            s->weight[0] + s->weight[1], p->yblen);
1454         break;
1455     case 3:
1456         idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1457         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1458         idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1459         if (s->biweight_func) {
1460             /* fixme: +32 is a quick hack */
1461             s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1462             s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1463                              s->weight[0], s->weight[1], p->yblen);
1464         } else
1465             s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1466         break;
1467     }
1468     s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1469 }
1470
1471 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1472 {
1473     Plane *p = &s->plane[plane];
1474     int x, dstx = p->xbsep - p->xoffset;
1475
1476     block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1477     mctmp += p->xbsep;
1478
1479     for (x = 1; x < s->blwidth-1; x++) {
1480         block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1481         dstx  += p->xbsep;
1482         mctmp += p->xbsep;
1483     }
1484     block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1485 }
1486
1487 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1488 {
1489     int idx = 0;
1490     if (xblen > 8)
1491         idx = 1;
1492     if (xblen > 16)
1493         idx = 2;
1494
1495     memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1496     memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1497     s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1498     if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1499         s->weight_func   = s->diracdsp.weight_dirac_pixels_tab[idx];
1500         s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1501     } else {
1502         s->weight_func   = NULL;
1503         s->biweight_func = NULL;
1504     }
1505 }
1506
1507 static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1508 {
1509     /* chroma allocates an edge of 8 when subsampled
1510        which for 4:2:2 means an h edge of 16 and v edge of 8
1511        just use 8 for everything for the moment */
1512     int i, edge = EDGE_WIDTH/2;
1513
1514     ref->hpel[plane][0] = ref->avframe.data[plane];
1515     s->dsp.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 */
1516
1517     /* no need for hpel if we only have fpel vectors */
1518     if (!s->mv_precision)
1519         return;
1520
1521     for (i = 1; i < 4; i++) {
1522         if (!ref->hpel_base[plane][i])
1523             ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe.linesize[plane] + 32);
1524         /* we need to be 16-byte aligned even for chroma */
1525         ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe.linesize[plane] + 16;
1526     }
1527
1528     if (!ref->interpolated[plane]) {
1529         s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1530                                       ref->hpel[plane][3], ref->hpel[plane][0],
1531                                       ref->avframe.linesize[plane], width, height);
1532         s->dsp.draw_edges(ref->hpel[plane][1], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1533         s->dsp.draw_edges(ref->hpel[plane][2], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1534         s->dsp.draw_edges(ref->hpel[plane][3], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1535     }
1536     ref->interpolated[plane] = 1;
1537 }
1538
1539 /**
1540  * Dirac Specification ->
1541  * 13.0 Transform data syntax. transform_data()
1542  */
1543 static int dirac_decode_frame_internal(DiracContext *s)
1544 {
1545     DWTContext d;
1546     int y, i, comp, dsty;
1547
1548     if (s->low_delay) {
1549         /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1550         for (comp = 0; comp < 3; comp++) {
1551             Plane *p = &s->plane[comp];
1552             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1553         }
1554         if (!s->zero_res)
1555             decode_lowdelay(s);
1556     }
1557
1558     for (comp = 0; comp < 3; comp++) {
1559         Plane *p       = &s->plane[comp];
1560         uint8_t *frame = s->current_picture->avframe.data[comp];
1561
1562         /* FIXME: small resolutions */
1563         for (i = 0; i < 4; i++)
1564             s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1565
1566         if (!s->zero_res && !s->low_delay)
1567         {
1568             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1569             decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1570         }
1571         if (ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
1572                                   s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp))
1573             return -1;
1574
1575         if (!s->num_refs) { /* intra */
1576             for (y = 0; y < p->height; y += 16) {
1577                 ff_spatial_idwt_slice2(&d, y+16); /* decode */
1578                 s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
1579                                                     p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1580             }
1581         } else { /* inter */
1582             int rowheight = p->ybsep*p->stride;
1583
1584             select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1585
1586             for (i = 0; i < s->num_refs; i++)
1587                 interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1588
1589             memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1590
1591             dsty = -p->yoffset;
1592             for (y = 0; y < s->blheight; y++) {
1593                 int h     = 0,
1594                     start = FFMAX(dsty, 0);
1595                 uint16_t *mctmp    = s->mctmp + y*rowheight;
1596                 DiracBlock *blocks = s->blmotion + y*s->blwidth;
1597
1598                 init_obmc_weights(s, p, y);
1599
1600                 if (y == s->blheight-1 || start+p->ybsep > p->height)
1601                     h = p->height - start;
1602                 else
1603                     h = p->ybsep - (start - dsty);
1604                 if (h < 0)
1605                     break;
1606
1607                 memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1608                 mc_row(s, blocks, mctmp, comp, dsty);
1609
1610                 mctmp += (start - dsty)*p->stride + p->xoffset;
1611                 ff_spatial_idwt_slice2(&d, start + h); /* decode */
1612                 s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1613                                              p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
1614
1615                 dsty += p->ybsep;
1616             }
1617         }
1618     }
1619
1620
1621     return 0;
1622 }
1623
1624 /**
1625  * Dirac Specification ->
1626  * 11.1.1 Picture Header. picture_header()
1627  */
1628 static int dirac_decode_picture_header(DiracContext *s)
1629 {
1630     int retire, picnum;
1631     int i, j, refnum, refdist;
1632     GetBitContext *gb = &s->gb;
1633
1634     /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1635     picnum = s->current_picture->avframe.display_picture_number = get_bits_long(gb, 32);
1636
1637
1638     av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1639
1640     /* if this is the first keyframe after a sequence header, start our
1641        reordering from here */
1642     if (s->frame_number < 0)
1643         s->frame_number = picnum;
1644
1645     s->ref_pics[0] = s->ref_pics[1] = NULL;
1646     for (i = 0; i < s->num_refs; i++) {
1647         refnum = picnum + dirac_get_se_golomb(gb);
1648         refdist = INT_MAX;
1649
1650         /* find the closest reference to the one we want */
1651         /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1652         for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1653             if (s->ref_frames[j]
1654                 && FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum) < refdist) {
1655                 s->ref_pics[i] = s->ref_frames[j];
1656                 refdist = FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum);
1657             }
1658
1659         if (!s->ref_pics[i] || refdist)
1660             av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1661
1662         /* if there were no references at all, allocate one */
1663         if (!s->ref_pics[i])
1664             for (j = 0; j < MAX_FRAMES; j++)
1665                 if (!s->all_frames[j].avframe.data[0]) {
1666                     s->ref_pics[i] = &s->all_frames[j];
1667                     s->avctx->get_buffer(s->avctx, &s->ref_pics[i]->avframe);
1668                     break;
1669                 }
1670     }
1671
1672     /* retire the reference frames that are not used anymore */
1673     if (s->current_picture->avframe.reference) {
1674         retire = picnum + dirac_get_se_golomb(gb);
1675         if (retire != picnum) {
1676             DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1677
1678             if (retire_pic)
1679                 retire_pic->avframe.reference &= DELAYED_PIC_REF;
1680             else
1681                 av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1682         }
1683
1684         /* if reference array is full, remove the oldest as per the spec */
1685         while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
1686             av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1687             remove_frame(s->ref_frames, s->ref_frames[0]->avframe.display_picture_number)->avframe.reference &= DELAYED_PIC_REF;
1688         }
1689     }
1690
1691     if (s->num_refs) {
1692         if (dirac_unpack_prediction_parameters(s))  /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1693             return -1;
1694         if (dirac_unpack_block_motion_data(s))      /* [DIRAC_STD] 12. Block motion data syntax                       */
1695             return -1;
1696     }
1697     if (dirac_unpack_idwt_params(s))                /* [DIRAC_STD] 11.3 Wavelet transform data                        */
1698         return -1;
1699
1700     init_planes(s);
1701     return 0;
1702 }
1703
1704 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *data_size)
1705 {
1706     DiracFrame *out = s->delay_frames[0];
1707     int i, out_idx  = 0;
1708
1709     /* find frame with lowest picture number */
1710     for (i = 1; s->delay_frames[i]; i++)
1711         if (s->delay_frames[i]->avframe.display_picture_number < out->avframe.display_picture_number) {
1712             out     = s->delay_frames[i];
1713             out_idx = i;
1714         }
1715
1716     for (i = out_idx; s->delay_frames[i]; i++)
1717         s->delay_frames[i] = s->delay_frames[i+1];
1718
1719     if (out) {
1720         out->avframe.reference ^= DELAYED_PIC_REF;
1721         *data_size = sizeof(AVFrame);
1722         *(AVFrame *)picture = out->avframe;
1723     }
1724
1725     return 0;
1726 }
1727
1728 /**
1729  * Dirac Specification ->
1730  * 9.6 Parse Info Header Syntax. parse_info()
1731  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1732  */
1733 #define DATA_UNIT_HEADER_SIZE 13
1734
1735 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1736    inside the function parse_sequence() */
1737 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1738 {
1739     DiracContext *s   = avctx->priv_data;
1740     DiracFrame *pic   = NULL;
1741     int i, parse_code = buf[4];
1742     unsigned tmp;
1743
1744     if (size < DATA_UNIT_HEADER_SIZE)
1745         return -1;
1746
1747     init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1748
1749     if (parse_code == pc_seq_header) {
1750         if (s->seen_sequence_header)
1751             return 0;
1752
1753         /* [DIRAC_STD] 10. Sequence header */
1754         if (avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source))
1755             return -1;
1756
1757         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1758
1759         if (alloc_sequence_buffers(s))
1760             return -1;
1761
1762         s->seen_sequence_header = 1;
1763     } else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
1764         free_sequence_buffers(s);
1765         s->seen_sequence_header = 0;
1766     } else if (parse_code == pc_aux_data) {
1767         if (buf[13] == 1) {     /* encoder implementation/version */
1768             int ver[3];
1769             /* versions older than 1.0.8 don't store quant delta for
1770                subbands with only one codeblock */
1771             if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
1772                 if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
1773                     s->old_delta_quant = 1;
1774         }
1775     } else if (parse_code & 0x8) {  /* picture data unit */
1776         if (!s->seen_sequence_header) {
1777             av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
1778             return -1;
1779         }
1780
1781         /* find an unused frame */
1782         for (i = 0; i < MAX_FRAMES; i++)
1783             if (s->all_frames[i].avframe.data[0] == NULL)
1784                 pic = &s->all_frames[i];
1785         if (!pic) {
1786             av_log(avctx, AV_LOG_ERROR, "framelist full\n");
1787             return -1;
1788         }
1789
1790         avcodec_get_frame_defaults(&pic->avframe);
1791
1792         /* [DIRAC_STD] Defined in 9.6.1 ... */
1793         tmp            =  parse_code & 0x03;                   /* [DIRAC_STD] num_refs()      */
1794         if (tmp > 2) {
1795             av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
1796             return -1;
1797         }
1798         s->num_refs    = tmp;
1799         s->is_arith    = (parse_code & 0x48) == 0x08;          /* [DIRAC_STD] using_ac()      */
1800         s->low_delay   = (parse_code & 0x88) == 0x88;          /* [DIRAC_STD] is_low_delay()  */
1801         pic->avframe.reference = (parse_code & 0x0C) == 0x0C;  /* [DIRAC_STD]  is_reference() */
1802         pic->avframe.key_frame = s->num_refs == 0;             /* [DIRAC_STD] is_intra()      */
1803         pic->avframe.pict_type = s->num_refs + 1;              /* Definition of AVPictureType in avutil.h */
1804
1805         if (avctx->get_buffer(avctx, &pic->avframe) < 0) {
1806             av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1807             return -1;
1808         }
1809         s->current_picture = pic;
1810         s->plane[0].stride = pic->avframe.linesize[0];
1811         s->plane[1].stride = pic->avframe.linesize[1];
1812         s->plane[2].stride = pic->avframe.linesize[2];
1813
1814         /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
1815         if (dirac_decode_picture_header(s))
1816             return -1;
1817
1818         /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
1819         if (dirac_decode_frame_internal(s))
1820             return -1;
1821     }
1822     return 0;
1823 }
1824
1825 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
1826 {
1827     DiracContext *s     = avctx->priv_data;
1828     DiracFrame *picture = data;
1829     uint8_t *buf        = pkt->data;
1830     int buf_size        = pkt->size;
1831     int i, data_unit_size, buf_idx = 0;
1832
1833     /* release unused frames */
1834     for (i = 0; i < MAX_FRAMES; i++)
1835         if (s->all_frames[i].avframe.data[0] && !s->all_frames[i].avframe.reference) {
1836             avctx->release_buffer(avctx, &s->all_frames[i].avframe);
1837             memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
1838         }
1839
1840     s->current_picture = NULL;
1841     *data_size = 0;
1842
1843     /* end of stream, so flush delayed pics */
1844     if (buf_size == 0)
1845         return get_delayed_pic(s, (AVFrame *)data, data_size);
1846
1847     for (;;) {
1848         /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
1849           [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
1850           BBCD start code search */
1851         for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
1852             if (buf[buf_idx  ] == 'B' && buf[buf_idx+1] == 'B' &&
1853                 buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
1854                 break;
1855         }
1856         /* BBCD found or end of data */
1857         if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
1858             break;
1859
1860         data_unit_size = AV_RB32(buf+buf_idx+5);
1861         if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
1862             if(buf_idx + data_unit_size > buf_size)
1863             av_log(s->avctx, AV_LOG_ERROR,
1864                    "Data unit with size %d is larger than input buffer, discarding\n",
1865                    data_unit_size);
1866             buf_idx += 4;
1867             continue;
1868         }
1869         /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
1870         if (dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size))
1871         {
1872             av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
1873             return -1;
1874         }
1875         buf_idx += data_unit_size;
1876     }
1877
1878     if (!s->current_picture)
1879         return buf_size;
1880
1881     if (s->current_picture->avframe.display_picture_number > s->frame_number) {
1882         DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
1883
1884         s->current_picture->avframe.reference |= DELAYED_PIC_REF;
1885
1886         if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
1887             int min_num = s->delay_frames[0]->avframe.display_picture_number;
1888             /* Too many delayed frames, so we display the frame with the lowest pts */
1889             av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
1890             delayed_frame = s->delay_frames[0];
1891
1892             for (i = 1; s->delay_frames[i]; i++)
1893                 if (s->delay_frames[i]->avframe.display_picture_number < min_num)
1894                     min_num = s->delay_frames[i]->avframe.display_picture_number;
1895
1896             delayed_frame = remove_frame(s->delay_frames, min_num);
1897             add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
1898         }
1899
1900         if (delayed_frame) {
1901             delayed_frame->avframe.reference ^= DELAYED_PIC_REF;
1902             *(AVFrame*)data = delayed_frame->avframe;
1903             *data_size = sizeof(AVFrame);
1904         }
1905     } else if (s->current_picture->avframe.display_picture_number == s->frame_number) {
1906         /* The right frame at the right time :-) */
1907         *(AVFrame*)data = s->current_picture->avframe;
1908         *data_size = sizeof(AVFrame);
1909     }
1910
1911     if (*data_size)
1912         s->frame_number = picture->avframe.display_picture_number + 1;
1913
1914     return buf_idx;
1915 }
1916
1917 AVCodec ff_dirac_decoder = {
1918     .name           = "dirac",
1919     .type           = AVMEDIA_TYPE_VIDEO,
1920     .id             = AV_CODEC_ID_DIRAC,
1921     .priv_data_size = sizeof(DiracContext),
1922     .init           = dirac_decode_init,
1923     .close          = dirac_decode_end,
1924     .decode         = dirac_decode_frame,
1925     .capabilities   = CODEC_CAP_DELAY,
1926     .flush          = dirac_decode_flush,
1927     .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
1928 };