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