git.sesse.net Git - ffmpeg/blob - 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 "get_bits.h"
  31 #include "bytestream.h"
  32 #include "internal.h"
  33 #include "golomb.h"
  34 #include "dirac_arith.h"
  35 #include "mpeg12data.h"
  36 #include "libavcodec/mpegvideo.h"
  37 #include "mpegvideoencdsp.h"
  38 #include "dirac_dwt.h"
  39 #include "dirac.h"
  40 #include "diracdsp.h"
  41 #include "videodsp.h"
  42
  43 /**
  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).
  49  *
  50  * We use this instead of MAX_DECOMPOSITIONS to save some memory.
  51  */
  52 #define MAX_DWT_LEVELS 5
  53
  54 /**
  55  * The spec limits this to 3 for frame coding, but in practice can be as high as 6
  56  */
  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 */
  62
  63 /**
  64  * DiracBlock->ref flags, if set then the block does MC from the given ref
  65  */
  66 #define DIRAC_REF_MASK_REF1   1
  67 #define DIRAC_REF_MASK_REF2   2
  68 #define DIRAC_REF_MASK_GLOBAL 4
  69
  70 /**
  71  * Value of Picture.reference when Picture is not a reference picture, but
  72  * is held for delayed output.
  73  */
  74 #define DELAYED_PIC_REF 4
  75
  76 #define CALC_PADDING(size, depth)                       \
  77     (((size + (1 << depth) - 1) >> depth) << depth)
  78
  79 #define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
  80
  81 typedef struct {
  82     AVFrame *avframe;
  83     int interpolated[3];    /* 1 if hpel[] is valid */
  84     uint8_t *hpel[3][4];
  85     uint8_t *hpel_base[3][4];
  86     int reference;
  87 } DiracFrame;
  88
  89 typedef struct {
  90     union {
  91         int16_t mv[2][2];
  92         int16_t dc[3];
  93     } u; /* anonymous unions aren't in C99 :( */
  94     uint8_t ref;
  95 } DiracBlock;
  96
  97 typedef struct SubBand {
  98     int level;
  99     int orientation;
 100     int stride; /* in bytes */
 101     int width;
 102     int height;
 103     int pshift;
 104     int quant;
 105     uint8_t *ibuf;
 106     struct SubBand *parent;
 107
 108     /* for low delay */
 109     unsigned length;
 110     const uint8_t *coeff_data;
 111 } SubBand;
 112
 113 typedef struct Plane {
 114     int width;
 115     int height;
 116     ptrdiff_t stride;
 117
 118     int idwt_width;
 119     int idwt_height;
 120     int idwt_stride;
 121     uint8_t *idwt_buf;
 122     uint8_t *idwt_buf_base;
 123     uint8_t *idwt_tmp;
 124
 125     /* block length */
 126     uint8_t xblen;
 127     uint8_t yblen;
 128     /* block separation (block n+1 starts after this many pixels in block n) */
 129     uint8_t xbsep;
 130     uint8_t ybsep;
 131     /* amount of overspill on each edge (half of the overlap between blocks) */
 132     uint8_t xoffset;
 133     uint8_t yoffset;
 134
 135     SubBand band[MAX_DWT_LEVELS][4];
 136 } Plane;
 137
 138 typedef struct DiracContext {
 139     AVCodecContext *avctx;
 140     MpegvideoEncDSPContext mpvencdsp;
 141     VideoDSPContext vdsp;
 142     DiracDSPContext diracdsp;
 143     DiracVersionInfo version;
 144     GetBitContext gb;
 145     AVDiracSeqHeader seq;
 146     int seen_sequence_header;
 147     int frame_number;           /* number of the next frame to display       */
 148     Plane plane[3];
 149     int chroma_x_shift;
 150     int chroma_y_shift;
 151
 152     int bit_depth;              /* bit depth                                 */
 153     int pshift;                 /* pixel shift = bit_depth > 8               */
 154
 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              */
 164
 165     /* wavelet decoding */
 166     unsigned wavelet_depth;     /* depth of the IDWT                         */
 167     unsigned wavelet_idx;
 168
 169     /**
 170      * schroedinger older than 1.0.8 doesn't store
 171      * quant delta if only one codebook exists in a band
 172      */
 173     unsigned old_delta_quant;
 174     unsigned codeblock_mode;
 175
 176     unsigned num_x;              /* number of horizontal slices               */
 177     unsigned num_y;              /* number of vertical slices                 */
 178
 179     struct {
 180         unsigned width;
 181         unsigned height;
 182     } codeblock[MAX_DWT_LEVELS+1];
 183
 184     struct {
 185         AVRational bytes;       /* average bytes per slice                   */
 186         uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
 187     } lowdelay;
 188
 189     struct {
 190         unsigned prefix_bytes;
 191         unsigned size_scaler;
 192     } highquality;
 193
 194     struct {
 195         int pan_tilt[2];        /* pan/tilt vector                           */
 196         int zrs[2][2];          /* zoom/rotate/shear matrix                  */
 197         int perspective[2];     /* perspective vector                        */
 198         unsigned zrs_exp;
 199         unsigned perspective_exp;
 200     } globalmc[2];
 201
 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             */
 206
 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)        */
 211
 212     uint8_t *sbsplit;
 213     DiracBlock *blmotion;
 214
 215     uint8_t *edge_emu_buffer[4];
 216     uint8_t *edge_emu_buffer_base;
 217
 218     uint16_t *mctmp;            /* buffer holding the MC data multiplied by OBMC weights */
 219     uint8_t *mcscratch;
 220     int buffer_stride;
 221
 222     DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
 223
 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;
 229
 230     DiracFrame *current_picture;
 231     DiracFrame *ref_pics[2];
 232
 233     DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
 234     DiracFrame *delay_frames[MAX_DELAY+1];
 235     DiracFrame all_frames[MAX_FRAMES];
 236 } DiracContext;
 237
 238 enum dirac_subband {
 239     subband_ll = 0,
 240     subband_hl = 1,
 241     subband_lh = 2,
 242     subband_hh = 3,
 243     subband_nb,
 244 };
 245
 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} },
 254 };
 255
 256 static const int32_t qscale_tab[128] = {
 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,    -13317,     27554,      32768,     -1581,      9853,    -10518,
 264     65536,     -3164,    -16782,    -21037,     131072,     -6328,      2922,     23552,
 265    262144,    -12658,      5844,    -18524,     524288,     15232,     11689,     28578,
 266   1048576,    -10085,    -13110,     -8471,    2097152,    -20170,     10267,    -16943,
 267   4194304,       208,    -15954,     31741,    8388608,       416,      4579,     -2146,
 268  16777216,       832,      9158,     -4293,   33554432,      1663,    -18172,     -8587,
 269  67108864,      3326,       143,    -17175,   134217728,     6653,       285,     31276,
 270 268435456,     13306,       570,     -3075,   536870912,   -13938,      1140,     -6152,
 271 1073741824,    12672,      2281,    -12304, -2147483648,   -15205,      4561,    -24610,
 272          0,    10138,      9122,     16407,           0,   -20274,    -18243,    -32813,
 273 };
 274
 275 static const int32_t qoffset_intra_tab[128] = {
 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,     -6658,     13777,       16384,      -790,      4927,     -5258,
 283     32768,     -1581,     -8390,    -10518,       65536,     -3163,      1461,     11776,
 284    131072,     -6328,      2922,     -9261,      262144,      7616,      5845,     14289,
 285    524288,     -5042,     -6554,     -4235,     1048576,    -10084,      5134,     -8471,
 286   2097152,       104,     -7976,     15871,     4194304,       208,      2290,     -1072,
 287   8388608,       416,      4579,     -2146,    16777216,       832,     -9085,     -4293,
 288  33554432,      1663,        72,     -8587,    67108864,      3327,       143,     15638,
 289 134217728,      6653,       285,     -1537,   268435456,     -6968,       570,     -3075,
 290 536870912,      6336,      1141,     -6151, -1073741823,     -7602,      2281,    -12304,
 291         0,      5069,      4561,      8204,           0,    -10136,     -9121,    -16406,
 292 };
 293
 294 static const int qoffset_inter_tab[MAX_QUANT+1] = {
 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
 303 };
 304
 305 /* magic number division by 3 from schroedinger */
 306 static inline int divide3(int x)
 307 {
 308     return ((x+1)*21845 + 10922) >> 16;
 309 }
 310
 311 static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
 312 {
 313     DiracFrame *remove_pic = NULL;
 314     int i, remove_idx = -1;
 315
 316     for (i = 0; framelist[i]; i++)
 317         if (framelist[i]->avframe->display_picture_number == picnum) {
 318             remove_pic = framelist[i];
 319             remove_idx = i;
 320         }
 321
 322     if (remove_pic)
 323         for (i = remove_idx; framelist[i]; i++)
 324             framelist[i] = framelist[i+1];
 325
 326     return remove_pic;
 327 }
 328
 329 static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
 330 {
 331     int i;
 332     for (i = 0; i < maxframes; i++)
 333         if (!framelist[i]) {
 334             framelist[i] = frame;
 335             return 0;
 336         }
 337     return -1;
 338 }
 339
 340 static int alloc_sequence_buffers(DiracContext *s)
 341 {
 342     int sbwidth  = DIVRNDUP(s->seq.width,  4);
 343     int sbheight = DIVRNDUP(s->seq.height, 4);
 344     int i, w, h, top_padding;
 345
 346     /* todo: think more about this / use or set Plane here */
 347     for (i = 0; i < 3; i++) {
 348         int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
 349         int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
 350         w = s->seq.width  >> (i ? s->chroma_x_shift : 0);
 351         h = s->seq.height >> (i ? s->chroma_y_shift : 0);
 352
 353         /* we allocate the max we support here since num decompositions can
 354          * change from frame to frame. Stride is aligned to 16 for SIMD, and
 355          * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
 356          * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
 357          * on each side */
 358         top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
 359         w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
 360         h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
 361
 362         s->plane[i].idwt_buf_base = av_mallocz_array((w+max_xblen), h * (2 << s->pshift));
 363         s->plane[i].idwt_tmp      = av_malloc_array((w+16), 2 << s->pshift);
 364         s->plane[i].idwt_buf      = s->plane[i].idwt_buf_base + (top_padding*w)*(2 << s->pshift);
 365         if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
 366             return AVERROR(ENOMEM);
 367     }
 368
 369     /* fixme: allocate using real stride here */
 370     s->sbsplit  = av_malloc_array(sbwidth, sbheight);
 371     s->blmotion = av_malloc_array(sbwidth, sbheight * 16 * sizeof(*s->blmotion));
 372
 373     if (!s->sbsplit || !s->blmotion)
 374         return AVERROR(ENOMEM);
 375     return 0;
 376 }
 377
 378 static int alloc_buffers(DiracContext *s, int stride)
 379 {
 380     int w = s->seq.width;
 381     int h = s->seq.height;
 382
 383     av_assert0(stride >= w);
 384     stride += 64;
 385
 386     if (s->buffer_stride >= stride)
 387         return 0;
 388     s->buffer_stride = 0;
 389
 390     av_freep(&s->edge_emu_buffer_base);
 391     memset(s->edge_emu_buffer, 0, sizeof(s->edge_emu_buffer));
 392     av_freep(&s->mctmp);
 393     av_freep(&s->mcscratch);
 394
 395     s->edge_emu_buffer_base = av_malloc_array(stride, MAX_BLOCKSIZE);
 396
 397     s->mctmp     = av_malloc_array((stride+MAX_BLOCKSIZE), (h+MAX_BLOCKSIZE) * sizeof(*s->mctmp));
 398     s->mcscratch = av_malloc_array(stride, MAX_BLOCKSIZE);
 399
 400     if (!s->edge_emu_buffer_base || !s->mctmp || !s->mcscratch)
 401         return AVERROR(ENOMEM);
 402
 403     s->buffer_stride = stride;
 404     return 0;
 405 }
 406
 407 static void free_sequence_buffers(DiracContext *s)
 408 {
 409     int i, j, k;
 410
 411     for (i = 0; i < MAX_FRAMES; i++) {
 412         if (s->all_frames[i].avframe->data[0]) {
 413             av_frame_unref(s->all_frames[i].avframe);
 414             memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
 415         }
 416
 417         for (j = 0; j < 3; j++)
 418             for (k = 1; k < 4; k++)
 419                 av_freep(&s->all_frames[i].hpel_base[j][k]);
 420     }
 421
 422     memset(s->ref_frames, 0, sizeof(s->ref_frames));
 423     memset(s->delay_frames, 0, sizeof(s->delay_frames));
 424
 425     for (i = 0; i < 3; i++) {
 426         av_freep(&s->plane[i].idwt_buf_base);
 427         av_freep(&s->plane[i].idwt_tmp);
 428     }
 429
 430     s->buffer_stride = 0;
 431     av_freep(&s->sbsplit);
 432     av_freep(&s->blmotion);
 433     av_freep(&s->edge_emu_buffer_base);
 434
 435     av_freep(&s->mctmp);
 436     av_freep(&s->mcscratch);
 437 }
 438
 439 static av_cold int dirac_decode_init(AVCodecContext *avctx)
 440 {
 441     DiracContext *s = avctx->priv_data;
 442     int i;
 443
 444     s->avctx = avctx;
 445     s->frame_number = -1;
 446
 447     ff_diracdsp_init(&s->diracdsp);
 448     ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
 449     ff_videodsp_init(&s->vdsp, 8);
 450
 451     for (i = 0; i < MAX_FRAMES; i++) {
 452         s->all_frames[i].avframe = av_frame_alloc();
 453         if (!s->all_frames[i].avframe) {
 454             while (i > 0)
 455                 av_frame_free(&s->all_frames[--i].avframe);
 456             return AVERROR(ENOMEM);
 457         }
 458     }
 459
 460     return 0;
 461 }
 462
 463 static void dirac_decode_flush(AVCodecContext *avctx)
 464 {
 465     DiracContext *s = avctx->priv_data;
 466     free_sequence_buffers(s);
 467     s->seen_sequence_header = 0;
 468     s->frame_number = -1;
 469 }
 470
 471 static av_cold int dirac_decode_end(AVCodecContext *avctx)
 472 {
 473     DiracContext *s = avctx->priv_data;
 474     int i;
 475
 476     dirac_decode_flush(avctx);
 477     for (i = 0; i < MAX_FRAMES; i++)
 478         av_frame_free(&s->all_frames[i].avframe);
 479
 480     return 0;
 481 }
 482
 483 #define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
 484
 485 static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
 486 {
 487     int sign, coeff;
 488
 489     coeff = svq3_get_ue_golomb(gb);
 490     if (coeff) {
 491         coeff = (coeff * qfactor + qoffset + 2) >> 2;
 492         sign  = get_bits1(gb);
 493         coeff = (coeff ^ -sign) + sign;
 494     }
 495     return coeff;
 496 }
 497
 498 #define UNPACK_ARITH(n, type) \
 499     static inline void coeff_unpack_arith_##n(DiracArith *c, int qfactor, int qoffset, \
 500                                               SubBand *b, type *buf, int x, int y) \
 501     { \
 502         int coeff, sign, sign_pred = 0, pred_ctx = CTX_ZPZN_F1; \
 503         const int mstride = -(b->stride >> (1+b->pshift)); \
 504         if (b->parent) { \
 505             const type *pbuf = (type *)b->parent->ibuf; \
 506             const int stride = b->parent->stride >> (1+b->parent->pshift); \
 507             pred_ctx += !!pbuf[stride * (y>>1) + (x>>1)] << 1; \
 508         } \
 509         if (b->orientation == subband_hl) \
 510             sign_pred = buf[mstride]; \
 511         if (x) { \
 512             pred_ctx += !(buf[-1] | buf[mstride] | buf[-1 + mstride]); \
 513             if (b->orientation == subband_lh) \
 514                 sign_pred = buf[-1]; \
 515         } else { \
 516             pred_ctx += !buf[mstride]; \
 517         } \
 518         coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA); \
 519         if (coeff) { \
 520             coeff = (coeff * qfactor + qoffset + 2) >> 2; \
 521             sign  = dirac_get_arith_bit(c, SIGN_CTX(sign_pred)); \
 522             coeff = (coeff ^ -sign) + sign; \
 523         } \
 524         *buf = coeff; \
 525     } \
 526
 527 UNPACK_ARITH(8, int16_t)
 528 UNPACK_ARITH(10, int32_t)
 529
 530 /**
 531  * Decode the coeffs in the rectangle defined by left, right, top, bottom
 532  * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
 533  */
 534 static inline void codeblock(DiracContext *s, SubBand *b,
 535                              GetBitContext *gb, DiracArith *c,
 536                              int left, int right, int top, int bottom,
 537                              int blockcnt_one, int is_arith)
 538 {
 539     int x, y, zero_block;
 540     int qoffset, qfactor;
 541     uint8_t *buf;
 542
 543     /* check for any coded coefficients in this codeblock */
 544     if (!blockcnt_one) {
 545         if (is_arith)
 546             zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
 547         else
 548             zero_block = get_bits1(gb);
 549
 550         if (zero_block)
 551             return;
 552     }
 553
 554     if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
 555         int quant = b->quant;
 556         if (is_arith)
 557             quant += dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
 558         else
 559             quant += dirac_get_se_golomb(gb);
 560         if (quant < 0) {
 561             av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
 562             return;
 563         }
 564         b->quant = quant;
 565     }
 566
 567     b->quant = FFMIN(b->quant, MAX_QUANT);
 568
 569     qfactor = qscale_tab[b->quant];
 570     /* TODO: context pointer? */
 571     if (!s->num_refs)
 572         qoffset = qoffset_intra_tab[b->quant];
 573     else
 574         qoffset = qoffset_inter_tab[b->quant];
 575
 576     buf = b->ibuf + top * b->stride;
 577     if (is_arith) {
 578         for (y = top; y < bottom; y++) {
 579             for (x = left; x < right; x++) {
 580                 if (b->pshift) {
 581                     coeff_unpack_arith_10(c, qfactor, qoffset, b, (int32_t*)(buf)+x, x, y);
 582                 } else {
 583                     coeff_unpack_arith_8(c, qfactor, qoffset, b, (int16_t*)(buf)+x, x, y);
 584                 }
 585             }
 586             buf += b->stride;
 587         }
 588     } else {
 589         for (y = top; y < bottom; y++) {
 590             for (x = left; x < right; x++) {
 591                 int val = coeff_unpack_golomb(gb, qfactor, qoffset);
 592                 if (b->pshift) {
 593                     AV_WN32(&buf[4*x], val);
 594                 } else {
 595                     AV_WN16(&buf[2*x], val);
 596                 }
 597             }
 598             buf += b->stride;
 599          }
 600      }
 601 }
 602
 603 /**
 604  * Dirac Specification ->
 605  * 13.3 intra_dc_prediction(band)
 606  */
 607 #define INTRA_DC_PRED(n, type) \
 608     static inline void intra_dc_prediction_##n(SubBand *b) \
 609     { \
 610         type *buf = (type*)b->ibuf; \
 611         int x, y; \
 612         \
 613         for (x = 1; x < b->width; x++) \
 614             buf[x] += buf[x-1]; \
 615         buf += (b->stride >> (1+b->pshift)); \
 616         \
 617         for (y = 1; y < b->height; y++) { \
 618             buf[0] += buf[-(b->stride >> (1+b->pshift))]; \
 619             \
 620             for (x = 1; x < b->width; x++) { \
 621                 int pred = buf[x - 1] + buf[x - (b->stride >> (1+b->pshift))] + buf[x - (b->stride >> (1+b->pshift))-1]; \
 622                 buf[x]  += divide3(pred); \
 623             } \
 624             buf += (b->stride >> (1+b->pshift)); \
 625         } \
 626     } \
 627
 628 INTRA_DC_PRED(8, int16_t)
 629 INTRA_DC_PRED(10, int32_t)
 630
 631 /**
 632  * Dirac Specification ->
 633  * 13.4.2 Non-skipped subbands.  subband_coeffs()
 634  */
 635 static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
 636 {
 637     int cb_x, cb_y, left, right, top, bottom;
 638     DiracArith c;
 639     GetBitContext gb;
 640     int cb_width  = s->codeblock[b->level + (b->orientation != subband_ll)].width;
 641     int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
 642     int blockcnt_one = (cb_width + cb_height) == 2;
 643
 644     if (!b->length)
 645         return;
 646
 647     init_get_bits8(&gb, b->coeff_data, b->length);
 648
 649     if (is_arith)
 650         ff_dirac_init_arith_decoder(&c, &gb, b->length);
 651
 652     top = 0;
 653     for (cb_y = 0; cb_y < cb_height; cb_y++) {
 654         bottom = (b->height * (cb_y+1LL)) / cb_height;
 655         left = 0;
 656         for (cb_x = 0; cb_x < cb_width; cb_x++) {
 657             right = (b->width * (cb_x+1LL)) / cb_width;
 658             codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
 659             left = right;
 660         }
 661         top = bottom;
 662     }
 663
 664     if (b->orientation == subband_ll && s->num_refs == 0) {
 665         if (s->pshift) {
 666             intra_dc_prediction_10(b);
 667         } else {
 668             intra_dc_prediction_8(b);
 669         }
 670     }
 671 }
 672
 673 static int decode_subband_arith(AVCodecContext *avctx, void *b)
 674 {
 675     DiracContext *s = avctx->priv_data;
 676     decode_subband_internal(s, b, 1);
 677     return 0;
 678 }
 679
 680 static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
 681 {
 682     DiracContext *s = avctx->priv_data;
 683     SubBand **b     = arg;
 684     decode_subband_internal(s, *b, 0);
 685     return 0;
 686 }
 687
 688 /**
 689  * Dirac Specification ->
 690  * [DIRAC_STD] 13.4.1 core_transform_data()
 691  */
 692 static void decode_component(DiracContext *s, int comp)
 693 {
 694     AVCodecContext *avctx = s->avctx;
 695     SubBand *bands[3*MAX_DWT_LEVELS+1];
 696     enum dirac_subband orientation;
 697     int level, num_bands = 0;
 698
 699     /* Unpack all subbands at all levels. */
 700     for (level = 0; level < s->wavelet_depth; level++) {
 701         for (orientation = !!level; orientation < 4; orientation++) {
 702             SubBand *b = &s->plane[comp].band[level][orientation];
 703             bands[num_bands++] = b;
 704
 705             align_get_bits(&s->gb);
 706             /* [DIRAC_STD] 13.4.2 subband() */
 707             b->length = svq3_get_ue_golomb(&s->gb);
 708             if (b->length) {
 709                 b->quant = svq3_get_ue_golomb(&s->gb);
 710                 align_get_bits(&s->gb);
 711                 b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
 712                 b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
 713                 skip_bits_long(&s->gb, b->length*8);
 714             }
 715         }
 716         /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
 717         if (s->is_arith)
 718             avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
 719                            NULL, 4-!!level, sizeof(SubBand));
 720     }
 721     /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
 722     if (!s->is_arith)
 723         avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
 724 }
 725
 726 #define PARSE_VALUES(type, x, gb, ebits, buf1, buf2) \
 727     type *buf = (type *)buf1; \
 728     buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
 729     if (get_bits_count(gb) >= ebits) \
 730         return; \
 731     if (buf2) { \
 732         buf = (type *)buf2; \
 733         buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset); \
 734         if (get_bits_count(gb) >= ebits) \
 735             return; \
 736     } \
 737
 738 static void decode_subband(DiracContext *s, GetBitContext *gb, int quant,
 739                            int slice_x, int slice_y, int bits_end,
 740                            SubBand *b1, SubBand *b2)
 741 {
 742     int left   = b1->width  * slice_x    / s->num_x;
 743     int right  = b1->width  *(slice_x+1) / s->num_x;
 744     int top    = b1->height * slice_y    / s->num_y;
 745     int bottom = b1->height *(slice_y+1) / s->num_y;
 746
 747     int qfactor = qscale_tab[quant & 0x7f];
 748     int qoffset = qoffset_intra_tab[quant & 0x7f];
 749
 750     uint8_t *buf1 =      b1->ibuf + top * b1->stride;
 751     uint8_t *buf2 = b2 ? b2->ibuf + top * b2->stride: NULL;
 752     int x, y;
 753     /* we have to constantly check for overread since the spec explicitly
 754        requires this, with the meaning that all remaining coeffs are set to 0 */
 755     if (get_bits_count(gb) >= bits_end)
 756         return;
 757
 758     if (s->pshift) {
 759         for (y = top; y < bottom; y++) {
 760             for (x = left; x < right; x++) {
 761                 PARSE_VALUES(int32_t, x, gb, bits_end, buf1, buf2);
 762             }
 763             buf1 += b1->stride;
 764             if (buf2)
 765                 buf2 += b2->stride;
 766         }
 767     }
 768     else {
 769         for (y = top; y < bottom; y++) {
 770             for (x = left; x < right; x++) {
 771                 PARSE_VALUES(int16_t, x, gb, bits_end, buf1, buf2);
 772             }
 773             buf1 += b1->stride;
 774             if (buf2)
 775                 buf2 += b2->stride;
 776         }
 777     }
 778 }
 779
 780 /* Used by Low Delay and High Quality profiles */
 781 typedef struct DiracSlice {
 782     GetBitContext gb;
 783     int slice_x;
 784     int slice_y;
 785     int bytes;
 786 } DiracSlice;
 787
 788
 789 /**
 790  * Dirac Specification ->
 791  * 13.5.2 Slices. slice(sx,sy)
 792  */
 793 static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
 794 {
 795     DiracContext *s = avctx->priv_data;
 796     DiracSlice *slice = arg;
 797     GetBitContext *gb = &slice->gb;
 798     enum dirac_subband orientation;
 799     int level, quant, chroma_bits, chroma_end;
 800
 801     int quant_base  = get_bits(gb, 7); /*[DIRAC_STD] qindex */
 802     int length_bits = av_log2(8 * slice->bytes)+1;
 803     int luma_bits   = get_bits_long(gb, length_bits);
 804     int luma_end    = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
 805
 806     /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
 807     for (level = 0; level < s->wavelet_depth; level++)
 808         for (orientation = !!level; orientation < 4; orientation++) {
 809             quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
 810             decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
 811                            &s->plane[0].band[level][orientation], NULL);
 812         }
 813
 814     /* consume any unused bits from luma */
 815     skip_bits_long(gb, get_bits_count(gb) - luma_end);
 816
 817     chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
 818     chroma_end  = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
 819     /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
 820     for (level = 0; level < s->wavelet_depth; level++)
 821         for (orientation = !!level; orientation < 4; orientation++) {
 822             quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
 823             decode_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
 824                            &s->plane[1].band[level][orientation],
 825                            &s->plane[2].band[level][orientation]);
 826         }
 827
 828     return 0;
 829 }
 830
 831 /**
 832  * VC-2 Specification ->
 833  * 13.5.3 hq_slice(sx,sy)
 834  */
 835 static int decode_hq_slice(DiracContext *s, GetBitContext *gb,
 836                            int slice_x, int slice_y)
 837 {
 838     int i, quant, level, orientation, quant_idx;
 839     uint8_t quants[MAX_DWT_LEVELS][4];
 840
 841     skip_bits_long(gb, 8*s->highquality.prefix_bytes);
 842     quant_idx = get_bits(gb, 8);
 843
 844     /* Slice quantization (slice_quantizers() in the specs) */
 845     for (level = 0; level < s->wavelet_depth; level++) {
 846         for (orientation = !!level; orientation < 4; orientation++) {
 847             quant = FFMAX(quant_idx - s->lowdelay.quant[level][orientation], 0);
 848             quants[level][orientation] = quant;
 849         }
 850     }
 851
 852     /* Luma + 2 Chroma planes */
 853     for (i = 0; i < 3; i++) {
 854         int length = s->highquality.size_scaler * get_bits(gb, 8);
 855         int bits_left = 8 * length;
 856         int bits_end = get_bits_count(gb) + bits_left;
 857         for (level = 0; level < s->wavelet_depth; level++) {
 858             for (orientation = !!level; orientation < 4; orientation++) {
 859                 decode_subband(s, gb, quants[level][orientation], slice_x, slice_y, bits_end,
 860                                &s->plane[i].band[level][orientation], NULL);
 861             }
 862         }
 863         skip_bits_long(gb, bits_end - get_bits_count(gb));
 864     }
 865
 866     return 0;
 867 }
 868
 869 /**
 870  * Dirac Specification ->
 871  * 13.5.1 low_delay_transform_data()
 872  */
 873 static int decode_lowdelay(DiracContext *s)
 874 {
 875     AVCodecContext *avctx = s->avctx;
 876     int slice_x, slice_y, bytes, bufsize;
 877     const uint8_t *buf;
 878     DiracSlice *slices;
 879     int slice_num = 0;
 880
 881     slices = av_mallocz_array(s->num_x, s->num_y * sizeof(DiracSlice));
 882     if (!slices)
 883         return AVERROR(ENOMEM);
 884
 885     align_get_bits(&s->gb);
 886     /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
 887     buf = s->gb.buffer + get_bits_count(&s->gb)/8;
 888     bufsize = get_bits_left(&s->gb);
 889
 890     if (s->hq_picture) {
 891         for (slice_y = 0; slice_y < s->num_y; slice_y++) {
 892             for (slice_x = 0; slice_x < s->num_x; slice_x++) {
 893                 decode_hq_slice(s, &s->gb, slice_x, slice_y);
 894             }
 895         }
 896     } else {
 897         for (slice_y = 0; bufsize > 0 && slice_y < s->num_y; slice_y++) {
 898             for (slice_x = 0; bufsize > 0 && slice_x < s->num_x; slice_x++) {
 899                 bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
 900                     - slice_num    * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
 901                 slices[slice_num].bytes   = bytes;
 902                 slices[slice_num].slice_x = slice_x;
 903                 slices[slice_num].slice_y = slice_y;
 904                 init_get_bits(&slices[slice_num].gb, buf, bufsize);
 905                 slice_num++;
 906
 907                 buf     += bytes;
 908                 if (bufsize/8 >= bytes)
 909                     bufsize -= bytes*8;
 910                 else
 911                     bufsize = 0;
 912             }
 913         }
 914         avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
 915                        sizeof(DiracSlice)); /* [DIRAC_STD] 13.5.2 Slices */
 916     }
 917
 918     if (s->dc_prediction) {
 919         if (s->pshift) {
 920             intra_dc_prediction_10(&s->plane[0].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 921             intra_dc_prediction_10(&s->plane[1].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 922             intra_dc_prediction_10(&s->plane[2].band[0][0]); /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 923         } else {
 924             intra_dc_prediction_8(&s->plane[0].band[0][0]);
 925             intra_dc_prediction_8(&s->plane[1].band[0][0]);
 926             intra_dc_prediction_8(&s->plane[2].band[0][0]);
 927         }
 928     }
 929     av_free(slices);
 930     return 0;
 931 }
 932
 933 static void init_planes(DiracContext *s)
 934 {
 935     int i, w, h, level, orientation;
 936
 937     for (i = 0; i < 3; i++) {
 938         Plane *p = &s->plane[i];
 939
 940         p->width       = s->seq.width  >> (i ? s->chroma_x_shift : 0);
 941         p->height      = s->seq.height >> (i ? s->chroma_y_shift : 0);
 942         p->idwt_width  = w = CALC_PADDING(p->width , s->wavelet_depth);
 943         p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
 944         p->idwt_stride = FFALIGN(p->idwt_width << (1 + s->pshift), 8);
 945
 946         for (level = s->wavelet_depth-1; level >= 0; level--) {
 947             w = w>>1;
 948             h = h>>1;
 949             for (orientation = !!level; orientation < 4; orientation++) {
 950                 SubBand *b = &p->band[level][orientation];
 951
 952                 b->pshift = s->pshift;
 953                 b->ibuf   = p->idwt_buf;
 954                 b->level  = level;
 955                 b->stride = p->idwt_stride << (s->wavelet_depth - level);
 956                 b->width  = w;
 957                 b->height = h;
 958                 b->orientation = orientation;
 959
 960                 if (orientation & 1)
 961                     b->ibuf += w << (1+b->pshift);
 962                 if (orientation > 1)
 963                     b->ibuf += (b->stride>>1);
 964
 965                 if (level)
 966                     b->parent = &p->band[level-1][orientation];
 967             }
 968         }
 969
 970         if (i > 0) {
 971             p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
 972             p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
 973             p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
 974             p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
 975         }
 976
 977         p->xoffset = (p->xblen - p->xbsep)/2;
 978         p->yoffset = (p->yblen - p->ybsep)/2;
 979     }
 980 }
 981
 982 /**
 983  * Unpack the motion compensation parameters
 984  * Dirac Specification ->
 985  * 11.2 Picture prediction data. picture_prediction()
 986  */
 987 static int dirac_unpack_prediction_parameters(DiracContext *s)
 988 {
 989     static const uint8_t default_blen[] = { 4, 12, 16, 24 };
 990
 991     GetBitContext *gb = &s->gb;
 992     unsigned idx, ref;
 993
 994     align_get_bits(gb);
 995     /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
 996     /* Luma and Chroma are equal. 11.2.3 */
 997     idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
 998
 999     if (idx > 4) {
1000         av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
1001         return AVERROR_INVALIDDATA;
1002     }
1003
1004     if (idx == 0) {
1005         s->plane[0].xblen = svq3_get_ue_golomb(gb);
1006         s->plane[0].yblen = svq3_get_ue_golomb(gb);
1007         s->plane[0].xbsep = svq3_get_ue_golomb(gb);
1008         s->plane[0].ybsep = svq3_get_ue_golomb(gb);
1009     } else {
1010         /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
1011         s->plane[0].xblen = default_blen[idx-1];
1012         s->plane[0].yblen = default_blen[idx-1];
1013         s->plane[0].xbsep = 4 * idx;
1014         s->plane[0].ybsep = 4 * idx;
1015     }
1016     /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
1017       Calculated in function dirac_unpack_block_motion_data */
1018
1019     if (s->plane[0].xblen % (1 << s->chroma_x_shift) != 0 ||
1020         s->plane[0].yblen % (1 << s->chroma_y_shift) != 0 ||
1021         !s->plane[0].xblen || !s->plane[0].yblen) {
1022         av_log(s->avctx, AV_LOG_ERROR,
1023                "invalid x/y block length (%d/%d) for x/y chroma shift (%d/%d)\n",
1024                s->plane[0].xblen, s->plane[0].yblen, s->chroma_x_shift, s->chroma_y_shift);
1025         return AVERROR_INVALIDDATA;
1026     }
1027     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) {
1028         av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
1029         return AVERROR_INVALIDDATA;
1030     }
1031     if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
1032         av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
1033         return AVERROR_INVALIDDATA;
1034     }
1035     if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
1036         av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
1037         return AVERROR_PATCHWELCOME;
1038     }
1039
1040     /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
1041       Read motion vector precision */
1042     s->mv_precision = svq3_get_ue_golomb(gb);
1043     if (s->mv_precision > 3) {
1044         av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
1045         return AVERROR_INVALIDDATA;
1046     }
1047
1048     /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
1049       Read the global motion compensation parameters */
1050     s->globalmc_flag = get_bits1(gb);
1051     if (s->globalmc_flag) {
1052         memset(s->globalmc, 0, sizeof(s->globalmc));
1053         /* [DIRAC_STD] pan_tilt(gparams) */
1054         for (ref = 0; ref < s->num_refs; ref++) {
1055             if (get_bits1(gb)) {
1056                 s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
1057                 s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
1058             }
1059             /* [DIRAC_STD] zoom_rotate_shear(gparams)
1060                zoom/rotation/shear parameters */
1061             if (get_bits1(gb)) {
1062                 s->globalmc[ref].zrs_exp   = svq3_get_ue_golomb(gb);
1063                 s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
1064                 s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
1065                 s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
1066                 s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
1067             } else {
1068                 s->globalmc[ref].zrs[0][0] = 1;
1069                 s->globalmc[ref].zrs[1][1] = 1;
1070             }
1071             /* [DIRAC_STD] perspective(gparams) */
1072             if (get_bits1(gb)) {
1073                 s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
1074                 s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
1075                 s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
1076             }
1077         }
1078     }
1079
1080     /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
1081       Picture prediction mode, not currently used. */
1082     if (svq3_get_ue_golomb(gb)) {
1083         av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
1084         return AVERROR_INVALIDDATA;
1085     }
1086
1087     /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
1088        just data read, weight calculation will be done later on. */
1089     s->weight_log2denom = 1;
1090     s->weight[0]        = 1;
1091     s->weight[1]        = 1;
1092
1093     if (get_bits1(gb)) {
1094         s->weight_log2denom = svq3_get_ue_golomb(gb);
1095         s->weight[0] = dirac_get_se_golomb(gb);
1096         if (s->num_refs == 2)
1097             s->weight[1] = dirac_get_se_golomb(gb);
1098     }
1099     return 0;
1100 }
1101
1102 /**
1103  * Dirac Specification ->
1104  * 11.3 Wavelet transform data. wavelet_transform()
1105  */
1106 static int dirac_unpack_idwt_params(DiracContext *s)
1107 {
1108     GetBitContext *gb = &s->gb;
1109     int i, level;
1110     unsigned tmp;
1111
1112 #define CHECKEDREAD(dst, cond, errmsg) \
1113     tmp = svq3_get_ue_golomb(gb); \
1114     if (cond) { \
1115         av_log(s->avctx, AV_LOG_ERROR, errmsg); \
1116         return AVERROR_INVALIDDATA; \
1117     }\
1118     dst = tmp;
1119
1120     align_get_bits(gb);
1121
1122     s->zero_res = s->num_refs ? get_bits1(gb) : 0;
1123     if (s->zero_res)
1124         return 0;
1125
1126     /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
1127     CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
1128
1129     CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
1130
1131     if (!s->low_delay) {
1132         /* Codeblock parameters (core syntax only) */
1133         if (get_bits1(gb)) {
1134             for (i = 0; i <= s->wavelet_depth; i++) {
1135                 CHECKEDREAD(s->codeblock[i].width , tmp < 1 || tmp > (s->avctx->width >>s->wavelet_depth-i), "codeblock width invalid\n")
1136                 CHECKEDREAD(s->codeblock[i].height, tmp < 1 || tmp > (s->avctx->height>>s->wavelet_depth-i), "codeblock height invalid\n")
1137             }
1138
1139             CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
1140         }
1141         else {
1142             for (i = 0; i <= s->wavelet_depth; i++)
1143                 s->codeblock[i].width = s->codeblock[i].height = 1;
1144         }
1145     }
1146     else {
1147         s->num_x        = svq3_get_ue_golomb(gb);
1148         s->num_y        = svq3_get_ue_golomb(gb);
1149         if (s->ld_picture) {
1150             s->lowdelay.bytes.num = svq3_get_ue_golomb(gb);
1151             s->lowdelay.bytes.den = svq3_get_ue_golomb(gb);
1152             if (s->lowdelay.bytes.den <= 0) {
1153                 av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
1154                 return AVERROR_INVALIDDATA;
1155             }
1156         } else if (s->hq_picture) {
1157             s->highquality.prefix_bytes = svq3_get_ue_golomb(gb);
1158             s->highquality.size_scaler  = svq3_get_ue_golomb(gb);
1159         }
1160
1161         /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
1162         if (get_bits1(gb)) {
1163             av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
1164             /* custom quantization matrix */
1165             s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
1166             for (level = 0; level < s->wavelet_depth; level++) {
1167                 s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
1168                 s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
1169                 s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
1170             }
1171         } else {
1172             if (s->wavelet_depth > 4) {
1173                 av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
1174                 return AVERROR_INVALIDDATA;
1175             }
1176             /* default quantization matrix */
1177             for (level = 0; level < s->wavelet_depth; level++)
1178                 for (i = 0; i < 4; i++) {
1179                     s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
1180                     /* haar with no shift differs for different depths */
1181                     if (s->wavelet_idx == 3)
1182                         s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
1183                 }
1184         }
1185     }
1186     return 0;
1187 }
1188
1189 static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
1190 {
1191     static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
1192
1193     if (!(x|y))
1194         return 0;
1195     else if (!y)
1196         return sbsplit[-1];
1197     else if (!x)
1198         return sbsplit[-stride];
1199
1200     return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
1201 }
1202
1203 static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
1204 {
1205     int pred;
1206
1207     if (!(x|y))
1208         return 0;
1209     else if (!y)
1210         return block[-1].ref & refmask;
1211     else if (!x)
1212         return block[-stride].ref & refmask;
1213
1214     /* return the majority */
1215     pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
1216     return (pred >> 1) & refmask;
1217 }
1218
1219 static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
1220 {
1221     int i, n = 0;
1222
1223     memset(block->u.dc, 0, sizeof(block->u.dc));
1224
1225     if (x && !(block[-1].ref & 3)) {
1226         for (i = 0; i < 3; i++)
1227             block->u.dc[i] += block[-1].u.dc[i];
1228         n++;
1229     }
1230
1231     if (y && !(block[-stride].ref & 3)) {
1232         for (i = 0; i < 3; i++)
1233             block->u.dc[i] += block[-stride].u.dc[i];
1234         n++;
1235     }
1236
1237     if (x && y && !(block[-1-stride].ref & 3)) {
1238         for (i = 0; i < 3; i++)
1239             block->u.dc[i] += block[-1-stride].u.dc[i];
1240         n++;
1241     }
1242
1243     if (n == 2) {
1244         for (i = 0; i < 3; i++)
1245             block->u.dc[i] = (block->u.dc[i]+1)>>1;
1246     } else if (n == 3) {
1247         for (i = 0; i < 3; i++)
1248             block->u.dc[i] = divide3(block->u.dc[i]);
1249     }
1250 }
1251
1252 static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
1253 {
1254     int16_t *pred[3];
1255     int refmask = ref+1;
1256     int mask = refmask | DIRAC_REF_MASK_GLOBAL; /*  exclude gmc blocks */
1257     int n = 0;
1258
1259     if (x && (block[-1].ref & mask) == refmask)
1260         pred[n++] = block[-1].u.mv[ref];
1261
1262     if (y && (block[-stride].ref & mask) == refmask)
1263         pred[n++] = block[-stride].u.mv[ref];
1264
1265     if (x && y && (block[-stride-1].ref & mask) == refmask)
1266         pred[n++] = block[-stride-1].u.mv[ref];
1267
1268     switch (n) {
1269     case 0:
1270         block->u.mv[ref][0] = 0;
1271         block->u.mv[ref][1] = 0;
1272         break;
1273     case 1:
1274         block->u.mv[ref][0] = pred[0][0];
1275         block->u.mv[ref][1] = pred[0][1];
1276         break;
1277     case 2:
1278         block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
1279         block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
1280         break;
1281     case 3:
1282         block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
1283         block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
1284         break;
1285     }
1286 }
1287
1288 static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
1289 {
1290     int ez      = s->globalmc[ref].zrs_exp;
1291     int ep      = s->globalmc[ref].perspective_exp;
1292     int (*A)[2] = s->globalmc[ref].zrs;
1293     int *b      = s->globalmc[ref].pan_tilt;
1294     int *c      = s->globalmc[ref].perspective;
1295
1296     int m       = (1<<ep) - (c[0]*x + c[1]*y);
1297     int mx      = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
1298     int my      = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
1299
1300     block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
1301     block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
1302 }
1303
1304 static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
1305                                 int stride, int x, int y)
1306 {
1307     int i;
1308
1309     block->ref  = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
1310     block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
1311
1312     if (s->num_refs == 2) {
1313         block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
1314         block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
1315     }
1316
1317     if (!block->ref) {
1318         pred_block_dc(block, stride, x, y);
1319         for (i = 0; i < 3; i++)
1320             block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
1321         return;
1322     }
1323
1324     if (s->globalmc_flag) {
1325         block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
1326         block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
1327     }
1328
1329     for (i = 0; i < s->num_refs; i++)
1330         if (block->ref & (i+1)) {
1331             if (block->ref & DIRAC_REF_MASK_GLOBAL) {
1332                 global_mv(s, block, x, y, i);
1333             } else {
1334                 pred_mv(block, stride, x, y, i);
1335                 block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1336                 block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
1337             }
1338         }
1339 }
1340
1341 /**
1342  * Copies the current block to the other blocks covered by the current superblock split mode
1343  */
1344 static void propagate_block_data(DiracBlock *block, int stride, int size)
1345 {
1346     int x, y;
1347     DiracBlock *dst = block;
1348
1349     for (x = 1; x < size; x++)
1350         dst[x] = *block;
1351
1352     for (y = 1; y < size; y++) {
1353         dst += stride;
1354         for (x = 0; x < size; x++)
1355             dst[x] = *block;
1356     }
1357 }
1358
1359 /**
1360  * Dirac Specification ->
1361  * 12. Block motion data syntax
1362  */
1363 static int dirac_unpack_block_motion_data(DiracContext *s)
1364 {
1365     GetBitContext *gb = &s->gb;
1366     uint8_t *sbsplit = s->sbsplit;
1367     int i, x, y, q, p;
1368     DiracArith arith[8];
1369
1370     align_get_bits(gb);
1371
1372     /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
1373     s->sbwidth  = DIVRNDUP(s->seq.width,  4*s->plane[0].xbsep);
1374     s->sbheight = DIVRNDUP(s->seq.height, 4*s->plane[0].ybsep);
1375     s->blwidth  = 4 * s->sbwidth;
1376     s->blheight = 4 * s->sbheight;
1377
1378     /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
1379        decode superblock split modes */
1380     ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));     /* svq3_get_ue_golomb(gb) is the length */
1381     for (y = 0; y < s->sbheight; y++) {
1382         for (x = 0; x < s->sbwidth; x++) {
1383             unsigned int split  = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
1384             if (split > 2)
1385                 return AVERROR_INVALIDDATA;
1386             sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
1387         }
1388         sbsplit += s->sbwidth;
1389     }
1390
1391     /* setup arith decoding */
1392     ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));
1393     for (i = 0; i < s->num_refs; i++) {
1394         ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
1395         ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
1396     }
1397     for (i = 0; i < 3; i++)
1398         ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
1399
1400     for (y = 0; y < s->sbheight; y++)
1401         for (x = 0; x < s->sbwidth; x++) {
1402             int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
1403             int step   = 4 >> s->sbsplit[y * s->sbwidth + x];
1404
1405             for (q = 0; q < blkcnt; q++)
1406                 for (p = 0; p < blkcnt; p++) {
1407                     int bx = 4 * x + p*step;
1408                     int by = 4 * y + q*step;
1409                     DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
1410                     decode_block_params(s, arith, block, s->blwidth, bx, by);
1411                     propagate_block_data(block, s->blwidth, step);
1412                 }
1413         }
1414
1415     return 0;
1416 }
1417
1418 static int weight(int i, int blen, int offset)
1419 {
1420 #define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) :        \
1421     (1 + (6*(i) + offset - 1) / (2*offset - 1))
1422
1423     if (i < 2*offset)
1424         return ROLLOFF(i);
1425     else if (i > blen-1 - 2*offset)
1426         return ROLLOFF(blen-1 - i);
1427     return 8;
1428 }
1429
1430 static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
1431                                  int left, int right, int wy)
1432 {
1433     int x;
1434     for (x = 0; left && x < p->xblen >> 1; x++)
1435         obmc_weight[x] = wy*8;
1436     for (; x < p->xblen >> right; x++)
1437         obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
1438     for (; x < p->xblen; x++)
1439         obmc_weight[x] = wy*8;
1440     for (; x < stride; x++)
1441         obmc_weight[x] = 0;
1442 }
1443
1444 static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
1445                              int left, int right, int top, int bottom)
1446 {
1447     int y;
1448     for (y = 0; top && y < p->yblen >> 1; y++) {
1449         init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1450         obmc_weight += stride;
1451     }
1452     for (; y < p->yblen >> bottom; y++) {
1453         int wy = weight(y, p->yblen, p->yoffset);
1454         init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
1455         obmc_weight += stride;
1456     }
1457     for (; y < p->yblen; y++) {
1458         init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
1459         obmc_weight += stride;
1460     }
1461 }
1462
1463 static void init_obmc_weights(DiracContext *s, Plane *p, int by)
1464 {
1465     int top = !by;
1466     int bottom = by == s->blheight-1;
1467
1468     /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
1469     if (top || bottom || by == 1) {
1470         init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
1471         init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
1472         init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
1473     }
1474 }
1475
1476 static const uint8_t epel_weights[4][4][4] = {
1477     {{ 16,  0,  0,  0 },
1478      { 12,  4,  0,  0 },
1479      {  8,  8,  0,  0 },
1480      {  4, 12,  0,  0 }},
1481     {{ 12,  0,  4,  0 },
1482      {  9,  3,  3,  1 },
1483      {  6,  6,  2,  2 },
1484      {  3,  9,  1,  3 }},
1485     {{  8,  0,  8,  0 },
1486      {  6,  2,  6,  2 },
1487      {  4,  4,  4,  4 },
1488      {  2,  6,  2,  6 }},
1489     {{  4,  0, 12,  0 },
1490      {  3,  1,  9,  3 },
1491      {  2,  2,  6,  6 },
1492      {  1,  3,  3,  9 }}
1493 };
1494
1495 /**
1496  * For block x,y, determine which of the hpel planes to do bilinear
1497  * interpolation from and set src[] to the location in each hpel plane
1498  * to MC from.
1499  *
1500  * @return the index of the put_dirac_pixels_tab function to use
1501  *  0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
1502  */
1503 static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
1504                      int x, int y, int ref, int plane)
1505 {
1506     Plane *p = &s->plane[plane];
1507     uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
1508     int motion_x = block->u.mv[ref][0];
1509     int motion_y = block->u.mv[ref][1];
1510     int mx, my, i, epel, nplanes = 0;
1511
1512     if (plane) {
1513         motion_x >>= s->chroma_x_shift;
1514         motion_y >>= s->chroma_y_shift;
1515     }
1516
1517     mx         = motion_x & ~(-1U << s->mv_precision);
1518     my         = motion_y & ~(-1U << s->mv_precision);
1519     motion_x >>= s->mv_precision;
1520     motion_y >>= s->mv_precision;
1521     /* normalize subpel coordinates to epel */
1522     /* TODO: template this function? */
1523     mx      <<= 3 - s->mv_precision;
1524     my      <<= 3 - s->mv_precision;
1525
1526     x += motion_x;
1527     y += motion_y;
1528     epel = (mx|my)&1;
1529
1530     /* hpel position */
1531     if (!((mx|my)&3)) {
1532         nplanes = 1;
1533         src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
1534     } else {
1535         /* qpel or epel */
1536         nplanes = 4;
1537         for (i = 0; i < 4; i++)
1538             src[i] = ref_hpel[i] + y*p->stride + x;
1539
1540         /* if we're interpolating in the right/bottom halves, adjust the planes as needed
1541            we increment x/y because the edge changes for half of the pixels */
1542         if (mx > 4) {
1543             src[0] += 1;
1544             src[2] += 1;
1545             x++;
1546         }
1547         if (my > 4) {
1548             src[0] += p->stride;
1549             src[1] += p->stride;
1550             y++;
1551         }
1552
1553         /* hpel planes are:
1554            [0]: F  [1]: H
1555            [2]: V  [3]: C */
1556         if (!epel) {
1557             /* check if we really only need 2 planes since either mx or my is
1558                a hpel position. (epel weights of 0 handle this there) */
1559             if (!(mx&3)) {
1560                 /* mx == 0: average [0] and [2]
1561                    mx == 4: average [1] and [3] */
1562                 src[!mx] = src[2 + !!mx];
1563                 nplanes = 2;
1564             } else if (!(my&3)) {
1565                 src[0] = src[(my>>1)  ];
1566                 src[1] = src[(my>>1)+1];
1567                 nplanes = 2;
1568             }
1569         } else {
1570             /* adjust the ordering if needed so the weights work */
1571             if (mx > 4) {
1572                 FFSWAP(const uint8_t *, src[0], src[1]);
1573                 FFSWAP(const uint8_t *, src[2], src[3]);
1574             }
1575             if (my > 4) {
1576                 FFSWAP(const uint8_t *, src[0], src[2]);
1577                 FFSWAP(const uint8_t *, src[1], src[3]);
1578             }
1579             src[4] = epel_weights[my&3][mx&3];
1580         }
1581     }
1582
1583     /* fixme: v/h _edge_pos */
1584     if (x + p->xblen > p->width +EDGE_WIDTH/2 ||
1585         y + p->yblen > p->height+EDGE_WIDTH/2 ||
1586         x < 0 || y < 0) {
1587         for (i = 0; i < nplanes; i++) {
1588             s->vdsp.emulated_edge_mc(s->edge_emu_buffer[i], src[i],
1589                                      p->stride, p->stride,
1590                                      p->xblen, p->yblen, x, y,
1591                                      p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1592             src[i] = s->edge_emu_buffer[i];
1593         }
1594     }
1595     return (nplanes>>1) + epel;
1596 }
1597
1598 static void add_dc(uint16_t *dst, int dc, int stride,
1599                    uint8_t *obmc_weight, int xblen, int yblen)
1600 {
1601     int x, y;
1602     dc += 128;
1603
1604     for (y = 0; y < yblen; y++) {
1605         for (x = 0; x < xblen; x += 2) {
1606             dst[x  ] += dc * obmc_weight[x  ];
1607             dst[x+1] += dc * obmc_weight[x+1];
1608         }
1609         dst          += stride;
1610         obmc_weight  += MAX_BLOCKSIZE;
1611     }
1612 }
1613
1614 static void block_mc(DiracContext *s, DiracBlock *block,
1615                      uint16_t *mctmp, uint8_t *obmc_weight,
1616                      int plane, int dstx, int dsty)
1617 {
1618     Plane *p = &s->plane[plane];
1619     const uint8_t *src[5];
1620     int idx;
1621
1622     switch (block->ref&3) {
1623     case 0: /* DC */
1624         add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1625         return;
1626     case 1:
1627     case 2:
1628         idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1629         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1630         if (s->weight_func)
1631             s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1632                            s->weight[0] + s->weight[1], p->yblen);
1633         break;
1634     case 3:
1635         idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1636         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1637         idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1638         if (s->biweight_func) {
1639             /* fixme: +32 is a quick hack */
1640             s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1641             s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1642                              s->weight[0], s->weight[1], p->yblen);
1643         } else
1644             s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1645         break;
1646     }
1647     s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1648 }
1649
1650 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1651 {
1652     Plane *p = &s->plane[plane];
1653     int x, dstx = p->xbsep - p->xoffset;
1654
1655     block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1656     mctmp += p->xbsep;
1657
1658     for (x = 1; x < s->blwidth-1; x++) {
1659         block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1660         dstx  += p->xbsep;
1661         mctmp += p->xbsep;
1662     }
1663     block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1664 }
1665
1666 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1667 {
1668     int idx = 0;
1669     if (xblen > 8)
1670         idx = 1;
1671     if (xblen > 16)
1672         idx = 2;
1673
1674     memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1675     memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1676     s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1677     if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1678         s->weight_func   = s->diracdsp.weight_dirac_pixels_tab[idx];
1679         s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1680     } else {
1681         s->weight_func   = NULL;
1682         s->biweight_func = NULL;
1683     }
1684 }
1685
1686 static int interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1687 {
1688     /* chroma allocates an edge of 8 when subsampled
1689        which for 4:2:2 means an h edge of 16 and v edge of 8
1690        just use 8 for everything for the moment */
1691     int i, edge = EDGE_WIDTH/2;
1692
1693     ref->hpel[plane][0] = ref->avframe->data[plane];
1694     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 */
1695
1696     /* no need for hpel if we only have fpel vectors */
1697     if (!s->mv_precision)
1698         return 0;
1699
1700     for (i = 1; i < 4; i++) {
1701         if (!ref->hpel_base[plane][i])
1702             ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe->linesize[plane] + 32);
1703         if (!ref->hpel_base[plane][i]) {
1704             return AVERROR(ENOMEM);
1705         }
1706         /* we need to be 16-byte aligned even for chroma */
1707         ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe->linesize[plane] + 16;
1708     }
1709
1710     if (!ref->interpolated[plane]) {
1711         s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1712                                       ref->hpel[plane][3], ref->hpel[plane][0],
1713                                       ref->avframe->linesize[plane], width, height);
1714         s->mpvencdsp.draw_edges(ref->hpel[plane][1], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1715         s->mpvencdsp.draw_edges(ref->hpel[plane][2], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1716         s->mpvencdsp.draw_edges(ref->hpel[plane][3], ref->avframe->linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1717     }
1718     ref->interpolated[plane] = 1;
1719
1720     return 0;
1721 }
1722
1723 /**
1724  * Dirac Specification ->
1725  * 13.0 Transform data syntax. transform_data()
1726  */
1727 static int dirac_decode_frame_internal(DiracContext *s)
1728 {
1729     DWTContext d;
1730     int y, i, comp, dsty;
1731     int ret;
1732
1733     if (s->low_delay) {
1734         /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1735         for (comp = 0; comp < 3; comp++) {
1736             Plane *p = &s->plane[comp];
1737             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height);
1738         }
1739         if (!s->zero_res) {
1740             if ((ret = decode_lowdelay(s)) < 0)
1741                 return ret;
1742         }
1743     }
1744
1745     for (comp = 0; comp < 3; comp++) {
1746         Plane *p       = &s->plane[comp];
1747         uint8_t *frame = s->current_picture->avframe->data[comp];
1748
1749         /* FIXME: small resolutions */
1750         for (i = 0; i < 4; i++)
1751             s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1752
1753         if (!s->zero_res && !s->low_delay)
1754         {
1755             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height);
1756             decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1757         }
1758         ret = ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
1759                                     s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp, s->bit_depth);
1760         if (ret < 0)
1761             return ret;
1762
1763         if (!s->num_refs) { /* intra */
1764             for (y = 0; y < p->height; y += 16) {
1765                 ff_spatial_idwt_slice2(&d, y+16); /* decode */
1766                 s->diracdsp.put_signed_rect_clamped[s->pshift](frame + y*p->stride, p->stride,
1767                                                                p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1768             }
1769         } else { /* inter */
1770             int rowheight = p->ybsep*p->stride;
1771
1772             select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1773
1774             for (i = 0; i < s->num_refs; i++) {
1775                 int ret = interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1776                 if (ret < 0)
1777                     return ret;
1778             }
1779
1780             memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1781
1782             dsty = -p->yoffset;
1783             for (y = 0; y < s->blheight; y++) {
1784                 int h     = 0,
1785                     start = FFMAX(dsty, 0);
1786                 uint16_t *mctmp    = s->mctmp + y*rowheight;
1787                 DiracBlock *blocks = s->blmotion + y*s->blwidth;
1788
1789                 init_obmc_weights(s, p, y);
1790
1791                 if (y == s->blheight-1 || start+p->ybsep > p->height)
1792                     h = p->height - start;
1793                 else
1794                     h = p->ybsep - (start - dsty);
1795                 if (h < 0)
1796                     break;
1797
1798                 memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1799                 mc_row(s, blocks, mctmp, comp, dsty);
1800
1801                 mctmp += (start - dsty)*p->stride + p->xoffset;
1802                 ff_spatial_idwt_slice2(&d, start + h); /* decode */
1803                 /* NOTE: add_rect_clamped hasn't been templated hence the shifts.
1804                  * idwt_stride is passed as pixels, not in bytes as in the rest of the decoder */
1805                 s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1806                                              (int16_t*)(p->idwt_buf) + start*(p->idwt_stride >> 1), (p->idwt_stride >> 1), p->width, h);
1807
1808                 dsty += p->ybsep;
1809             }
1810         }
1811     }
1812
1813
1814     return 0;
1815 }
1816
1817 static int get_buffer_with_edge(AVCodecContext *avctx, AVFrame *f, int flags)
1818 {
1819     int ret, i;
1820     int chroma_x_shift, chroma_y_shift;
1821     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_x_shift, &chroma_y_shift);
1822
1823     f->width  = avctx->width  + 2 * EDGE_WIDTH;
1824     f->height = avctx->height + 2 * EDGE_WIDTH + 2;
1825     ret = ff_get_buffer(avctx, f, flags);
1826     if (ret < 0)
1827         return ret;
1828
1829     for (i = 0; f->data[i]; i++) {
1830         int offset = (EDGE_WIDTH >> (i && i<3 ? chroma_y_shift : 0)) *
1831                      f->linesize[i] + 32;
1832         f->data[i] += offset;
1833     }
1834     f->width  = avctx->width;
1835     f->height = avctx->height;
1836
1837     return 0;
1838 }
1839
1840 /**
1841  * Dirac Specification ->
1842  * 11.1.1 Picture Header. picture_header()
1843  */
1844 static int dirac_decode_picture_header(DiracContext *s)
1845 {
1846     unsigned retire, picnum;
1847     int i, j, ret;
1848     int64_t refdist, refnum;
1849     GetBitContext *gb = &s->gb;
1850
1851     /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1852     picnum = s->current_picture->avframe->display_picture_number = get_bits_long(gb, 32);
1853
1854
1855     av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1856
1857     /* if this is the first keyframe after a sequence header, start our
1858        reordering from here */
1859     if (s->frame_number < 0)
1860         s->frame_number = picnum;
1861
1862     s->ref_pics[0] = s->ref_pics[1] = NULL;
1863     for (i = 0; i < s->num_refs; i++) {
1864         refnum = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1865         refdist = INT64_MAX;
1866
1867         /* find the closest reference to the one we want */
1868         /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1869         for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1870             if (s->ref_frames[j]
1871                 && FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum) < refdist) {
1872                 s->ref_pics[i] = s->ref_frames[j];
1873                 refdist = FFABS(s->ref_frames[j]->avframe->display_picture_number - refnum);
1874             }
1875
1876         if (!s->ref_pics[i] || refdist)
1877             av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1878
1879         /* if there were no references at all, allocate one */
1880         if (!s->ref_pics[i])
1881             for (j = 0; j < MAX_FRAMES; j++)
1882                 if (!s->all_frames[j].avframe->data[0]) {
1883                     s->ref_pics[i] = &s->all_frames[j];
1884                     get_buffer_with_edge(s->avctx, s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
1885                     break;
1886                 }
1887
1888         if (!s->ref_pics[i]) {
1889             av_log(s->avctx, AV_LOG_ERROR, "Reference could not be allocated\n");
1890             return AVERROR_INVALIDDATA;
1891         }
1892
1893     }
1894
1895     /* retire the reference frames that are not used anymore */
1896     if (s->current_picture->reference) {
1897         retire = (picnum + dirac_get_se_golomb(gb)) & 0xFFFFFFFF;
1898         if (retire != picnum) {
1899             DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1900
1901             if (retire_pic)
1902                 retire_pic->reference &= DELAYED_PIC_REF;
1903             else
1904                 av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1905         }
1906
1907         /* if reference array is full, remove the oldest as per the spec */
1908         while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
1909             av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1910             remove_frame(s->ref_frames, s->ref_frames[0]->avframe->display_picture_number)->reference &= DELAYED_PIC_REF;
1911         }
1912     }
1913
1914     if (s->num_refs) {
1915         ret = dirac_unpack_prediction_parameters(s);  /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1916         if (ret < 0)
1917             return ret;
1918         ret = dirac_unpack_block_motion_data(s);      /* [DIRAC_STD] 12. Block motion data syntax                       */
1919         if (ret < 0)
1920             return ret;
1921     }
1922     ret = dirac_unpack_idwt_params(s);                /* [DIRAC_STD] 11.3 Wavelet transform data                        */
1923     if (ret < 0)
1924         return ret;
1925
1926     init_planes(s);
1927     return 0;
1928 }
1929
1930 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
1931 {
1932     DiracFrame *out = s->delay_frames[0];
1933     int i, out_idx  = 0;
1934     int ret;
1935
1936     /* find frame with lowest picture number */
1937     for (i = 1; s->delay_frames[i]; i++)
1938         if (s->delay_frames[i]->avframe->display_picture_number < out->avframe->display_picture_number) {
1939             out     = s->delay_frames[i];
1940             out_idx = i;
1941         }
1942
1943     for (i = out_idx; s->delay_frames[i]; i++)
1944         s->delay_frames[i] = s->delay_frames[i+1];
1945
1946     if (out) {
1947         out->reference ^= DELAYED_PIC_REF;
1948         *got_frame = 1;
1949         if((ret = av_frame_ref(picture, out->avframe)) < 0)
1950             return ret;
1951     }
1952
1953     return 0;
1954 }
1955
1956 /**
1957  * Dirac Specification ->
1958  * 9.6 Parse Info Header Syntax. parse_info()
1959  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1960  */
1961 #define DATA_UNIT_HEADER_SIZE 13
1962
1963 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1964    inside the function parse_sequence() */
1965 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1966 {
1967     DiracContext *s   = avctx->priv_data;
1968     DiracFrame *pic   = NULL;
1969     AVDiracSeqHeader *dsh;
1970     int ret, i;
1971     uint8_t parse_code;
1972     unsigned tmp;
1973
1974     if (size < DATA_UNIT_HEADER_SIZE)
1975         return AVERROR_INVALIDDATA;
1976
1977     parse_code = buf[4];
1978
1979     init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1980
1981     if (parse_code == DIRAC_PCODE_SEQ_HEADER) {
1982         if (s->seen_sequence_header)
1983             return 0;
1984
1985         /* [DIRAC_STD] 10. Sequence header */
1986         ret = av_dirac_parse_sequence_header(&dsh, buf + DATA_UNIT_HEADER_SIZE, size - DATA_UNIT_HEADER_SIZE, avctx);
1987         if (ret < 0) {
1988             av_log(avctx, AV_LOG_ERROR, "error parsing sequence header");
1989             return ret;
1990         }
1991
1992         ret = ff_set_dimensions(avctx, dsh->width, dsh->height);
1993         if (ret < 0) {
1994             av_freep(&dsh);
1995             return ret;
1996         }
1997
1998         ff_set_sar(avctx, dsh->sample_aspect_ratio);
1999         avctx->pix_fmt         = dsh->pix_fmt;
2000         avctx->color_range     = dsh->color_range;
2001         avctx->color_trc       = dsh->color_trc;
2002         avctx->color_primaries = dsh->color_primaries;
2003         avctx->colorspace      = dsh->colorspace;
2004         avctx->profile         = dsh->profile;
2005         avctx->level           = dsh->level;
2006         avctx->framerate       = dsh->framerate;
2007         s->bit_depth           = dsh->bit_depth;
2008         s->seq                 = *dsh;
2009         av_freep(&dsh);
2010
2011         s->pshift = s->bit_depth > 8;
2012
2013         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
2014
2015         ret = alloc_sequence_buffers(s);
2016         if (ret < 0)
2017             return ret;
2018
2019         s->seen_sequence_header = 1;
2020     } else if (parse_code == DIRAC_PCODE_END_SEQ) { /* [DIRAC_STD] End of Sequence */
2021         free_sequence_buffers(s);
2022         s->seen_sequence_header = 0;
2023     } else if (parse_code == DIRAC_PCODE_AUX) {
2024         if (buf[13] == 1) {     /* encoder implementation/version */
2025             int ver[3];
2026             /* versions older than 1.0.8 don't store quant delta for
2027                subbands with only one codeblock */
2028             if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
2029                 if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
2030                     s->old_delta_quant = 1;
2031         }
2032     } else if (parse_code & 0x8) {  /* picture data unit */
2033         if (!s->seen_sequence_header) {
2034             av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
2035             return AVERROR_INVALIDDATA;
2036         }
2037
2038         /* find an unused frame */
2039         for (i = 0; i < MAX_FRAMES; i++)
2040             if (s->all_frames[i].avframe->data[0] == NULL)
2041                 pic = &s->all_frames[i];
2042         if (!pic) {
2043             av_log(avctx, AV_LOG_ERROR, "framelist full\n");
2044             return AVERROR_INVALIDDATA;
2045         }
2046
2047         av_frame_unref(pic->avframe);
2048
2049         /* [DIRAC_STD] Defined in 9.6.1 ... */
2050         tmp            =  parse_code & 0x03;                   /* [DIRAC_STD] num_refs()      */
2051         if (tmp > 2) {
2052             av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
2053             return AVERROR_INVALIDDATA;
2054         }
2055         s->num_refs      = tmp;
2056         s->is_arith      = (parse_code & 0x48) == 0x08;          /* [DIRAC_STD] using_ac()            */
2057         s->low_delay     = (parse_code & 0x88) == 0x88;          /* [DIRAC_STD] is_low_delay()        */
2058         s->core_syntax   = (parse_code & 0x88) == 0x08;          /* [DIRAC_STD] is_core_syntax()      */
2059         s->ld_picture    = (parse_code & 0xF8) == 0xC8;          /* [DIRAC_STD] is_ld_picture()       */
2060         s->hq_picture    = (parse_code & 0xF8) == 0xE8;          /* [DIRAC_STD] is_hq_picture()       */
2061         s->dc_prediction = (parse_code & 0x28) == 0x08;          /* [DIRAC_STD] using_dc_prediction() */
2062         pic->reference   = (parse_code & 0x0C) == 0x0C;          /* [DIRAC_STD] is_reference()        */
2063         pic->avframe->key_frame = s->num_refs == 0;              /* [DIRAC_STD] is_intra()            */
2064         pic->avframe->pict_type = s->num_refs + 1;               /* Definition of AVPictureType in avutil.h */
2065
2066         if (s->version.minor == 2 && parse_code == 0x88)
2067             s->ld_picture = 1;
2068
2069         if (s->low_delay && !(s->ld_picture || s->hq_picture) ) {
2070             av_log(avctx, AV_LOG_ERROR, "Invalid low delay flag\n");
2071             return AVERROR_INVALIDDATA;
2072         }
2073
2074         if ((ret = get_buffer_with_edge(avctx, pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
2075             return ret;
2076         s->current_picture = pic;
2077         s->plane[0].stride = pic->avframe->linesize[0];
2078         s->plane[1].stride = pic->avframe->linesize[1];
2079         s->plane[2].stride = pic->avframe->linesize[2];
2080
2081         if (alloc_buffers(s, FFMAX3(FFABS(s->plane[0].stride), FFABS(s->plane[1].stride), FFABS(s->plane[2].stride))) < 0)
2082             return AVERROR(ENOMEM);
2083
2084         /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
2085         ret = dirac_decode_picture_header(s);
2086         if (ret < 0)
2087             return ret;
2088
2089         /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
2090         ret = dirac_decode_frame_internal(s);
2091         if (ret < 0)
2092             return ret;
2093     }
2094     return 0;
2095 }
2096
2097 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
2098 {
2099     DiracContext *s     = avctx->priv_data;
2100     AVFrame *picture    = data;
2101     uint8_t *buf        = pkt->data;
2102     int buf_size        = pkt->size;
2103     int i, buf_idx      = 0;
2104     int ret;
2105     unsigned data_unit_size;
2106
2107     /* release unused frames */
2108     for (i = 0; i < MAX_FRAMES; i++)
2109         if (s->all_frames[i].avframe->data[0] && !s->all_frames[i].reference) {
2110             av_frame_unref(s->all_frames[i].avframe);
2111             memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
2112         }
2113
2114     s->current_picture = NULL;
2115     *got_frame = 0;
2116
2117     /* end of stream, so flush delayed pics */
2118     if (buf_size == 0)
2119         return get_delayed_pic(s, (AVFrame *)data, got_frame);
2120
2121     for (;;) {
2122         /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
2123           [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
2124           BBCD start code search */
2125         for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
2126             if (buf[buf_idx  ] == 'B' && buf[buf_idx+1] == 'B' &&
2127                 buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
2128                 break;
2129         }
2130         /* BBCD found or end of data */
2131         if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
2132             break;
2133
2134         data_unit_size = AV_RB32(buf+buf_idx+5);
2135         if (data_unit_size > buf_size - buf_idx || !data_unit_size) {
2136             if(data_unit_size > buf_size - buf_idx)
2137             av_log(s->avctx, AV_LOG_ERROR,
2138                    "Data unit with size %d is larger than input buffer, discarding\n",
2139                    data_unit_size);
2140             buf_idx += 4;
2141             continue;
2142         }
2143         /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
2144         ret = dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size);
2145         if (ret < 0)
2146         {
2147             av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
2148             return ret;
2149         }
2150         buf_idx += data_unit_size;
2151     }
2152
2153     if (!s->current_picture)
2154         return buf_size;
2155
2156     if (s->current_picture->avframe->display_picture_number > s->frame_number) {
2157         DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
2158
2159         s->current_picture->reference |= DELAYED_PIC_REF;
2160
2161         if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
2162             int min_num = s->delay_frames[0]->avframe->display_picture_number;
2163             /* Too many delayed frames, so we display the frame with the lowest pts */
2164             av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
2165
2166             for (i = 1; s->delay_frames[i]; i++)
2167                 if (s->delay_frames[i]->avframe->display_picture_number < min_num)
2168                     min_num = s->delay_frames[i]->avframe->display_picture_number;
2169
2170             delayed_frame = remove_frame(s->delay_frames, min_num);
2171             add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
2172         }
2173
2174         if (delayed_frame) {
2175             delayed_frame->reference ^= DELAYED_PIC_REF;
2176             if((ret=av_frame_ref(data, delayed_frame->avframe)) < 0)
2177                 return ret;
2178             *got_frame = 1;
2179         }
2180     } else if (s->current_picture->avframe->display_picture_number == s->frame_number) {
2181         /* The right frame at the right time :-) */
2182         if((ret=av_frame_ref(data, s->current_picture->avframe)) < 0)
2183             return ret;
2184         *got_frame = 1;
2185     }
2186
2187     if (*got_frame)
2188         s->frame_number = picture->display_picture_number + 1;
2189
2190     return buf_idx;
2191 }
2192
2193 AVCodec ff_dirac_decoder = {
2194     .name           = "dirac",
2195     .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
2196     .type           = AVMEDIA_TYPE_VIDEO,
2197     .id             = AV_CODEC_ID_DIRAC,
2198     .priv_data_size = sizeof(DiracContext),
2199     .init           = dirac_decode_init,
2200     .close          = dirac_decode_end,
2201     .decode         = dirac_decode_frame,
2202     .capabilities   = AV_CODEC_CAP_DELAY,
2203     .flush          = dirac_decode_flush,
2204 };