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