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