git.sesse.net Git - ffmpeg/blob - libavcodec/diracdec.c

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