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