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     ptrdiff_t 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_bits8(&gb, b->coeff_data, b->length);
 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], p->stride,
1418                                 src[i], p->stride,
1419                                 p->xblen, p->yblen, x, y,
1420                                 p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
1421             src[i] = s->edge_emu_buffer[i];
1422         }
1423     }
1424     return (nplanes>>1) + epel;
1425 }
1426
1427 static void add_dc(uint16_t *dst, int dc, int stride,
1428                    uint8_t *obmc_weight, int xblen, int yblen)
1429 {
1430     int x, y;
1431     dc += 128;
1432
1433     for (y = 0; y < yblen; y++) {
1434         for (x = 0; x < xblen; x += 2) {
1435             dst[x  ] += dc * obmc_weight[x  ];
1436             dst[x+1] += dc * obmc_weight[x+1];
1437         }
1438         dst          += stride;
1439         obmc_weight  += MAX_BLOCKSIZE;
1440     }
1441 }
1442
1443 static void block_mc(DiracContext *s, DiracBlock *block,
1444                      uint16_t *mctmp, uint8_t *obmc_weight,
1445                      int plane, int dstx, int dsty)
1446 {
1447     Plane *p = &s->plane[plane];
1448     const uint8_t *src[5];
1449     int idx;
1450
1451     switch (block->ref&3) {
1452     case 0: /* DC */
1453         add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
1454         return;
1455     case 1:
1456     case 2:
1457         idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
1458         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1459         if (s->weight_func)
1460             s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
1461                            s->weight[0] + s->weight[1], p->yblen);
1462         break;
1463     case 3:
1464         idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
1465         s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1466         idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
1467         if (s->biweight_func) {
1468             /* fixme: +32 is a quick hack */
1469             s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
1470             s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
1471                              s->weight[0], s->weight[1], p->yblen);
1472         } else
1473             s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
1474         break;
1475     }
1476     s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
1477 }
1478
1479 static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
1480 {
1481     Plane *p = &s->plane[plane];
1482     int x, dstx = p->xbsep - p->xoffset;
1483
1484     block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
1485     mctmp += p->xbsep;
1486
1487     for (x = 1; x < s->blwidth-1; x++) {
1488         block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
1489         dstx  += p->xbsep;
1490         mctmp += p->xbsep;
1491     }
1492     block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
1493 }
1494
1495 static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
1496 {
1497     int idx = 0;
1498     if (xblen > 8)
1499         idx = 1;
1500     if (xblen > 16)
1501         idx = 2;
1502
1503     memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
1504     memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
1505     s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
1506     if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
1507         s->weight_func   = s->diracdsp.weight_dirac_pixels_tab[idx];
1508         s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
1509     } else {
1510         s->weight_func   = NULL;
1511         s->biweight_func = NULL;
1512     }
1513 }
1514
1515 static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
1516 {
1517     /* chroma allocates an edge of 8 when subsampled
1518        which for 4:2:2 means an h edge of 16 and v edge of 8
1519        just use 8 for everything for the moment */
1520     int i, edge = EDGE_WIDTH/2;
1521
1522     ref->hpel[plane][0] = ref->avframe.data[plane];
1523     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 */
1524
1525     /* no need for hpel if we only have fpel vectors */
1526     if (!s->mv_precision)
1527         return;
1528
1529     for (i = 1; i < 4; i++) {
1530         if (!ref->hpel_base[plane][i])
1531             ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe.linesize[plane] + 32);
1532         /* we need to be 16-byte aligned even for chroma */
1533         ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe.linesize[plane] + 16;
1534     }
1535
1536     if (!ref->interpolated[plane]) {
1537         s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
1538                                       ref->hpel[plane][3], ref->hpel[plane][0],
1539                                       ref->avframe.linesize[plane], width, height);
1540         s->dsp.draw_edges(ref->hpel[plane][1], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1541         s->dsp.draw_edges(ref->hpel[plane][2], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1542         s->dsp.draw_edges(ref->hpel[plane][3], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
1543     }
1544     ref->interpolated[plane] = 1;
1545 }
1546
1547 /**
1548  * Dirac Specification ->
1549  * 13.0 Transform data syntax. transform_data()
1550  */
1551 static int dirac_decode_frame_internal(DiracContext *s)
1552 {
1553     DWTContext d;
1554     int y, i, comp, dsty;
1555
1556     if (s->low_delay) {
1557         /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
1558         for (comp = 0; comp < 3; comp++) {
1559             Plane *p = &s->plane[comp];
1560             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1561         }
1562         if (!s->zero_res)
1563             decode_lowdelay(s);
1564     }
1565
1566     for (comp = 0; comp < 3; comp++) {
1567         Plane *p       = &s->plane[comp];
1568         uint8_t *frame = s->current_picture->avframe.data[comp];
1569
1570         /* FIXME: small resolutions */
1571         for (i = 0; i < 4; i++)
1572             s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
1573
1574         if (!s->zero_res && !s->low_delay)
1575         {
1576             memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
1577             decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
1578         }
1579         if (ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
1580                                   s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp))
1581             return -1;
1582
1583         if (!s->num_refs) { /* intra */
1584             for (y = 0; y < p->height; y += 16) {
1585                 ff_spatial_idwt_slice2(&d, y+16); /* decode */
1586                 s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
1587                                                     p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
1588             }
1589         } else { /* inter */
1590             int rowheight = p->ybsep*p->stride;
1591
1592             select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
1593
1594             for (i = 0; i < s->num_refs; i++)
1595                 interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
1596
1597             memset(s->mctmp, 0, 4*p->yoffset*p->stride);
1598
1599             dsty = -p->yoffset;
1600             for (y = 0; y < s->blheight; y++) {
1601                 int h     = 0,
1602                     start = FFMAX(dsty, 0);
1603                 uint16_t *mctmp    = s->mctmp + y*rowheight;
1604                 DiracBlock *blocks = s->blmotion + y*s->blwidth;
1605
1606                 init_obmc_weights(s, p, y);
1607
1608                 if (y == s->blheight-1 || start+p->ybsep > p->height)
1609                     h = p->height - start;
1610                 else
1611                     h = p->ybsep - (start - dsty);
1612                 if (h < 0)
1613                     break;
1614
1615                 memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
1616                 mc_row(s, blocks, mctmp, comp, dsty);
1617
1618                 mctmp += (start - dsty)*p->stride + p->xoffset;
1619                 ff_spatial_idwt_slice2(&d, start + h); /* decode */
1620                 s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
1621                                              p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
1622
1623                 dsty += p->ybsep;
1624             }
1625         }
1626     }
1627
1628
1629     return 0;
1630 }
1631
1632 /**
1633  * Dirac Specification ->
1634  * 11.1.1 Picture Header. picture_header()
1635  */
1636 static int dirac_decode_picture_header(DiracContext *s)
1637 {
1638     int retire, picnum;
1639     int i, j, refnum, refdist;
1640     GetBitContext *gb = &s->gb;
1641
1642     /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
1643     picnum = s->current_picture->avframe.display_picture_number = get_bits_long(gb, 32);
1644
1645
1646     av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
1647
1648     /* if this is the first keyframe after a sequence header, start our
1649        reordering from here */
1650     if (s->frame_number < 0)
1651         s->frame_number = picnum;
1652
1653     s->ref_pics[0] = s->ref_pics[1] = NULL;
1654     for (i = 0; i < s->num_refs; i++) {
1655         refnum = picnum + dirac_get_se_golomb(gb);
1656         refdist = INT_MAX;
1657
1658         /* find the closest reference to the one we want */
1659         /* Jordi: this is needed if the referenced picture hasn't yet arrived */
1660         for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
1661             if (s->ref_frames[j]
1662                 && FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum) < refdist) {
1663                 s->ref_pics[i] = s->ref_frames[j];
1664                 refdist = FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum);
1665             }
1666
1667         if (!s->ref_pics[i] || refdist)
1668             av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
1669
1670         /* if there were no references at all, allocate one */
1671         if (!s->ref_pics[i])
1672             for (j = 0; j < MAX_FRAMES; j++)
1673                 if (!s->all_frames[j].avframe.data[0]) {
1674                     s->ref_pics[i] = &s->all_frames[j];
1675                     ff_get_buffer(s->avctx, &s->ref_pics[i]->avframe, AV_GET_BUFFER_FLAG_REF);
1676                     break;
1677                 }
1678     }
1679
1680     /* retire the reference frames that are not used anymore */
1681     if (s->current_picture->avframe.reference) {
1682         retire = picnum + dirac_get_se_golomb(gb);
1683         if (retire != picnum) {
1684             DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
1685
1686             if (retire_pic)
1687                 retire_pic->avframe.reference &= DELAYED_PIC_REF;
1688             else
1689                 av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
1690         }
1691
1692         /* if reference array is full, remove the oldest as per the spec */
1693         while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
1694             av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
1695             remove_frame(s->ref_frames, s->ref_frames[0]->avframe.display_picture_number)->avframe.reference &= DELAYED_PIC_REF;
1696         }
1697     }
1698
1699     if (s->num_refs) {
1700         if (dirac_unpack_prediction_parameters(s))  /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
1701             return -1;
1702         if (dirac_unpack_block_motion_data(s))      /* [DIRAC_STD] 12. Block motion data syntax                       */
1703             return -1;
1704     }
1705     if (dirac_unpack_idwt_params(s))                /* [DIRAC_STD] 11.3 Wavelet transform data                        */
1706         return -1;
1707
1708     init_planes(s);
1709     return 0;
1710 }
1711
1712 static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *got_frame)
1713 {
1714     DiracFrame *out = s->delay_frames[0];
1715     int i, out_idx  = 0;
1716     int ret;
1717
1718     /* find frame with lowest picture number */
1719     for (i = 1; s->delay_frames[i]; i++)
1720         if (s->delay_frames[i]->avframe.display_picture_number < out->avframe.display_picture_number) {
1721             out     = s->delay_frames[i];
1722             out_idx = i;
1723         }
1724
1725     for (i = out_idx; s->delay_frames[i]; i++)
1726         s->delay_frames[i] = s->delay_frames[i+1];
1727
1728     if (out) {
1729         out->avframe.reference ^= DELAYED_PIC_REF;
1730         *got_frame = 1;
1731         if((ret = av_frame_ref(picture, &out->avframe)) < 0)
1732             return ret;
1733     }
1734
1735     return 0;
1736 }
1737
1738 /**
1739  * Dirac Specification ->
1740  * 9.6 Parse Info Header Syntax. parse_info()
1741  * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
1742  */
1743 #define DATA_UNIT_HEADER_SIZE 13
1744
1745 /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
1746    inside the function parse_sequence() */
1747 static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
1748 {
1749     DiracContext *s   = avctx->priv_data;
1750     DiracFrame *pic   = NULL;
1751     int ret, i, parse_code = buf[4];
1752     unsigned tmp;
1753
1754     if (size < DATA_UNIT_HEADER_SIZE)
1755         return -1;
1756
1757     init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
1758
1759     if (parse_code == pc_seq_header) {
1760         if (s->seen_sequence_header)
1761             return 0;
1762
1763         /* [DIRAC_STD] 10. Sequence header */
1764         if (avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source))
1765             return -1;
1766
1767         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1768
1769         if (alloc_sequence_buffers(s))
1770             return -1;
1771
1772         s->seen_sequence_header = 1;
1773     } else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
1774         free_sequence_buffers(s);
1775         s->seen_sequence_header = 0;
1776     } else if (parse_code == pc_aux_data) {
1777         if (buf[13] == 1) {     /* encoder implementation/version */
1778             int ver[3];
1779             /* versions older than 1.0.8 don't store quant delta for
1780                subbands with only one codeblock */
1781             if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
1782                 if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
1783                     s->old_delta_quant = 1;
1784         }
1785     } else if (parse_code & 0x8) {  /* picture data unit */
1786         if (!s->seen_sequence_header) {
1787             av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
1788             return -1;
1789         }
1790
1791         /* find an unused frame */
1792         for (i = 0; i < MAX_FRAMES; i++)
1793             if (s->all_frames[i].avframe.data[0] == NULL)
1794                 pic = &s->all_frames[i];
1795         if (!pic) {
1796             av_log(avctx, AV_LOG_ERROR, "framelist full\n");
1797             return -1;
1798         }
1799
1800         avcodec_get_frame_defaults(&pic->avframe);
1801
1802         /* [DIRAC_STD] Defined in 9.6.1 ... */
1803         tmp            =  parse_code & 0x03;                   /* [DIRAC_STD] num_refs()      */
1804         if (tmp > 2) {
1805             av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
1806             return -1;
1807         }
1808         s->num_refs    = tmp;
1809         s->is_arith    = (parse_code & 0x48) == 0x08;          /* [DIRAC_STD] using_ac()      */
1810         s->low_delay   = (parse_code & 0x88) == 0x88;          /* [DIRAC_STD] is_low_delay()  */
1811         pic->avframe.reference = (parse_code & 0x0C) == 0x0C;  /* [DIRAC_STD]  is_reference() */
1812         pic->avframe.key_frame = s->num_refs == 0;             /* [DIRAC_STD] is_intra()      */
1813         pic->avframe.pict_type = s->num_refs + 1;              /* Definition of AVPictureType in avutil.h */
1814
1815         if ((ret = ff_get_buffer(avctx, &pic->avframe, (parse_code & 0x0C) == 0x0C ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
1816             return ret;
1817         s->current_picture = pic;
1818         s->plane[0].stride = pic->avframe.linesize[0];
1819         s->plane[1].stride = pic->avframe.linesize[1];
1820         s->plane[2].stride = pic->avframe.linesize[2];
1821
1822         /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
1823         if (dirac_decode_picture_header(s))
1824             return -1;
1825
1826         /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
1827         if (dirac_decode_frame_internal(s))
1828             return -1;
1829     }
1830     return 0;
1831 }
1832
1833 static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *pkt)
1834 {
1835     DiracContext *s     = avctx->priv_data;
1836     DiracFrame *picture = data;
1837     uint8_t *buf        = pkt->data;
1838     int buf_size        = pkt->size;
1839     int i, data_unit_size, buf_idx = 0;
1840     int ret;
1841
1842     /* release unused frames */
1843     for (i = 0; i < MAX_FRAMES; i++)
1844         if (s->all_frames[i].avframe.data[0] && !s->all_frames[i].avframe.reference) {
1845             av_frame_unref(&s->all_frames[i].avframe);
1846             memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
1847         }
1848
1849     s->current_picture = NULL;
1850     *got_frame = 0;
1851
1852     /* end of stream, so flush delayed pics */
1853     if (buf_size == 0)
1854         return get_delayed_pic(s, (AVFrame *)data, got_frame);
1855
1856     for (;;) {
1857         /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
1858           [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
1859           BBCD start code search */
1860         for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
1861             if (buf[buf_idx  ] == 'B' && buf[buf_idx+1] == 'B' &&
1862                 buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
1863                 break;
1864         }
1865         /* BBCD found or end of data */
1866         if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
1867             break;
1868
1869         data_unit_size = AV_RB32(buf+buf_idx+5);
1870         if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
1871             if(buf_idx + data_unit_size > buf_size)
1872             av_log(s->avctx, AV_LOG_ERROR,
1873                    "Data unit with size %d is larger than input buffer, discarding\n",
1874                    data_unit_size);
1875             buf_idx += 4;
1876             continue;
1877         }
1878         /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
1879         if (dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size))
1880         {
1881             av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
1882             return -1;
1883         }
1884         buf_idx += data_unit_size;
1885     }
1886
1887     if (!s->current_picture)
1888         return buf_size;
1889
1890     if (s->current_picture->avframe.display_picture_number > s->frame_number) {
1891         DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
1892
1893         s->current_picture->avframe.reference |= DELAYED_PIC_REF;
1894
1895         if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
1896             int min_num = s->delay_frames[0]->avframe.display_picture_number;
1897             /* Too many delayed frames, so we display the frame with the lowest pts */
1898             av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
1899             delayed_frame = s->delay_frames[0];
1900
1901             for (i = 1; s->delay_frames[i]; i++)
1902                 if (s->delay_frames[i]->avframe.display_picture_number < min_num)
1903                     min_num = s->delay_frames[i]->avframe.display_picture_number;
1904
1905             delayed_frame = remove_frame(s->delay_frames, min_num);
1906             add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
1907         }
1908
1909         if (delayed_frame) {
1910             delayed_frame->avframe.reference ^= DELAYED_PIC_REF;
1911             if((ret=av_frame_ref(data, &delayed_frame->avframe)) < 0)
1912                 return ret;
1913             *got_frame = 1;
1914         }
1915     } else if (s->current_picture->avframe.display_picture_number == s->frame_number) {
1916         /* The right frame at the right time :-) */
1917         if((ret=av_frame_ref(data, &s->current_picture->avframe)) < 0)
1918             return ret;
1919         *got_frame = 1;
1920     }
1921
1922     if (*got_frame)
1923         s->frame_number = picture->avframe.display_picture_number + 1;
1924
1925     return buf_idx;
1926 }
1927
1928 AVCodec ff_dirac_decoder = {
1929     .name           = "dirac",
1930     .type           = AVMEDIA_TYPE_VIDEO,
1931     .id             = AV_CODEC_ID_DIRAC,
1932     .priv_data_size = sizeof(DiracContext),
1933     .init           = dirac_decode_init,
1934     .close          = dirac_decode_end,
1935     .decode         = dirac_decode_frame,
1936     .capabilities   = CODEC_CAP_DELAY,
1937     .flush          = dirac_decode_flush,
1938     .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
1939 };