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