Merge commit '594d4d5df3c70404168701dd5c90b7e6e5587793'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 5 Dec 2012 14:18:12 +0000 (15:18 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 5 Dec 2012 14:18:12 +0000 (15:18 +0100)
* commit '594d4d5df3c70404168701dd5c90b7e6e5587793':
  lavc: add a wrapper for AVCodecContext.get_buffer().

Conflicts:
libavcodec/4xm.c
libavcodec/8svx.c
libavcodec/bmv.c
libavcodec/cljr.c
libavcodec/cscd.c
libavcodec/dnxhddec.c
libavcodec/dpcm.c
libavcodec/dpx.c
libavcodec/eacmv.c
libavcodec/eamad.c
libavcodec/frwu.c
libavcodec/g723_1.c
libavcodec/gifdec.c
libavcodec/idcinvideo.c
libavcodec/iff.c
libavcodec/indeo3.c
libavcodec/internal.h
libavcodec/interplayvideo.c
libavcodec/kmvc.c
libavcodec/mpc7.c
libavcodec/mpegaudiodec.c
libavcodec/pcx.c
libavcodec/pngdec.c
libavcodec/pnmdec.c
libavcodec/rl2.c
libavcodec/snow.c
libavcodec/targa.c
libavcodec/tscc.c
libavcodec/txd.c
libavcodec/utils.c
libavcodec/v210dec.c
libavcodec/vb.c
libavcodec/vmdav.c
libavcodec/vp56.c
libavcodec/vqavideo.c
libavcodec/wavpack.c
libavcodec/wnv1.c
libavcodec/xl.c
libavcodec/yop.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
165 files changed:
1  2 
libavcodec/4xm.c
libavcodec/8bps.c
libavcodec/8svx.c
libavcodec/aacdec.c
libavcodec/ac3dec.c
libavcodec/adpcm.c
libavcodec/adxdec.c
libavcodec/alac.c
libavcodec/alsdec.c
libavcodec/amrnbdec.c
libavcodec/amrwbdec.c
libavcodec/ansi.c
libavcodec/apedec.c
libavcodec/asvdec.c
libavcodec/atrac1.c
libavcodec/atrac3.c
libavcodec/aura.c
libavcodec/avrndec.c
libavcodec/avuidec.c
libavcodec/bfi.c
libavcodec/bink.c
libavcodec/binkaudio.c
libavcodec/bmp.c
libavcodec/bmv.c
libavcodec/brender_pix.c
libavcodec/cavsdec.c
libavcodec/cdgraphics.c
libavcodec/cdxl.c
libavcodec/cljr.c
libavcodec/cllc.c
libavcodec/cngdec.c
libavcodec/cook.c
libavcodec/crystalhd.c
libavcodec/cscd.c
libavcodec/cyuv.c
libavcodec/dcadec.c
libavcodec/dfa.c
libavcodec/diracdec.c
libavcodec/dnxhddec.c
libavcodec/dpcm.c
libavcodec/dpx.c
libavcodec/dsicinav.c
libavcodec/dvdec.c
libavcodec/dxa.c
libavcodec/eacmv.c
libavcodec/eamad.c
libavcodec/eatgq.c
libavcodec/eatqi.c
libavcodec/escape124.c
libavcodec/escape130.c
libavcodec/ffv1dec.c
libavcodec/ffwavesynth.c
libavcodec/flacdec.c
libavcodec/frame_thread_encoder.c
libavcodec/frwu.c
libavcodec/g722dec.c
libavcodec/g723_1.c
libavcodec/g726.c
libavcodec/g729dec.c
libavcodec/gifdec.c
libavcodec/gsmdec.c
libavcodec/idcinvideo.c
libavcodec/iff.c
libavcodec/imc.c
libavcodec/indeo3.c
libavcodec/internal.h
libavcodec/interplayvideo.c
libavcodec/ivi_common.c
libavcodec/j2kdec.c
libavcodec/kgv1dec.c
libavcodec/kmvc.c
libavcodec/lcldec.c
libavcodec/libcelt_dec.c
libavcodec/libgsm.c
libavcodec/libilbc.c
libavcodec/libopencore-amr.c
libavcodec/libopusdec.c
libavcodec/libschroedingerdec.c
libavcodec/libspeexdec.c
libavcodec/libstagefright.cpp
libavcodec/libvorbisdec.c
libavcodec/loco.c
libavcodec/mace.c
libavcodec/mjpegdec.c
libavcodec/mlpdec.c
libavcodec/mpc7.c
libavcodec/mpc8.c
libavcodec/mpegaudiodec.c
libavcodec/mss2.c
libavcodec/mxpegdec.c
libavcodec/nellymoserdec.c
libavcodec/paf.c
libavcodec/pcm-mpeg.c
libavcodec/pcm.c
libavcodec/pcx.c
libavcodec/pictordec.c
libavcodec/pngdec.c
libavcodec/pnmdec.c
libavcodec/proresdec2.c
libavcodec/proresdec_lgpl.c
libavcodec/pthread.c
libavcodec/ptx.c
libavcodec/qcelpdec.c
libavcodec/qdm2.c
libavcodec/qdrw.c
libavcodec/qpeg.c
libavcodec/r210dec.c
libavcodec/ra144dec.c
libavcodec/ra288.c
libavcodec/rl2.c
libavcodec/roqvideoenc.c
libavcodec/s302m.c
libavcodec/sanm.c
libavcodec/sgidec.c
libavcodec/shorten.c
libavcodec/sipr.c
libavcodec/smacker.c
libavcodec/snow.c
libavcodec/snowdec.c
libavcodec/snowenc.c
libavcodec/sonic.c
libavcodec/sunrast.c
libavcodec/svq1enc.c
libavcodec/takdec.c
libavcodec/targa.c
libavcodec/targa_y216dec.c
libavcodec/thread.h
libavcodec/tiff.c
libavcodec/tmv.c
libavcodec/truespeech.c
libavcodec/tscc.c
libavcodec/tta.c
libavcodec/twinvq.c
libavcodec/txd.c
libavcodec/utils.c
libavcodec/v210dec.c
libavcodec/v210x.c
libavcodec/v308dec.c
libavcodec/v408dec.c
libavcodec/v410dec.c
libavcodec/vb.c
libavcodec/vble.c
libavcodec/vc1dec.c
libavcodec/vcr1.c
libavcodec/vima.c
libavcodec/vmdav.c
libavcodec/vorbisdec.c
libavcodec/vp56.c
libavcodec/vqavideo.c
libavcodec/wavpack.c
libavcodec/wmadec.c
libavcodec/wmalosslessdec.c
libavcodec/wmaprodec.c
libavcodec/wmavoice.c
libavcodec/wnv1.c
libavcodec/ws-snd1.c
libavcodec/xan.c
libavcodec/xbmdec.c
libavcodec/xfacedec.c
libavcodec/xl.c
libavcodec/xwddec.c
libavcodec/y41pdec.c
libavcodec/yop.c
libavcodec/yuv4dec.c
libavcodec/zmbv.c

  #include "bytestream.h"
  #include "dsputil.h"
  #include "get_bits.h"
+ #include "internal.h"
  
 -//#undef NDEBUG
 -//#include <assert.h>
 +#include "libavutil/avassert.h"
  
  #define BLOCK_TYPE_VLC_BITS 5
  #define ACDC_VLC_BITS 9
@@@ -882,21 -840,17 +883,21 @@@ static int decode_frame(AVCodecContext 
      }
  
      if (frame_4cc == AV_RL32("ifr2")) {
 -        p->pict_type = AV_PICTURE_TYPE_I;
 -        if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0)
 +        p->pict_type= AV_PICTURE_TYPE_I;
 +        if (decode_i2_frame(f, buf - 4, frame_size + 4) < 0) {
 +            av_log(f->avctx, AV_LOG_ERROR, "decode i2 frame failed\n");
              return -1;
 +        }
      } else if (frame_4cc == AV_RL32("ifrm")) {
 -        p->pict_type = AV_PICTURE_TYPE_I;
 -        if (decode_i_frame(f, buf, frame_size) < 0)
 +        p->pict_type= AV_PICTURE_TYPE_I;
 +        if (decode_i_frame(f, buf, frame_size) < 0) {
 +            av_log(f->avctx, AV_LOG_ERROR, "decode i frame failed\n");
              return -1;
 +        }
      } else if (frame_4cc == AV_RL32("pfrm") || frame_4cc == AV_RL32("pfr2")) {
          if (!f->last_picture.data[0]) {
 -            f->last_picture.reference = 1;
 +            f->last_picture.reference = 3;
-             if (avctx->get_buffer(avctx, &f->last_picture) < 0) {
+             if (ff_get_buffer(avctx, &f->last_picture) < 0) {
                  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
                  return -1;
              }
Simple merge
   *
   * supports: fibonacci delta encoding
   *         : exponential encoding
 + *
 + * For more information about the 8SVX format:
 + * http://netghost.narod.ru/gff/vendspec/iff/iff.txt
 + * http://sox.sourceforge.net/AudioFormats-11.html
 + * http://aminet.net/package/mus/misc/wavepak
 + * http://amigan.1emu.net/reg/8SVX.txt
 + *
 + * Samples can be found here:
 + * http://aminet.net/mods/smpl/
   */
  
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
+ #include "internal.h"
  #include "libavutil/common.h"
  
  /** decoder context */
@@@ -134,8 -136,8 +135,8 @@@ static int eightsvx_decode_frame(AVCode
      }
  
      /* get output buffer */
 -    esc->frame.nb_samples = buf_size * (is_compr + 1);
 +    esc->frame.nb_samples = buf_size * 2;
-     if ((ret = avctx->get_buffer(avctx, &esc->frame)) < 0) {
+     if ((ret = ff_get_buffer(avctx, &esc->frame)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return ret;
      }
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
  
  #include "libavutil/common.h"
  #include "libavutil/lfg.h"
 +#include "libavutil/xga_font_data.h"
  #include "avcodec.h"
  #include "cga_data.h"
+ #include "internal.h"
  
  #define ATTR_BOLD         0x01  /**< Bold/Bright-foreground (mode 1) */
  #define ATTR_FAINT        0x02  /**< Faint (mode 2) */
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
index 2205a42,0000000..187dad5
mode 100644,000000..100644
--- /dev/null
@@@ -1,141 -1,0 +1,142 @@@
-     if((ret = avctx->get_buffer(avctx, p)) < 0){
 +/*
 + * AVRn decoder
 + * Copyright (c) 2012 Michael Niedermayer
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "avcodec.h"
++#include "internal.h"
 +#include "mjpeg.h"
 +#include "mjpegdec.h"
 +#include "libavutil/imgutils.h"
 +
 +typedef struct {
 +    MJpegDecodeContext mjpeg_ctx;
 +    AVFrame frame;
 +    int is_mjpeg;
 +    int interlace; //FIXME use frame.interlaced_frame
 +    int tff;
 +} AVRnContext;
 +
 +static av_cold int init(AVCodecContext *avctx)
 +{
 +    AVRnContext *a = avctx->priv_data;
 +    int ret;
 +
 +    // Support "Resolution 1:1" for Avid AVI Codec
 +    a->is_mjpeg = avctx->extradata_size < 31 || memcmp(&avctx->extradata[28], "1:1", 3);
 +
 +    if(!a->is_mjpeg && avctx->lowres) {
 +        av_log(avctx, AV_LOG_ERROR, "lowres is not possible with rawvideo\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if(a->is_mjpeg)
 +        return ff_mjpeg_decode_init(avctx);
 +
 +    if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
 +        return ret;
 +
 +    avcodec_get_frame_defaults(&a->frame);
 +    avctx->pix_fmt = AV_PIX_FMT_UYVY422;
 +
 +    if(avctx->extradata_size >= 9 && avctx->extradata[4]+28 < avctx->extradata_size) {
 +        int ndx = avctx->extradata[4] + 4;
 +        a->interlace = !memcmp(avctx->extradata + ndx, "1:1(", 4);
 +        if(a->interlace) {
 +            a->tff = avctx->extradata[ndx + 24] == 1;
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static av_cold int end(AVCodecContext *avctx)
 +{
 +    AVRnContext *a = avctx->priv_data;
 +    AVFrame *p = &a->frame;
 +
 +    if(p->data[0])
 +        avctx->release_buffer(avctx, p);
 +
 +    if(a->is_mjpeg)
 +        ff_mjpeg_decode_end(avctx);
 +
 +    return 0;
 +}
 +
 +static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
 +{
 +    AVRnContext *a = avctx->priv_data;
 +    AVFrame *p = &a->frame;
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size       = avpkt->size;
 +    int y, ret, true_height;
 +
 +    if(a->is_mjpeg)
 +        return ff_mjpeg_decode_frame(avctx, data, data_size, avpkt);
 +
 +    true_height    = buf_size / (2*avctx->width);
 +    if(p->data[0])
 +        avctx->release_buffer(avctx, p);
 +
 +    if(buf_size < 2*avctx->width * avctx->height) {
 +        av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
++    if((ret = ff_get_buffer(avctx, p)) < 0){
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
 +    }
 +    p->pict_type= AV_PICTURE_TYPE_I;
 +    p->key_frame= 1;
 +
 +    if(a->interlace) {
 +        buf += (true_height - avctx->height)*avctx->width;
 +        for(y = 0; y < avctx->height-1; y+=2) {
 +            memcpy(p->data[0] + (y+ a->tff)*p->linesize[0], buf                             , 2*avctx->width);
 +            memcpy(p->data[0] + (y+!a->tff)*p->linesize[0], buf + avctx->width*true_height+4, 2*avctx->width);
 +            buf += 2*avctx->width;
 +        }
 +    } else {
 +        buf += (true_height - avctx->height)*avctx->width*2;
 +        for(y = 0; y < avctx->height; y++) {
 +            memcpy(p->data[0] + y*p->linesize[0], buf, 2*avctx->width);
 +            buf += 2*avctx->width;
 +        }
 +    }
 +
 +    *(AVFrame*)data = a->frame;
 +    *data_size      = sizeof(AVFrame);
 +    return buf_size;
 +}
 +
 +AVCodec ff_avrn_decoder = {
 +    .name           = "avrn",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_AVRN,
 +    .priv_data_size = sizeof(AVRnContext),
 +    .init           = init,
 +    .close          = end,
 +    .decode         = decode_frame,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),
 +    .capabilities   = CODEC_CAP_DR1,
 +    .max_lowres     = 3,
 +};
 +
index 52d8090,0000000..7aa30ff
mode 100644,000000..100644
--- /dev/null
@@@ -1,155 -1,0 +1,156 @@@
-     if (avctx->get_buffer(avctx, pic) < 0) {
 +/*
 + * AVID Meridien decoder
 + *
 + * Copyright (c) 2012 Carl Eugen Hoyos
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "avcodec.h"
++#include "internal.h"
 +#include "libavutil/intreadwrite.h"
 +
 +static av_cold int avui_decode_init(AVCodecContext *avctx)
 +{
 +    avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
 +
 +    avctx->coded_frame = avcodec_alloc_frame();
 +
 +    if (!avctx->coded_frame) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    return 0;
 +}
 +
 +static int avui_decode_frame(AVCodecContext *avctx, void *data,
 +                             int *data_size, AVPacket *avpkt)
 +{
 +    AVFrame *pic = avctx->coded_frame;
 +    const uint8_t *src = avpkt->data, *extradata = avctx->extradata;
 +    const uint8_t *srca;
 +    uint8_t *y, *u, *v, *a;
 +    int transparent, interlaced = 1, skip, opaque_length, i, j, k;
 +    uint32_t extradata_size = avctx->extradata_size;
 +
 +    if (pic->data[0])
 +        avctx->release_buffer(avctx, pic);
 +
 +    while (extradata_size >= 24) {
 +        uint32_t atom_size = AV_RB32(extradata);
 +        if (!memcmp(&extradata[4], "APRGAPRG0001", 12)) {
 +            interlaced = extradata[19] != 1;
 +            break;
 +        }
 +        if (atom_size && atom_size <= extradata_size) {
 +            extradata      += atom_size;
 +            extradata_size -= atom_size;
 +        } else {
 +            break;
 +        }
 +    }
 +    if (avctx->height == 486) {
 +        skip = 10;
 +    } else {
 +        skip = 16;
 +    }
 +    opaque_length = 2 * avctx->width * (avctx->height + skip) + 4 * interlaced;
 +    if (avpkt->size < opaque_length) {
 +        av_log(avctx, AV_LOG_ERROR, "Insufficient input data.\n");
 +        return AVERROR(EINVAL);
 +    }
 +    transparent = avctx->bits_per_coded_sample == 32 &&
 +                  avpkt->size >= opaque_length * 2 + 4;
 +    srca = src + opaque_length + 5;
 +
 +    pic->reference = 0;
 +
++    if (ff_get_buffer(avctx, pic) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not allocate buffer.\n");
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    pic->key_frame = 1;
 +    pic->pict_type = AV_PICTURE_TYPE_I;
 +
 +    if (!interlaced) {
 +        src  += avctx->width * skip;
 +        srca += avctx->width * skip;
 +    }
 +
 +    for (i = 0; i < interlaced + 1; i++) {
 +        src  += avctx->width * skip;
 +        srca += avctx->width * skip;
 +        if (interlaced && avctx->height == 486) {
 +            y = pic->data[0] + (1 - i) * pic->linesize[0];
 +            u = pic->data[1] + (1 - i) * pic->linesize[1];
 +            v = pic->data[2] + (1 - i) * pic->linesize[2];
 +            a = pic->data[3] + (1 - i) * pic->linesize[3];
 +        } else {
 +            y = pic->data[0] + i * pic->linesize[0];
 +            u = pic->data[1] + i * pic->linesize[1];
 +            v = pic->data[2] + i * pic->linesize[2];
 +            a = pic->data[3] + i * pic->linesize[3];
 +        }
 +
 +        for (j = 0; j < avctx->height >> interlaced; j++) {
 +            for (k = 0; k < avctx->width >> 1; k++) {
 +                u[    k    ] = *src++;
 +                y[2 * k    ] = *src++;
 +                a[2 * k    ] = 0xFF - (transparent ? *srca++ : 0);
 +                srca++;
 +                v[    k    ] = *src++;
 +                y[2 * k + 1] = *src++;
 +                a[2 * k + 1] = 0xFF - (transparent ? *srca++ : 0);
 +                srca++;
 +            }
 +
 +            y += (interlaced + 1) * pic->linesize[0];
 +            u += (interlaced + 1) * pic->linesize[1];
 +            v += (interlaced + 1) * pic->linesize[2];
 +            a += (interlaced + 1) * pic->linesize[3];
 +        }
 +        src  += 4;
 +        srca += 4;
 +    }
 +    *data_size = sizeof(AVFrame);
 +    *(AVFrame *)data = *pic;
 +
 +    return avpkt->size;
 +}
 +
 +static av_cold int avui_decode_close(AVCodecContext *avctx)
 +{
 +    if (avctx->coded_frame->data[0])
 +        avctx->release_buffer(avctx, avctx->coded_frame);
 +
 +    av_freep(&avctx->coded_frame);
 +
 +    return 0;
 +}
 +
 +AVCodec ff_avui_decoder = {
 +    .name         = "avui",
 +    .type         = AVMEDIA_TYPE_VIDEO,
 +    .id           = AV_CODEC_ID_AVUI,
 +    .init         = avui_decode_init,
 +    .decode       = avui_decode_frame,
 +    .close        = avui_decode_close,
 +    .capabilities = CODEC_CAP_DR1,
 +    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
 +};
@@@ -61,9 -60,9 +62,9 @@@ static int bfi_decode_frame(AVCodecCont
      if (bfi->frame.data[0])
          avctx->release_buffer(avctx, &bfi->frame);
  
 -    bfi->frame.reference = 1;
 +    bfi->frame.reference = 3;
  
-     if (avctx->get_buffer(avctx, &bfi->frame) < 0) {
+     if (ff_get_buffer(avctx, &bfi->frame) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return -1;
      }
Simple merge
Simple merge
Simple merge
@@@ -19,6 -19,6 +19,7 @@@
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
++#include "libavutil/avassert.h"
  #include "libavutil/channel_layout.h"
  #include "avcodec.h"
  #include "bytestream.h"
index 886e8fb,0000000..92bc8b4
mode 100644,000000..100644
--- /dev/null
@@@ -1,244 -1,0 +1,245 @@@
-     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 +/*
 + * BRender PIX (.pix) image decoder
 + * Copyright (c) 2012 Aleksi Nurmi
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/*
 + * Tested against samples from I-War / Independence War and Defiance.
 + * If the PIX file does not contain a palette, the
 + * palette_has_changed property of the AVFrame is set to 0.
 + */
 +
 +#include "libavutil/imgutils.h"
 +#include "avcodec.h"
 +#include "bytestream.h"
++#include "internal.h"
 +
 +typedef struct BRPixContext {
 +    AVFrame frame;
 +} BRPixContext;
 +
 +typedef struct BRPixHeader {
 +    int format;
 +    unsigned int width, height;
 +} BRPixHeader;
 +
 +static av_cold int brpix_init(AVCodecContext *avctx)
 +{
 +    BRPixContext *s = avctx->priv_data;
 +
 +    avcodec_get_frame_defaults(&s->frame);
 +    avctx->coded_frame = &s->frame;
 +
 +    return 0;
 +}
 +
 +static int brpix_decode_header(BRPixHeader *out, GetByteContext *pgb)
 +{
 +    unsigned int header_len = bytestream2_get_be32(pgb);
 +
 +    out->format = bytestream2_get_byte(pgb);
 +    bytestream2_skip(pgb, 2);
 +    out->width = bytestream2_get_be16(pgb);
 +    out->height = bytestream2_get_be16(pgb);
 +
 +    // the header is at least 11 bytes long; we read the first 7
 +    if (header_len < 11) {
 +        return 0;
 +    }
 +
 +    // skip the rest of the header
 +    bytestream2_skip(pgb, header_len-7);
 +
 +    return 1;
 +}
 +
 +static int brpix_decode_frame(AVCodecContext *avctx,
 +                              void *data, int *data_size_out,
 +                              AVPacket *avpkt)
 +{
 +    BRPixContext *s = avctx->priv_data;
 +    AVFrame *frame_out = data;
 +
 +    int ret;
 +    GetByteContext gb;
 +
 +    unsigned int bytes_pp;
 +
 +    unsigned int magic[4];
 +    unsigned int chunk_type;
 +    unsigned int data_len;
 +    BRPixHeader hdr;
 +
 +    bytestream2_init(&gb, avpkt->data, avpkt->size);
 +
 +    magic[0] = bytestream2_get_be32(&gb);
 +    magic[1] = bytestream2_get_be32(&gb);
 +    magic[2] = bytestream2_get_be32(&gb);
 +    magic[3] = bytestream2_get_be32(&gb);
 +
 +    if (magic[0] != 0x12 ||
 +        magic[1] != 0x8 ||
 +        magic[2] != 0x2 ||
 +        magic[3] != 0x2) {
 +        av_log(avctx, AV_LOG_ERROR, "Not a BRender PIX file\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    chunk_type = bytestream2_get_be32(&gb);
 +    if (chunk_type != 0x3 && chunk_type != 0x3d) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid chunk type %d\n", chunk_type);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ret = brpix_decode_header(&hdr, &gb);
 +    if (!ret) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid header length\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    switch (hdr.format) {
 +    case 3:
 +        avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +        bytes_pp = 1;
 +        break;
 +    case 4:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB555BE;
 +        bytes_pp = 2;
 +        break;
 +    case 5:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB565BE;
 +        bytes_pp = 2;
 +        break;
 +    case 6:
 +        avctx->pix_fmt = AV_PIX_FMT_RGB24;
 +        bytes_pp = 3;
 +        break;
 +    case 7:
 +        avctx->pix_fmt = AV_PIX_FMT_0RGB;
 +        bytes_pp = 4;
 +        break;
 +    case 18:
 +        avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
 +        bytes_pp = 2;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Format %d is not supported\n",
 +                                    hdr.format);
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    if (s->frame.data[0])
 +        avctx->release_buffer(avctx, &s->frame);
 +
 +    if (av_image_check_size(hdr.width, hdr.height, 0, avctx) < 0)
 +        return AVERROR_INVALIDDATA;
 +
 +    if (hdr.width != avctx->width || hdr.height != avctx->height)
 +        avcodec_set_dimensions(avctx, hdr.width, hdr.height);
 +
++    if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
 +    }
 +
 +    chunk_type = bytestream2_get_be32(&gb);
 +
 +    if (avctx->pix_fmt == AV_PIX_FMT_PAL8 &&
 +        (chunk_type == 0x3 || chunk_type == 0x3d)) {
 +        BRPixHeader palhdr;
 +        uint32_t *pal_out = (uint32_t *)s->frame.data[1];
 +        int i;
 +
 +        ret = brpix_decode_header(&palhdr, &gb);
 +        if (!ret) {
 +            av_log(avctx, AV_LOG_ERROR, "Invalid palette header length\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        if (palhdr.format != 7) {
 +            av_log(avctx, AV_LOG_ERROR, "Palette is not in 0RGB format\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        chunk_type = bytestream2_get_be32(&gb);
 +        data_len = bytestream2_get_be32(&gb);
 +        bytestream2_skip(&gb, 8);
 +        if (chunk_type != 0x21 || data_len != 1032 ||
 +            bytestream2_get_bytes_left(&gb) < 1032) {
 +            av_log(avctx, AV_LOG_ERROR, "Invalid palette data\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        // convert 0RGB to machine endian format (ARGB32)
 +        for (i = 0; i < 256; ++i) {
 +            bytestream2_skipu(&gb, 1);
 +            *pal_out++ = (0xFFU << 24) | bytestream2_get_be24u(&gb);
 +        }
 +        bytestream2_skip(&gb, 8);
 +
 +        s->frame.palette_has_changed = 1;
 +
 +        chunk_type = bytestream2_get_be32(&gb);
 +    }
 +
 +    data_len = bytestream2_get_be32(&gb);
 +    bytestream2_skip(&gb, 8);
 +
 +    // read the image data to the buffer
 +    {
 +        unsigned int bytes_per_scanline = bytes_pp * hdr.width;
 +        unsigned int bytes_left = bytestream2_get_bytes_left(&gb);
 +
 +        if (chunk_type != 0x21 || data_len != bytes_left ||
 +            bytes_left / bytes_per_scanline < hdr.height)
 +        {
 +            av_log(avctx, AV_LOG_ERROR, "Invalid image data\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        av_image_copy_plane(s->frame.data[0], s->frame.linesize[0],
 +                            avpkt->data + bytestream2_tell(&gb),
 +                            bytes_per_scanline,
 +                            bytes_per_scanline, hdr.height);
 +    }
 +
 +    *frame_out = s->frame;
 +    *data_size_out = sizeof(AVFrame);
 +
 +    return avpkt->size;
 +}
 +
 +static av_cold int brpix_end(AVCodecContext *avctx)
 +{
 +    BRPixContext *s = avctx->priv_data;
 +
 +    if(s->frame.data[0])
 +        avctx->release_buffer(avctx, &s->frame);
 +
 +    return 0;
 +}
 +
 +AVCodec ff_brender_pix_decoder = {
 +    .name           = "brender_pix",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_BRENDER_PIX,
 +    .priv_data_size = sizeof(BRPixContext),
 +    .init           = brpix_init,
 +    .close          = brpix_end,
 +    .decode         = brpix_decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("BRender PIX image"),
 +};
Simple merge
Simple merge
  #include "libavutil/imgutils.h"
  #include "avcodec.h"
  #include "get_bits.h"
+ #include "internal.h"
  
  #define BIT_PLANAR   0x00
 -#define BYTE_PLANAR  0x20
 -#define CHUNKY       0x40
 +#define CHUNKY       0x20
 +#define BYTE_PLANAR  0x40
  #define BIT_LINE     0x80
  #define BYTE_LINE    0xC0
  
@@@ -74,9 -70,9 +74,9 @@@ static int decode_frame(AVCodecContext 
      }
  
      p->reference = 0;
-     if ((ret = avctx->get_buffer(avctx, p)) < 0) {
 -    if (ff_get_buffer(avctx, p) < 0) {
++    if ((ret = ff_get_buffer(avctx, p)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -        return -1;
 +        return ret;
      }
      p->pict_type = AV_PICTURE_TYPE_I;
      p->key_frame = 1;
Simple merge
Simple merge
Simple merge
index bf846d3,0000000..d18243c
mode 100644,000000..100644
--- /dev/null
@@@ -1,1225 -1,0 +1,1226 @@@
-         if (avctx->get_buffer(avctx, &priv->pic) < 0) {
 +/*
 + * - CrystalHD decoder module -
 + *
 + * Copyright(C) 2010,2011 Philip Langdale <ffmpeg.philipl@overt.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/*
 + * - Principles of Operation -
 + *
 + * The CrystalHD decoder operates at the bitstream level - which is an even
 + * higher level than the decoding hardware you typically see in modern GPUs.
 + * This means it has a very simple interface, in principle. You feed demuxed
 + * packets in one end and get decoded picture (fields/frames) out the other.
 + *
 + * Of course, nothing is ever that simple. Due, at the very least, to b-frame
 + * dependencies in the supported formats, the hardware has a delay between
 + * when a packet goes in, and when a picture comes out. Furthermore, this delay
 + * is not just a function of time, but also one of the dependency on additional
 + * frames being fed into the decoder to satisfy the b-frame dependencies.
 + *
 + * As such, a pipeline will build up that is roughly equivalent to the required
 + * DPB for the file being played. If that was all it took, things would still
 + * be simple - so, of course, it isn't.
 + *
 + * The hardware has a way of indicating that a picture is ready to be copied out,
 + * but this is unreliable - and sometimes the attempt will still fail so, based
 + * on testing, the code will wait until 3 pictures are ready before starting
 + * to copy out - and this has the effect of extending the pipeline.
 + *
 + * Finally, while it is tempting to say that once the decoder starts outputting
 + * frames, the software should never fail to return a frame from a decode(),
 + * this is a hard assertion to make, because the stream may switch between
 + * differently encoded content (number of b-frames, interlacing, etc) which
 + * might require a longer pipeline than before. If that happened, you could
 + * deadlock trying to retrieve a frame that can't be decoded without feeding
 + * in additional packets.
 + *
 + * As such, the code will return in the event that a picture cannot be copied
 + * out, leading to an increase in the length of the pipeline. This in turn,
 + * means we have to be sensitive to the time it takes to decode a picture;
 + * We do not want to give up just because the hardware needed a little more
 + * time to prepare the picture! For this reason, there are delays included
 + * in the decode() path that ensure that, under normal conditions, the hardware
 + * will only fail to return a frame if it really needs additional packets to
 + * complete the decoding.
 + *
 + * Finally, to be explicit, we do not want the pipeline to grow without bound
 + * for two reasons: 1) The hardware can only buffer a finite number of packets,
 + * and 2) The client application may not be able to cope with arbitrarily long
 + * delays in the video path relative to the audio path. For example. MPlayer
 + * can only handle a 20 picture delay (although this is arbitrary, and needs
 + * to be extended to fully support the CrystalHD where the delay could be up
 + * to 32 pictures - consider PAFF H.264 content with 16 b-frames).
 + */
 +
 +/*****************************************************************************
 + * Includes
 + ****************************************************************************/
 +
 +#define _XOPEN_SOURCE 600
 +#include <inttypes.h>
 +#include <stdio.h>
 +#include <stdlib.h>
 +#include <unistd.h>
 +
 +#include <libcrystalhd/bc_dts_types.h>
 +#include <libcrystalhd/bc_dts_defs.h>
 +#include <libcrystalhd/libcrystalhd_if.h>
 +
 +#include "avcodec.h"
 +#include "h264.h"
++#include "internal.h"
 +#include "libavutil/imgutils.h"
 +#include "libavutil/intreadwrite.h"
 +#include "libavutil/opt.h"
 +
 +/** Timeout parameter passed to DtsProcOutput() in us */
 +#define OUTPUT_PROC_TIMEOUT 50
 +/** Step between fake timestamps passed to hardware in units of 100ns */
 +#define TIMESTAMP_UNIT 100000
 +/** Initial value in us of the wait in decode() */
 +#define BASE_WAIT 10000
 +/** Increment in us to adjust wait in decode() */
 +#define WAIT_UNIT 1000
 +
 +
 +/*****************************************************************************
 + * Module private data
 + ****************************************************************************/
 +
 +typedef enum {
 +    RET_ERROR           = -1,
 +    RET_OK              = 0,
 +    RET_COPY_AGAIN      = 1,
 +    RET_SKIP_NEXT_COPY  = 2,
 +    RET_COPY_NEXT_FIELD = 3,
 +} CopyRet;
 +
 +typedef struct OpaqueList {
 +    struct OpaqueList *next;
 +    uint64_t fake_timestamp;
 +    uint64_t reordered_opaque;
 +    uint8_t pic_type;
 +} OpaqueList;
 +
 +typedef struct {
 +    AVClass *av_class;
 +    AVCodecContext *avctx;
 +    AVFrame pic;
 +    HANDLE dev;
 +
 +    uint8_t *orig_extradata;
 +    uint32_t orig_extradata_size;
 +
 +    AVBitStreamFilterContext *bsfc;
 +    AVCodecParserContext *parser;
 +
 +    uint8_t is_70012;
 +    uint8_t *sps_pps_buf;
 +    uint32_t sps_pps_size;
 +    uint8_t is_nal;
 +    uint8_t output_ready;
 +    uint8_t need_second_field;
 +    uint8_t skip_next_output;
 +    uint64_t decode_wait;
 +
 +    uint64_t last_picture;
 +
 +    OpaqueList *head;
 +    OpaqueList *tail;
 +
 +    /* Options */
 +    uint32_t sWidth;
 +    uint8_t bframe_bug;
 +} CHDContext;
 +
 +static const AVOption options[] = {
 +    { "crystalhd_downscale_width",
 +      "Turn on downscaling to the specified width",
 +      offsetof(CHDContext, sWidth),
 +      AV_OPT_TYPE_INT, {.i64 = 0}, 0, UINT32_MAX,
 +      AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM, },
 +    { NULL, },
 +};
 +
 +
 +/*****************************************************************************
 + * Helper functions
 + ****************************************************************************/
 +
 +static inline BC_MEDIA_SUBTYPE id2subtype(CHDContext *priv, enum AVCodecID id)
 +{
 +    switch (id) {
 +    case AV_CODEC_ID_MPEG4:
 +        return BC_MSUBTYPE_DIVX;
 +    case AV_CODEC_ID_MSMPEG4V3:
 +        return BC_MSUBTYPE_DIVX311;
 +    case AV_CODEC_ID_MPEG2VIDEO:
 +        return BC_MSUBTYPE_MPEG2VIDEO;
 +    case AV_CODEC_ID_VC1:
 +        return BC_MSUBTYPE_VC1;
 +    case AV_CODEC_ID_WMV3:
 +        return BC_MSUBTYPE_WMV3;
 +    case AV_CODEC_ID_H264:
 +        return priv->is_nal ? BC_MSUBTYPE_AVC1 : BC_MSUBTYPE_H264;
 +    default:
 +        return BC_MSUBTYPE_INVALID;
 +    }
 +}
 +
 +static inline void print_frame_info(CHDContext *priv, BC_DTS_PROC_OUT *output)
 +{
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tYBuffSz: %u\n", output->YbuffSz);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tYBuffDoneSz: %u\n",
 +           output->YBuffDoneSz);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tUVBuffDoneSz: %u\n",
 +           output->UVBuffDoneSz);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tTimestamp: %"PRIu64"\n",
 +           output->PicInfo.timeStamp);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tPicture Number: %u\n",
 +           output->PicInfo.picture_number);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tWidth: %u\n",
 +           output->PicInfo.width);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tHeight: %u\n",
 +           output->PicInfo.height);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tChroma: 0x%03x\n",
 +           output->PicInfo.chroma_format);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tPulldown: %u\n",
 +           output->PicInfo.pulldown);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFlags: 0x%08x\n",
 +           output->PicInfo.flags);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFrame Rate/Res: %u\n",
 +           output->PicInfo.frame_rate);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tAspect Ratio: %u\n",
 +           output->PicInfo.aspect_ratio);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tColor Primaries: %u\n",
 +           output->PicInfo.colour_primaries);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tMetaData: %u\n",
 +           output->PicInfo.picture_meta_payload);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tSession Number: %u\n",
 +           output->PicInfo.sess_num);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tycom: %u\n",
 +           output->PicInfo.ycom);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tCustom Aspect: %u\n",
 +           output->PicInfo.custom_aspect_ratio_width_height);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tFrames to Drop: %u\n",
 +           output->PicInfo.n_drop);
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "\tH264 Valid Fields: 0x%08x\n",
 +           output->PicInfo.other.h264.valid);
 +}
 +
 +
 +/*****************************************************************************
 + * OpaqueList functions
 + ****************************************************************************/
 +
 +static uint64_t opaque_list_push(CHDContext *priv, uint64_t reordered_opaque,
 +                                 uint8_t pic_type)
 +{
 +    OpaqueList *newNode = av_mallocz(sizeof (OpaqueList));
 +    if (!newNode) {
 +        av_log(priv->avctx, AV_LOG_ERROR,
 +               "Unable to allocate new node in OpaqueList.\n");
 +        return 0;
 +    }
 +    if (!priv->head) {
 +        newNode->fake_timestamp = TIMESTAMP_UNIT;
 +        priv->head              = newNode;
 +    } else {
 +        newNode->fake_timestamp = priv->tail->fake_timestamp + TIMESTAMP_UNIT;
 +        priv->tail->next        = newNode;
 +    }
 +    priv->tail = newNode;
 +    newNode->reordered_opaque = reordered_opaque;
 +    newNode->pic_type = pic_type;
 +
 +    return newNode->fake_timestamp;
 +}
 +
 +/*
 + * The OpaqueList is built in decode order, while elements will be removed
 + * in presentation order. If frames are reordered, this means we must be
 + * able to remove elements that are not the first element.
 + *
 + * Returned node must be freed by caller.
 + */
 +static OpaqueList *opaque_list_pop(CHDContext *priv, uint64_t fake_timestamp)
 +{
 +    OpaqueList *node = priv->head;
 +
 +    if (!priv->head) {
 +        av_log(priv->avctx, AV_LOG_ERROR,
 +               "CrystalHD: Attempted to query non-existent timestamps.\n");
 +        return NULL;
 +    }
 +
 +    /*
 +     * The first element is special-cased because we have to manipulate
 +     * the head pointer rather than the previous element in the list.
 +     */
 +    if (priv->head->fake_timestamp == fake_timestamp) {
 +        priv->head = node->next;
 +
 +        if (!priv->head->next)
 +            priv->tail = priv->head;
 +
 +        node->next = NULL;
 +        return node;
 +    }
 +
 +    /*
 +     * The list is processed at arm's length so that we have the
 +     * previous element available to rewrite its next pointer.
 +     */
 +    while (node->next) {
 +        OpaqueList *current = node->next;
 +        if (current->fake_timestamp == fake_timestamp) {
 +            node->next = current->next;
 +
 +            if (!node->next)
 +               priv->tail = node;
 +
 +            current->next = NULL;
 +            return current;
 +        } else {
 +            node = current;
 +        }
 +    }
 +
 +    av_log(priv->avctx, AV_LOG_VERBOSE,
 +           "CrystalHD: Couldn't match fake_timestamp.\n");
 +    return NULL;
 +}
 +
 +
 +/*****************************************************************************
 + * Video decoder API function definitions
 + ****************************************************************************/
 +
 +static void flush(AVCodecContext *avctx)
 +{
 +    CHDContext *priv = avctx->priv_data;
 +
 +    avctx->has_b_frames     = 0;
 +    priv->last_picture      = -1;
 +    priv->output_ready      = 0;
 +    priv->need_second_field = 0;
 +    priv->skip_next_output  = 0;
 +    priv->decode_wait       = BASE_WAIT;
 +
 +    if (priv->pic.data[0])
 +        avctx->release_buffer(avctx, &priv->pic);
 +
 +    /* Flush mode 4 flushes all software and hardware buffers. */
 +    DtsFlushInput(priv->dev, 4);
 +}
 +
 +
 +static av_cold int uninit(AVCodecContext *avctx)
 +{
 +    CHDContext *priv = avctx->priv_data;
 +    HANDLE device;
 +
 +    device = priv->dev;
 +    DtsStopDecoder(device);
 +    DtsCloseDecoder(device);
 +    DtsDeviceClose(device);
 +
 +    /*
 +     * Restore original extradata, so that if the decoder is
 +     * reinitialised, the bitstream detection and filtering
 +     * will work as expected.
 +     */
 +    if (priv->orig_extradata) {
 +        av_free(avctx->extradata);
 +        avctx->extradata = priv->orig_extradata;
 +        avctx->extradata_size = priv->orig_extradata_size;
 +        priv->orig_extradata = NULL;
 +        priv->orig_extradata_size = 0;
 +    }
 +
 +    av_parser_close(priv->parser);
 +    if (priv->bsfc) {
 +        av_bitstream_filter_close(priv->bsfc);
 +    }
 +
 +    av_free(priv->sps_pps_buf);
 +
 +    if (priv->pic.data[0])
 +        avctx->release_buffer(avctx, &priv->pic);
 +
 +    if (priv->head) {
 +       OpaqueList *node = priv->head;
 +       while (node) {
 +          OpaqueList *next = node->next;
 +          av_free(node);
 +          node = next;
 +       }
 +    }
 +
 +    return 0;
 +}
 +
 +
 +static av_cold int init(AVCodecContext *avctx)
 +{
 +    CHDContext* priv;
 +    BC_STATUS ret;
 +    BC_INFO_CRYSTAL version;
 +    BC_INPUT_FORMAT format = {
 +        .FGTEnable   = FALSE,
 +        .Progressive = TRUE,
 +        .OptFlags    = 0x80000000 | vdecFrameRate59_94 | 0x40,
 +        .width       = avctx->width,
 +        .height      = avctx->height,
 +    };
 +
 +    BC_MEDIA_SUBTYPE subtype;
 +
 +    uint32_t mode = DTS_PLAYBACK_MODE |
 +                    DTS_LOAD_FILE_PLAY_FW |
 +                    DTS_SKIP_TX_CHK_CPB |
 +                    DTS_PLAYBACK_DROP_RPT_MODE |
 +                    DTS_SINGLE_THREADED_MODE |
 +                    DTS_DFLT_RESOLUTION(vdecRESOLUTION_1080p23_976);
 +
 +    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD Init for %s\n",
 +           avctx->codec->name);
 +
 +    avctx->pix_fmt = AV_PIX_FMT_YUYV422;
 +
 +    /* Initialize the library */
 +    priv               = avctx->priv_data;
 +    priv->avctx        = avctx;
 +    priv->is_nal       = avctx->extradata_size > 0 && *(avctx->extradata) == 1;
 +    priv->last_picture = -1;
 +    priv->decode_wait  = BASE_WAIT;
 +
 +    subtype = id2subtype(priv, avctx->codec->id);
 +    switch (subtype) {
 +    case BC_MSUBTYPE_AVC1:
 +        {
 +            uint8_t *dummy_p;
 +            int dummy_int;
 +
 +            /* Back up the extradata so it can be restored at close time. */
 +            priv->orig_extradata = av_malloc(avctx->extradata_size);
 +            if (!priv->orig_extradata) {
 +                av_log(avctx, AV_LOG_ERROR,
 +                       "Failed to allocate copy of extradata\n");
 +                return AVERROR(ENOMEM);
 +            }
 +            priv->orig_extradata_size = avctx->extradata_size;
 +            memcpy(priv->orig_extradata, avctx->extradata, avctx->extradata_size);
 +
 +            priv->bsfc = av_bitstream_filter_init("h264_mp4toannexb");
 +            if (!priv->bsfc) {
 +                av_log(avctx, AV_LOG_ERROR,
 +                       "Cannot open the h264_mp4toannexb BSF!\n");
 +                return AVERROR_BSF_NOT_FOUND;
 +            }
 +            av_bitstream_filter_filter(priv->bsfc, avctx, NULL, &dummy_p,
 +                                       &dummy_int, NULL, 0, 0);
 +        }
 +        subtype = BC_MSUBTYPE_H264;
 +        // Fall-through
 +    case BC_MSUBTYPE_H264:
 +        format.startCodeSz = 4;
 +        // Fall-through
 +    case BC_MSUBTYPE_VC1:
 +    case BC_MSUBTYPE_WVC1:
 +    case BC_MSUBTYPE_WMV3:
 +    case BC_MSUBTYPE_WMVA:
 +    case BC_MSUBTYPE_MPEG2VIDEO:
 +    case BC_MSUBTYPE_DIVX:
 +    case BC_MSUBTYPE_DIVX311:
 +        format.pMetaData  = avctx->extradata;
 +        format.metaDataSz = avctx->extradata_size;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: Unknown codec name\n");
 +        return AVERROR(EINVAL);
 +    }
 +    format.mSubtype = subtype;
 +
 +    if (priv->sWidth) {
 +        format.bEnableScaling = 1;
 +        format.ScalingParams.sWidth = priv->sWidth;
 +    }
 +
 +    /* Get a decoder instance */
 +    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: starting up\n");
 +    // Initialize the Link and Decoder devices
 +    ret = DtsDeviceOpen(&priv->dev, mode);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: DtsDeviceOpen failed\n");
 +        goto fail;
 +    }
 +
 +    ret = DtsCrystalHDVersion(priv->dev, &version);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_VERBOSE,
 +               "CrystalHD: DtsCrystalHDVersion failed\n");
 +        goto fail;
 +    }
 +    priv->is_70012 = version.device == 0;
 +
 +    if (priv->is_70012 &&
 +        (subtype == BC_MSUBTYPE_DIVX || subtype == BC_MSUBTYPE_DIVX311)) {
 +        av_log(avctx, AV_LOG_VERBOSE,
 +               "CrystalHD: BCM70012 doesn't support MPEG4-ASP/DivX/Xvid\n");
 +        goto fail;
 +    }
 +
 +    ret = DtsSetInputFormat(priv->dev, &format);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: SetInputFormat failed\n");
 +        goto fail;
 +    }
 +
 +    ret = DtsOpenDecoder(priv->dev, BC_STREAM_TYPE_ES);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsOpenDecoder failed\n");
 +        goto fail;
 +    }
 +
 +    ret = DtsSetColorSpace(priv->dev, OUTPUT_MODE422_YUY2);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsSetColorSpace failed\n");
 +        goto fail;
 +    }
 +    ret = DtsStartDecoder(priv->dev);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartDecoder failed\n");
 +        goto fail;
 +    }
 +    ret = DtsStartCapture(priv->dev);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: DtsStartCapture failed\n");
 +        goto fail;
 +    }
 +
 +    if (avctx->codec->id == AV_CODEC_ID_H264) {
 +        priv->parser = av_parser_init(avctx->codec->id);
 +        if (!priv->parser)
 +            av_log(avctx, AV_LOG_WARNING,
 +                   "Cannot open the h.264 parser! Interlaced h.264 content "
 +                   "will not be detected reliably.\n");
 +        priv->parser->flags = PARSER_FLAG_COMPLETE_FRAMES;
 +    }
 +    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Init complete.\n");
 +
 +    return 0;
 +
 + fail:
 +    uninit(avctx);
 +    return -1;
 +}
 +
 +
 +static inline CopyRet copy_frame(AVCodecContext *avctx,
 +                                 BC_DTS_PROC_OUT *output,
 +                                 void *data, int *data_size)
 +{
 +    BC_STATUS ret;
 +    BC_DTS_STATUS decoder_status = { 0, };
 +    uint8_t trust_interlaced;
 +    uint8_t interlaced;
 +
 +    CHDContext *priv = avctx->priv_data;
 +    int64_t pkt_pts  = AV_NOPTS_VALUE;
 +    uint8_t pic_type = 0;
 +
 +    uint8_t bottom_field = (output->PicInfo.flags & VDEC_FLAG_BOTTOMFIELD) ==
 +                           VDEC_FLAG_BOTTOMFIELD;
 +    uint8_t bottom_first = !!(output->PicInfo.flags & VDEC_FLAG_BOTTOM_FIRST);
 +
 +    int width    = output->PicInfo.width;
 +    int height   = output->PicInfo.height;
 +    int bwidth;
 +    uint8_t *src = output->Ybuff;
 +    int sStride;
 +    uint8_t *dst;
 +    int dStride;
 +
 +    if (output->PicInfo.timeStamp != 0) {
 +        OpaqueList *node = opaque_list_pop(priv, output->PicInfo.timeStamp);
 +        if (node) {
 +            pkt_pts = node->reordered_opaque;
 +            pic_type = node->pic_type;
 +            av_free(node);
 +        } else {
 +            /*
 +             * We will encounter a situation where a timestamp cannot be
 +             * popped if a second field is being returned. In this case,
 +             * each field has the same timestamp and the first one will
 +             * cause it to be popped. To keep subsequent calculations
 +             * simple, pic_type should be set a FIELD value - doesn't
 +             * matter which, but I chose BOTTOM.
 +             */
 +            pic_type = PICT_BOTTOM_FIELD;
 +        }
 +        av_log(avctx, AV_LOG_VERBOSE, "output \"pts\": %"PRIu64"\n",
 +               output->PicInfo.timeStamp);
 +        av_log(avctx, AV_LOG_VERBOSE, "output picture type %d\n",
 +               pic_type);
 +    }
 +
 +    ret = DtsGetDriverStatus(priv->dev, &decoder_status);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "CrystalHD: GetDriverStatus failed: %u\n", ret);
 +       return RET_ERROR;
 +    }
 +
 +    /*
 +     * For most content, we can trust the interlaced flag returned
 +     * by the hardware, but sometimes we can't. These are the
 +     * conditions under which we can trust the flag:
 +     *
 +     * 1) It's not h.264 content
 +     * 2) The UNKNOWN_SRC flag is not set
 +     * 3) We know we're expecting a second field
 +     * 4) The hardware reports this picture and the next picture
 +     *    have the same picture number.
 +     *
 +     * Note that there can still be interlaced content that will
 +     * fail this check, if the hardware hasn't decoded the next
 +     * picture or if there is a corruption in the stream. (In either
 +     * case a 0 will be returned for the next picture number)
 +     */
 +    trust_interlaced = avctx->codec->id != AV_CODEC_ID_H264 ||
 +                       !(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
 +                       priv->need_second_field ||
 +                       (decoder_status.picNumFlags & ~0x40000000) ==
 +                       output->PicInfo.picture_number;
 +
 +    /*
 +     * If we got a false negative for trust_interlaced on the first field,
 +     * we will realise our mistake here when we see that the picture number is that
 +     * of the previous picture. We cannot recover the frame and should discard the
 +     * second field to keep the correct number of output frames.
 +     */
 +    if (output->PicInfo.picture_number == priv->last_picture && !priv->need_second_field) {
 +        av_log(avctx, AV_LOG_WARNING,
 +               "Incorrectly guessed progressive frame. Discarding second field\n");
 +        /* Returning without providing a picture. */
 +        return RET_OK;
 +    }
 +
 +    interlaced = (output->PicInfo.flags & VDEC_FLAG_INTERLACED_SRC) &&
 +                 trust_interlaced;
 +
 +    if (!trust_interlaced && (decoder_status.picNumFlags & ~0x40000000) == 0) {
 +        av_log(avctx, AV_LOG_VERBOSE,
 +               "Next picture number unknown. Assuming progressive frame.\n");
 +    }
 +
 +    av_log(avctx, AV_LOG_VERBOSE, "Interlaced state: %d | trust_interlaced %d\n",
 +           interlaced, trust_interlaced);
 +
 +    if (priv->pic.data[0] && !priv->need_second_field)
 +        avctx->release_buffer(avctx, &priv->pic);
 +
 +    priv->need_second_field = interlaced && !priv->need_second_field;
 +
 +    priv->pic.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE |
 +                             FF_BUFFER_HINTS_REUSABLE;
 +    if (!priv->pic.data[0]) {
++        if (ff_get_buffer(avctx, &priv->pic) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +            return RET_ERROR;
 +        }
 +    }
 +
 +    bwidth = av_image_get_linesize(avctx->pix_fmt, width, 0);
 +    if (priv->is_70012) {
 +        int pStride;
 +
 +        if (width <= 720)
 +            pStride = 720;
 +        else if (width <= 1280)
 +            pStride = 1280;
 +        else pStride = 1920;
 +        sStride = av_image_get_linesize(avctx->pix_fmt, pStride, 0);
 +    } else {
 +        sStride = bwidth;
 +    }
 +
 +    dStride = priv->pic.linesize[0];
 +    dst     = priv->pic.data[0];
 +
 +    av_log(priv->avctx, AV_LOG_VERBOSE, "CrystalHD: Copying out frame\n");
 +
 +    if (interlaced) {
 +        int dY = 0;
 +        int sY = 0;
 +
 +        height /= 2;
 +        if (bottom_field) {
 +            av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: bottom field\n");
 +            dY = 1;
 +        } else {
 +            av_log(priv->avctx, AV_LOG_VERBOSE, "Interlaced: top field\n");
 +            dY = 0;
 +        }
 +
 +        for (sY = 0; sY < height; dY++, sY++) {
 +            memcpy(&(dst[dY * dStride]), &(src[sY * sStride]), bwidth);
 +            dY++;
 +        }
 +    } else {
 +        av_image_copy_plane(dst, dStride, src, sStride, bwidth, height);
 +    }
 +
 +    priv->pic.interlaced_frame = interlaced;
 +    if (interlaced)
 +        priv->pic.top_field_first = !bottom_first;
 +
 +    priv->pic.pkt_pts = pkt_pts;
 +
 +    if (!priv->need_second_field) {
 +        *data_size       = sizeof(AVFrame);
 +        *(AVFrame *)data = priv->pic;
 +    }
 +
 +    /*
 +     * Two types of PAFF content have been observed. One form causes the
 +     * hardware to return a field pair and the other individual fields,
 +     * even though the input is always individual fields. We must skip
 +     * copying on the next decode() call to maintain pipeline length in
 +     * the first case.
 +     */
 +    if (!interlaced && (output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) &&
 +        (pic_type == PICT_TOP_FIELD || pic_type == PICT_BOTTOM_FIELD)) {
 +        av_log(priv->avctx, AV_LOG_VERBOSE, "Fieldpair from two packets.\n");
 +        return RET_SKIP_NEXT_COPY;
 +    }
 +
 +    /*
 +     * The logic here is purely based on empirical testing with samples.
 +     * If we need a second field, it could come from a second input packet,
 +     * or it could come from the same field-pair input packet at the current
 +     * field. In the first case, we should return and wait for the next time
 +     * round to get the second field, while in the second case, we should
 +     * ask the decoder for it immediately.
 +     *
 +     * Testing has shown that we are dealing with the fieldpair -> two fields
 +     * case if the VDEC_FLAG_UNKNOWN_SRC is not set or if the input picture
 +     * type was PICT_FRAME (in this second case, the flag might still be set)
 +     */
 +    return priv->need_second_field &&
 +           (!(output->PicInfo.flags & VDEC_FLAG_UNKNOWN_SRC) ||
 +            pic_type == PICT_FRAME) ?
 +           RET_COPY_NEXT_FIELD : RET_OK;
 +}
 +
 +
 +static inline CopyRet receive_frame(AVCodecContext *avctx,
 +                                    void *data, int *data_size)
 +{
 +    BC_STATUS ret;
 +    BC_DTS_PROC_OUT output = {
 +        .PicInfo.width  = avctx->width,
 +        .PicInfo.height = avctx->height,
 +    };
 +    CHDContext *priv = avctx->priv_data;
 +    HANDLE dev       = priv->dev;
 +
 +    *data_size = 0;
 +
 +    // Request decoded data from the driver
 +    ret = DtsProcOutputNoCopy(dev, OUTPUT_PROC_TIMEOUT, &output);
 +    if (ret == BC_STS_FMT_CHANGE) {
 +        av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Initial format change\n");
 +        avctx->width  = output.PicInfo.width;
 +        avctx->height = output.PicInfo.height;
 +        switch ( output.PicInfo.aspect_ratio ) {
 +        case vdecAspectRatioSquare:
 +            avctx->sample_aspect_ratio = (AVRational) {  1,  1};
 +            break;
 +        case vdecAspectRatio12_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 12, 11};
 +            break;
 +        case vdecAspectRatio10_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 10, 11};
 +            break;
 +        case vdecAspectRatio16_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 16, 11};
 +            break;
 +        case vdecAspectRatio40_33:
 +            avctx->sample_aspect_ratio = (AVRational) { 40, 33};
 +            break;
 +        case vdecAspectRatio24_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 24, 11};
 +            break;
 +        case vdecAspectRatio20_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 20, 11};
 +            break;
 +        case vdecAspectRatio32_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 32, 11};
 +            break;
 +        case vdecAspectRatio80_33:
 +            avctx->sample_aspect_ratio = (AVRational) { 80, 33};
 +            break;
 +        case vdecAspectRatio18_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 18, 11};
 +            break;
 +        case vdecAspectRatio15_11:
 +            avctx->sample_aspect_ratio = (AVRational) { 15, 11};
 +            break;
 +        case vdecAspectRatio64_33:
 +            avctx->sample_aspect_ratio = (AVRational) { 64, 33};
 +            break;
 +        case vdecAspectRatio160_99:
 +            avctx->sample_aspect_ratio = (AVRational) {160, 99};
 +            break;
 +        case vdecAspectRatio4_3:
 +            avctx->sample_aspect_ratio = (AVRational) {  4,  3};
 +            break;
 +        case vdecAspectRatio16_9:
 +            avctx->sample_aspect_ratio = (AVRational) { 16,  9};
 +            break;
 +        case vdecAspectRatio221_1:
 +            avctx->sample_aspect_ratio = (AVRational) {221,  1};
 +            break;
 +        }
 +        return RET_COPY_AGAIN;
 +    } else if (ret == BC_STS_SUCCESS) {
 +        int copy_ret = -1;
 +        if (output.PoutFlags & BC_POUT_FLAGS_PIB_VALID) {
 +            if (priv->last_picture == -1) {
 +                /*
 +                 * Init to one less, so that the incrementing code doesn't
 +                 * need to be special-cased.
 +                 */
 +                priv->last_picture = output.PicInfo.picture_number - 1;
 +            }
 +
 +            if (avctx->codec->id == AV_CODEC_ID_MPEG4 &&
 +                output.PicInfo.timeStamp == 0 && priv->bframe_bug) {
 +                av_log(avctx, AV_LOG_VERBOSE,
 +                       "CrystalHD: Not returning packed frame twice.\n");
 +                priv->last_picture++;
 +                DtsReleaseOutputBuffs(dev, NULL, FALSE);
 +                return RET_COPY_AGAIN;
 +            }
 +
 +            print_frame_info(priv, &output);
 +
 +            if (priv->last_picture + 1 < output.PicInfo.picture_number) {
 +                av_log(avctx, AV_LOG_WARNING,
 +                       "CrystalHD: Picture Number discontinuity\n");
 +                /*
 +                 * Have we lost frames? If so, we need to shrink the
 +                 * pipeline length appropriately.
 +                 *
 +                 * XXX: I have no idea what the semantics of this situation
 +                 * are so I don't even know if we've lost frames or which
 +                 * ones.
 +                 *
 +                 * In any case, only warn the first time.
 +                 */
 +               priv->last_picture = output.PicInfo.picture_number - 1;
 +            }
 +
 +            copy_ret = copy_frame(avctx, &output, data, data_size);
 +            if (*data_size > 0) {
 +                avctx->has_b_frames--;
 +                priv->last_picture++;
 +                av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Pipeline length: %u\n",
 +                       avctx->has_b_frames);
 +            }
 +        } else {
 +            /*
 +             * An invalid frame has been consumed.
 +             */
 +            av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput succeeded with "
 +                                        "invalid PIB\n");
 +            avctx->has_b_frames--;
 +            copy_ret = RET_OK;
 +        }
 +        DtsReleaseOutputBuffs(dev, NULL, FALSE);
 +
 +        return copy_ret;
 +    } else if (ret == BC_STS_BUSY) {
 +        return RET_COPY_AGAIN;
 +    } else {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: ProcOutput failed %d\n", ret);
 +        return RET_ERROR;
 +    }
 +}
 +
 +
 +static int decode(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
 +{
 +    BC_STATUS ret;
 +    BC_DTS_STATUS decoder_status = { 0, };
 +    CopyRet rec_ret;
 +    CHDContext *priv   = avctx->priv_data;
 +    HANDLE dev         = priv->dev;
 +    uint8_t *in_data   = avpkt->data;
 +    int len            = avpkt->size;
 +    int free_data      = 0;
 +    uint8_t pic_type   = 0;
 +
 +    av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: decode_frame\n");
 +
 +    if (avpkt->size == 7 && !priv->bframe_bug) {
 +        /*
 +         * The use of a drop frame triggers the bug
 +         */
 +        av_log(avctx, AV_LOG_INFO,
 +               "CrystalHD: Enabling work-around for packed b-frame bug\n");
 +        priv->bframe_bug = 1;
 +    } else if (avpkt->size == 8 && priv->bframe_bug) {
 +        /*
 +         * Delay frames don't trigger the bug
 +         */
 +        av_log(avctx, AV_LOG_INFO,
 +               "CrystalHD: Disabling work-around for packed b-frame bug\n");
 +        priv->bframe_bug = 0;
 +    }
 +
 +    if (len) {
 +        int32_t tx_free = (int32_t)DtsTxFreeSize(dev);
 +
 +        if (priv->parser) {
 +            int ret = 0;
 +
 +            if (priv->bsfc) {
 +                ret = av_bitstream_filter_filter(priv->bsfc, avctx, NULL,
 +                                                 &in_data, &len,
 +                                                 avpkt->data, len, 0);
 +            }
 +            free_data = ret > 0;
 +
 +            if (ret >= 0) {
 +                uint8_t *pout;
 +                int psize;
 +                int index;
 +                H264Context *h = priv->parser->priv_data;
 +
 +                index = av_parser_parse2(priv->parser, avctx, &pout, &psize,
 +                                         in_data, len, avctx->pkt->pts,
 +                                         avctx->pkt->dts, 0);
 +                if (index < 0) {
 +                    av_log(avctx, AV_LOG_WARNING,
 +                           "CrystalHD: Failed to parse h.264 packet to "
 +                           "detect interlacing.\n");
 +                } else if (index != len) {
 +                    av_log(avctx, AV_LOG_WARNING,
 +                           "CrystalHD: Failed to parse h.264 packet "
 +                           "completely. Interlaced frames may be "
 +                           "incorrectly detected.\n");
 +                } else {
 +                    av_log(avctx, AV_LOG_VERBOSE,
 +                           "CrystalHD: parser picture type %d\n",
 +                           h->s.picture_structure);
 +                    pic_type = h->s.picture_structure;
 +                }
 +            } else {
 +                av_log(avctx, AV_LOG_WARNING,
 +                       "CrystalHD: mp4toannexb filter failed to filter "
 +                       "packet. Interlaced frames may be incorrectly "
 +                       "detected.\n");
 +            }
 +        }
 +
 +        if (len < tx_free - 1024) {
 +            /*
 +             * Despite being notionally opaque, either libcrystalhd or
 +             * the hardware itself will mangle pts values that are too
 +             * small or too large. The docs claim it should be in units
 +             * of 100ns. Given that we're nominally dealing with a black
 +             * box on both sides, any transform we do has no guarantee of
 +             * avoiding mangling so we need to build a mapping to values
 +             * we know will not be mangled.
 +             */
 +            uint64_t pts = opaque_list_push(priv, avctx->pkt->pts, pic_type);
 +            if (!pts) {
 +                if (free_data) {
 +                    av_freep(&in_data);
 +                }
 +                return AVERROR(ENOMEM);
 +            }
 +            av_log(priv->avctx, AV_LOG_VERBOSE,
 +                   "input \"pts\": %"PRIu64"\n", pts);
 +            ret = DtsProcInput(dev, in_data, len, pts, 0);
 +            if (free_data) {
 +                av_freep(&in_data);
 +            }
 +            if (ret == BC_STS_BUSY) {
 +                av_log(avctx, AV_LOG_WARNING,
 +                       "CrystalHD: ProcInput returned busy\n");
 +                usleep(BASE_WAIT);
 +                return AVERROR(EBUSY);
 +            } else if (ret != BC_STS_SUCCESS) {
 +                av_log(avctx, AV_LOG_ERROR,
 +                       "CrystalHD: ProcInput failed: %u\n", ret);
 +                return -1;
 +            }
 +            avctx->has_b_frames++;
 +        } else {
 +            av_log(avctx, AV_LOG_WARNING, "CrystalHD: Input buffer full\n");
 +            len = 0; // We didn't consume any bytes.
 +        }
 +    } else {
 +        av_log(avctx, AV_LOG_INFO, "CrystalHD: No more input data\n");
 +    }
 +
 +    if (priv->skip_next_output) {
 +        av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Skipping next output.\n");
 +        priv->skip_next_output = 0;
 +        avctx->has_b_frames--;
 +        return len;
 +    }
 +
 +    ret = DtsGetDriverStatus(dev, &decoder_status);
 +    if (ret != BC_STS_SUCCESS) {
 +        av_log(avctx, AV_LOG_ERROR, "CrystalHD: GetDriverStatus failed\n");
 +        return -1;
 +    }
 +
 +    /*
 +     * No frames ready. Don't try to extract.
 +     *
 +     * Empirical testing shows that ReadyListCount can be a damn lie,
 +     * and ProcOut still fails when count > 0. The same testing showed
 +     * that two more iterations were needed before ProcOutput would
 +     * succeed.
 +     */
 +    if (priv->output_ready < 2) {
 +        if (decoder_status.ReadyListCount != 0)
 +            priv->output_ready++;
 +        usleep(BASE_WAIT);
 +        av_log(avctx, AV_LOG_INFO, "CrystalHD: Filling pipeline.\n");
 +        return len;
 +    } else if (decoder_status.ReadyListCount == 0) {
 +        /*
 +         * After the pipeline is established, if we encounter a lack of frames
 +         * that probably means we're not giving the hardware enough time to
 +         * decode them, so start increasing the wait time at the end of a
 +         * decode call.
 +         */
 +        usleep(BASE_WAIT);
 +        priv->decode_wait += WAIT_UNIT;
 +        av_log(avctx, AV_LOG_INFO, "CrystalHD: No frames ready. Returning\n");
 +        return len;
 +    }
 +
 +    do {
 +        rec_ret = receive_frame(avctx, data, data_size);
 +        if (rec_ret == RET_OK && *data_size == 0) {
 +            /*
 +             * This case is for when the encoded fields are stored
 +             * separately and we get a separate avpkt for each one. To keep
 +             * the pipeline stable, we should return nothing and wait for
 +             * the next time round to grab the second field.
 +             * H.264 PAFF is an example of this.
 +             */
 +            av_log(avctx, AV_LOG_VERBOSE, "Returning after first field.\n");
 +            avctx->has_b_frames--;
 +        } else if (rec_ret == RET_COPY_NEXT_FIELD) {
 +            /*
 +             * This case is for when the encoded fields are stored in a
 +             * single avpkt but the hardware returns then separately. Unless
 +             * we grab the second field before returning, we'll slip another
 +             * frame in the pipeline and if that happens a lot, we're sunk.
 +             * So we have to get that second field now.
 +             * Interlaced mpeg2 and vc1 are examples of this.
 +             */
 +            av_log(avctx, AV_LOG_VERBOSE, "Trying to get second field.\n");
 +            while (1) {
 +                usleep(priv->decode_wait);
 +                ret = DtsGetDriverStatus(dev, &decoder_status);
 +                if (ret == BC_STS_SUCCESS &&
 +                    decoder_status.ReadyListCount > 0) {
 +                    rec_ret = receive_frame(avctx, data, data_size);
 +                    if ((rec_ret == RET_OK && *data_size > 0) ||
 +                        rec_ret == RET_ERROR)
 +                        break;
 +                }
 +            }
 +            av_log(avctx, AV_LOG_VERBOSE, "CrystalHD: Got second field.\n");
 +        } else if (rec_ret == RET_SKIP_NEXT_COPY) {
 +            /*
 +             * Two input packets got turned into a field pair. Gawd.
 +             */
 +            av_log(avctx, AV_LOG_VERBOSE,
 +                   "Don't output on next decode call.\n");
 +            priv->skip_next_output = 1;
 +        }
 +        /*
 +         * If rec_ret == RET_COPY_AGAIN, that means that either we just handled
 +         * a FMT_CHANGE event and need to go around again for the actual frame,
 +         * we got a busy status and need to try again, or we're dealing with
 +         * packed b-frames, where the hardware strangely returns the packed
 +         * p-frame twice. We choose to keep the second copy as it carries the
 +         * valid pts.
 +         */
 +    } while (rec_ret == RET_COPY_AGAIN);
 +    usleep(priv->decode_wait);
 +    return len;
 +}
 +
 +
 +#if CONFIG_H264_CRYSTALHD_DECODER
 +static AVClass h264_class = {
 +    "h264_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_h264_crystalhd_decoder = {
 +    .name           = "h264_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_H264,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &h264_class,
 +};
 +#endif
 +
 +#if CONFIG_MPEG2_CRYSTALHD_DECODER
 +static AVClass mpeg2_class = {
 +    "mpeg2_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_mpeg2_crystalhd_decoder = {
 +    .name           = "mpeg2_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_MPEG2VIDEO,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 Video (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &mpeg2_class,
 +};
 +#endif
 +
 +#if CONFIG_MPEG4_CRYSTALHD_DECODER
 +static AVClass mpeg4_class = {
 +    "mpeg4_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_mpeg4_crystalhd_decoder = {
 +    .name           = "mpeg4_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_MPEG4,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &mpeg4_class,
 +};
 +#endif
 +
 +#if CONFIG_MSMPEG4_CRYSTALHD_DECODER
 +static AVClass msmpeg4_class = {
 +    "msmpeg4_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_msmpeg4_crystalhd_decoder = {
 +    .name           = "msmpeg4_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_MSMPEG4V3,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY | CODEC_CAP_EXPERIMENTAL,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 Part 2 Microsoft variant version 3 (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &msmpeg4_class,
 +};
 +#endif
 +
 +#if CONFIG_VC1_CRYSTALHD_DECODER
 +static AVClass vc1_class = {
 +    "vc1_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_vc1_crystalhd_decoder = {
 +    .name           = "vc1_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_VC1,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &vc1_class,
 +};
 +#endif
 +
 +#if CONFIG_WMV3_CRYSTALHD_DECODER
 +static AVClass wmv3_class = {
 +    "wmv3_crystalhd",
 +    av_default_item_name,
 +    options,
 +    LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_wmv3_crystalhd_decoder = {
 +    .name           = "wmv3_crystalhd",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_WMV3,
 +    .priv_data_size = sizeof(CHDContext),
 +    .init           = init,
 +    .close          = uninit,
 +    .decode         = decode,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_DELAY,
 +    .flush          = flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 (CrystalHD acceleration)"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){AV_PIX_FMT_YUYV422, AV_PIX_FMT_NONE},
 +    .priv_class     = &wmv3_class,
 +};
 +#endif
Simple merge
Simple merge
Simple merge
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +#include "libavutil/avassert.h"
  #include "avcodec.h"
  #include "bytestream.h"
+ #include "internal.h"
  
  #include "libavutil/imgutils.h"
  #include "libavutil/mem.h"
index 6e81491,0000000..571989a
mode 100644,000000..100644
--- /dev/null
@@@ -1,1932 -1,0 +1,1933 @@@
-                     s->avctx->get_buffer(s->avctx, &s->ref_pics[i]->avframe);
 +/*
 + * Copyright (C) 2007 Marco Gerards <marco@gnu.org>
 + * Copyright (C) 2009 David Conrad
 + * Copyright (C) 2011 Jordi Ortiz
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * Dirac Decoder
 + * @author Marco Gerards <marco@gnu.org>, David Conrad, Jordi Ortiz <nenjordi@gmail.com>
 + */
 +
 +#include "avcodec.h"
 +#include "dsputil.h"
 +#include "get_bits.h"
 +#include "bytestream.h"
++#include "internal.h"
 +#include "golomb.h"
 +#include "dirac_arith.h"
 +#include "mpeg12data.h"
 +#include "dwt.h"
 +#include "dirac.h"
 +#include "diracdsp.h"
 +
 +/**
 + * The spec limits the number of wavelet decompositions to 4 for both
 + * level 1 (VC-2) and 128 (long-gop default).
 + * 5 decompositions is the maximum before >16-bit buffers are needed.
 + * Schroedinger allows this for DD 9,7 and 13,7 wavelets only, limiting
 + * the others to 4 decompositions (or 3 for the fidelity filter).
 + *
 + * We use this instead of MAX_DECOMPOSITIONS to save some memory.
 + */
 +#define MAX_DWT_LEVELS 5
 +
 +/**
 + * The spec limits this to 3 for frame coding, but in practice can be as high as 6
 + */
 +#define MAX_REFERENCE_FRAMES 8
 +#define MAX_DELAY 5         /* limit for main profile for frame coding (TODO: field coding) */
 +#define MAX_FRAMES (MAX_REFERENCE_FRAMES + MAX_DELAY + 1)
 +#define MAX_QUANT 68        /* max quant for VC-2 */
 +#define MAX_BLOCKSIZE 32    /* maximum xblen/yblen we support */
 +
 +/**
 + * DiracBlock->ref flags, if set then the block does MC from the given ref
 + */
 +#define DIRAC_REF_MASK_REF1   1
 +#define DIRAC_REF_MASK_REF2   2
 +#define DIRAC_REF_MASK_GLOBAL 4
 +
 +/**
 + * Value of Picture.reference when Picture is not a reference picture, but
 + * is held for delayed output.
 + */
 +#define DELAYED_PIC_REF 4
 +
 +#define ff_emulated_edge_mc ff_emulated_edge_mc_8 /* Fix: change the calls to this function regarding bit depth */
 +
 +#define CALC_PADDING(size, depth)                       \
 +    (((size + (1 << depth) - 1) >> depth) << depth)
 +
 +#define DIVRNDUP(a, b) (((a) + (b) - 1) / (b))
 +
 +typedef struct {
 +    AVFrame avframe;
 +    int interpolated[3];    /* 1 if hpel[] is valid */
 +    uint8_t *hpel[3][4];
 +    uint8_t *hpel_base[3][4];
 +} DiracFrame;
 +
 +typedef struct {
 +    union {
 +        int16_t mv[2][2];
 +        int16_t dc[3];
 +    } u; /* anonymous unions aren't in C99 :( */
 +    uint8_t ref;
 +} DiracBlock;
 +
 +typedef struct SubBand {
 +    int level;
 +    int orientation;
 +    int stride;
 +    int width;
 +    int height;
 +    int quant;
 +    IDWTELEM *ibuf;
 +    struct SubBand *parent;
 +
 +    /* for low delay */
 +    unsigned length;
 +    const uint8_t *coeff_data;
 +} SubBand;
 +
 +typedef struct Plane {
 +    int width;
 +    int height;
 +    int stride;
 +
 +    int idwt_width;
 +    int idwt_height;
 +    int idwt_stride;
 +    IDWTELEM *idwt_buf;
 +    IDWTELEM *idwt_buf_base;
 +    IDWTELEM *idwt_tmp;
 +
 +    /* block length */
 +    uint8_t xblen;
 +    uint8_t yblen;
 +    /* block separation (block n+1 starts after this many pixels in block n) */
 +    uint8_t xbsep;
 +    uint8_t ybsep;
 +    /* amount of overspill on each edge (half of the overlap between blocks) */
 +    uint8_t xoffset;
 +    uint8_t yoffset;
 +
 +    SubBand band[MAX_DWT_LEVELS][4];
 +} Plane;
 +
 +typedef struct DiracContext {
 +    AVCodecContext *avctx;
 +    DSPContext dsp;
 +    DiracDSPContext diracdsp;
 +    GetBitContext gb;
 +    dirac_source_params source;
 +    int seen_sequence_header;
 +    int frame_number;           /* number of the next frame to display       */
 +    Plane plane[3];
 +    int chroma_x_shift;
 +    int chroma_y_shift;
 +
 +    int zero_res;               /* zero residue flag                         */
 +    int is_arith;               /* whether coeffs use arith or golomb coding */
 +    int low_delay;              /* use the low delay syntax                  */
 +    int globalmc_flag;          /* use global motion compensation            */
 +    int num_refs;               /* number of reference pictures              */
 +
 +    /* wavelet decoding */
 +    unsigned wavelet_depth;     /* depth of the IDWT                         */
 +    unsigned wavelet_idx;
 +
 +    /**
 +     * schroedinger older than 1.0.8 doesn't store
 +     * quant delta if only one codebook exists in a band
 +     */
 +    unsigned old_delta_quant;
 +    unsigned codeblock_mode;
 +
 +    struct {
 +        unsigned width;
 +        unsigned height;
 +    } codeblock[MAX_DWT_LEVELS+1];
 +
 +    struct {
 +        unsigned num_x;         /* number of horizontal slices               */
 +        unsigned num_y;         /* number of vertical slices                 */
 +        AVRational bytes;       /* average bytes per slice                   */
 +        uint8_t quant[MAX_DWT_LEVELS][4]; /* [DIRAC_STD] E.1 */
 +    } lowdelay;
 +
 +    struct {
 +        int pan_tilt[2];        /* pan/tilt vector                           */
 +        int zrs[2][2];          /* zoom/rotate/shear matrix                  */
 +        int perspective[2];     /* perspective vector                        */
 +        unsigned zrs_exp;
 +        unsigned perspective_exp;
 +    } globalmc[2];
 +
 +    /* motion compensation */
 +    uint8_t mv_precision;       /* [DIRAC_STD] REFS_WT_PRECISION             */
 +    int16_t weight[2];          /* [DIRAC_STD] REF1_WT and REF2_WT           */
 +    unsigned weight_log2denom;  /* [DIRAC_STD] REFS_WT_PRECISION             */
 +
 +    int blwidth;                /* number of blocks (horizontally)           */
 +    int blheight;               /* number of blocks (vertically)             */
 +    int sbwidth;                /* number of superblocks (horizontally)      */
 +    int sbheight;               /* number of superblocks (vertically)        */
 +
 +    uint8_t *sbsplit;
 +    DiracBlock *blmotion;
 +
 +    uint8_t *edge_emu_buffer[4];
 +    uint8_t *edge_emu_buffer_base;
 +
 +    uint16_t *mctmp;            /* buffer holding the MC data multipled by OBMC weights */
 +    uint8_t *mcscratch;
 +
 +    DECLARE_ALIGNED(16, uint8_t, obmc_weight)[3][MAX_BLOCKSIZE*MAX_BLOCKSIZE];
 +
 +    void (*put_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
 +    void (*avg_pixels_tab[4])(uint8_t *dst, const uint8_t *src[5], int stride, int h);
 +    void (*add_obmc)(uint16_t *dst, const uint8_t *src, int stride, const uint8_t *obmc_weight, int yblen);
 +    dirac_weight_func weight_func;
 +    dirac_biweight_func biweight_func;
 +
 +    DiracFrame *current_picture;
 +    DiracFrame *ref_pics[2];
 +
 +    DiracFrame *ref_frames[MAX_REFERENCE_FRAMES+1];
 +    DiracFrame *delay_frames[MAX_DELAY+1];
 +    DiracFrame all_frames[MAX_FRAMES];
 +} DiracContext;
 +
 +/**
 + * Dirac Specification ->
 + * Parse code values. 9.6.1 Table 9.1
 + */
 +enum dirac_parse_code {
 +    pc_seq_header         = 0x00,
 +    pc_eos                = 0x10,
 +    pc_aux_data           = 0x20,
 +    pc_padding            = 0x30,
 +};
 +
 +enum dirac_subband {
 +    subband_ll = 0,
 +    subband_hl = 1,
 +    subband_lh = 2,
 +    subband_hh = 3
 +};
 +
 +static const uint8_t default_qmat[][4][4] = {
 +    { { 5,  3,  3,  0}, { 0,  4,  4,  1}, { 0,  5,  5,  2}, { 0,  6,  6,  3} },
 +    { { 4,  2,  2,  0}, { 0,  4,  4,  2}, { 0,  5,  5,  3}, { 0,  7,  7,  5} },
 +    { { 5,  3,  3,  0}, { 0,  4,  4,  1}, { 0,  5,  5,  2}, { 0,  6,  6,  3} },
 +    { { 8,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0} },
 +    { { 8,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0}, { 0,  4,  4,  0} },
 +    { { 0,  4,  4,  8}, { 0,  8,  8, 12}, { 0, 13, 13, 17}, { 0, 17, 17, 21} },
 +    { { 3,  1,  1,  0}, { 0,  4,  4,  2}, { 0,  6,  6,  5}, { 0,  9,  9,  7} },
 +};
 +
 +static const int qscale_tab[MAX_QUANT+1] = {
 +    4,     5,     6,     7,     8,    10,    11,    13,
 +    16,    19,    23,    27,    32,    38,    45,    54,
 +    64,    76,    91,   108,   128,   152,   181,   215,
 +    256,   304,   362,   431,   512,   609,   724,   861,
 +    1024,  1218,  1448,  1722,  2048,  2435,  2896,  3444,
 +    4096,  4871,  5793,  6889,  8192,  9742, 11585, 13777,
 +    16384, 19484, 23170, 27554, 32768, 38968, 46341, 55109,
 +    65536, 77936
 +};
 +
 +static const int qoffset_intra_tab[MAX_QUANT+1] = {
 +    1,     2,     3,     4,     4,     5,     6,     7,
 +    8,    10,    12,    14,    16,    19,    23,    27,
 +    32,    38,    46,    54,    64,    76,    91,   108,
 +    128,   152,   181,   216,   256,   305,   362,   431,
 +    512,   609,   724,   861,  1024,  1218,  1448,  1722,
 +    2048,  2436,  2897,  3445,  4096,  4871,  5793,  6889,
 +    8192,  9742, 11585, 13777, 16384, 19484, 23171, 27555,
 +    32768, 38968
 +};
 +
 +static const int qoffset_inter_tab[MAX_QUANT+1] = {
 +    1,     2,     2,     3,     3,     4,     4,     5,
 +    6,     7,     9,    10,    12,    14,    17,    20,
 +    24,    29,    34,    41,    48,    57,    68,    81,
 +    96,   114,   136,   162,   192,   228,   272,   323,
 +    384,   457,   543,   646,   768,   913,  1086,  1292,
 +    1536,  1827,  2172,  2583,  3072,  3653,  4344,  5166,
 +    6144,  7307,  8689, 10333, 12288, 14613, 17378, 20666,
 +    24576, 29226
 +};
 +
 +/* magic number division by 3 from schroedinger */
 +static inline int divide3(int x)
 +{
 +    return ((x+1)*21845 + 10922) >> 16;
 +}
 +
 +static DiracFrame *remove_frame(DiracFrame *framelist[], int picnum)
 +{
 +    DiracFrame *remove_pic = NULL;
 +    int i, remove_idx = -1;
 +
 +    for (i = 0; framelist[i]; i++)
 +        if (framelist[i]->avframe.display_picture_number == picnum) {
 +            remove_pic = framelist[i];
 +            remove_idx = i;
 +        }
 +
 +    if (remove_pic)
 +        for (i = remove_idx; framelist[i]; i++)
 +            framelist[i] = framelist[i+1];
 +
 +    return remove_pic;
 +}
 +
 +static int add_frame(DiracFrame *framelist[], int maxframes, DiracFrame *frame)
 +{
 +    int i;
 +    for (i = 0; i < maxframes; i++)
 +        if (!framelist[i]) {
 +            framelist[i] = frame;
 +            return 0;
 +        }
 +    return -1;
 +}
 +
 +static int alloc_sequence_buffers(DiracContext *s)
 +{
 +    int sbwidth  = DIVRNDUP(s->source.width,  4);
 +    int sbheight = DIVRNDUP(s->source.height, 4);
 +    int i, w, h, top_padding;
 +
 +    /* todo: think more about this / use or set Plane here */
 +    for (i = 0; i < 3; i++) {
 +        int max_xblen = MAX_BLOCKSIZE >> (i ? s->chroma_x_shift : 0);
 +        int max_yblen = MAX_BLOCKSIZE >> (i ? s->chroma_y_shift : 0);
 +        w = s->source.width  >> (i ? s->chroma_x_shift : 0);
 +        h = s->source.height >> (i ? s->chroma_y_shift : 0);
 +
 +        /* we allocate the max we support here since num decompositions can
 +         * change from frame to frame. Stride is aligned to 16 for SIMD, and
 +         * 1<<MAX_DWT_LEVELS top padding to avoid if(y>0) in arith decoding
 +         * MAX_BLOCKSIZE padding for MC: blocks can spill up to half of that
 +         * on each side */
 +        top_padding = FFMAX(1<<MAX_DWT_LEVELS, max_yblen/2);
 +        w = FFALIGN(CALC_PADDING(w, MAX_DWT_LEVELS), 8); /* FIXME: Should this be 16 for SSE??? */
 +        h = top_padding + CALC_PADDING(h, MAX_DWT_LEVELS) + max_yblen/2;
 +
 +        s->plane[i].idwt_buf_base = av_mallocz((w+max_xblen)*h * sizeof(IDWTELEM));
 +        s->plane[i].idwt_tmp      = av_malloc((w+16) * sizeof(IDWTELEM));
 +        s->plane[i].idwt_buf      = s->plane[i].idwt_buf_base + top_padding*w;
 +        if (!s->plane[i].idwt_buf_base || !s->plane[i].idwt_tmp)
 +            return AVERROR(ENOMEM);
 +    }
 +
 +    w = s->source.width;
 +    h = s->source.height;
 +
 +    /* fixme: allocate using real stride here */
 +    s->sbsplit  = av_malloc(sbwidth * sbheight);
 +    s->blmotion = av_malloc(sbwidth * sbheight * 16 * sizeof(*s->blmotion));
 +    s->edge_emu_buffer_base = av_malloc((w+64)*MAX_BLOCKSIZE);
 +
 +    s->mctmp     = av_malloc((w+64+MAX_BLOCKSIZE) * (h*MAX_BLOCKSIZE) * sizeof(*s->mctmp));
 +    s->mcscratch = av_malloc((w+64)*MAX_BLOCKSIZE);
 +
 +    if (!s->sbsplit || !s->blmotion)
 +        return AVERROR(ENOMEM);
 +    return 0;
 +}
 +
 +static void free_sequence_buffers(DiracContext *s)
 +{
 +    int i, j, k;
 +
 +    for (i = 0; i < MAX_FRAMES; i++) {
 +        if (s->all_frames[i].avframe.data[0]) {
 +            s->avctx->release_buffer(s->avctx, &s->all_frames[i].avframe);
 +            memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
 +        }
 +
 +        for (j = 0; j < 3; j++)
 +            for (k = 1; k < 4; k++)
 +                av_freep(&s->all_frames[i].hpel_base[j][k]);
 +    }
 +
 +    memset(s->ref_frames, 0, sizeof(s->ref_frames));
 +    memset(s->delay_frames, 0, sizeof(s->delay_frames));
 +
 +    for (i = 0; i < 3; i++) {
 +        av_freep(&s->plane[i].idwt_buf_base);
 +        av_freep(&s->plane[i].idwt_tmp);
 +    }
 +
 +    av_freep(&s->sbsplit);
 +    av_freep(&s->blmotion);
 +    av_freep(&s->edge_emu_buffer_base);
 +
 +    av_freep(&s->mctmp);
 +    av_freep(&s->mcscratch);
 +}
 +
 +static av_cold int dirac_decode_init(AVCodecContext *avctx)
 +{
 +    DiracContext *s = avctx->priv_data;
 +    s->avctx = avctx;
 +    s->frame_number = -1;
 +
 +    if (avctx->flags&CODEC_FLAG_EMU_EDGE) {
 +        av_log(avctx, AV_LOG_ERROR, "Edge emulation not supported!\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    ff_dsputil_init(&s->dsp, avctx);
 +    ff_diracdsp_init(&s->diracdsp);
 +
 +    return 0;
 +}
 +
 +static void dirac_decode_flush(AVCodecContext *avctx)
 +{
 +    DiracContext *s = avctx->priv_data;
 +    free_sequence_buffers(s);
 +    s->seen_sequence_header = 0;
 +    s->frame_number = -1;
 +}
 +
 +static av_cold int dirac_decode_end(AVCodecContext *avctx)
 +{
 +    dirac_decode_flush(avctx);
 +    return 0;
 +}
 +
 +#define SIGN_CTX(x) (CTX_SIGN_ZERO + ((x) > 0) - ((x) < 0))
 +
 +static inline void coeff_unpack_arith(DiracArith *c, int qfactor, int qoffset,
 +                                      SubBand *b, IDWTELEM *buf, int x, int y)
 +{
 +    int coeff, sign;
 +    int sign_pred = 0;
 +    int pred_ctx = CTX_ZPZN_F1;
 +
 +    /* Check if the parent subband has a 0 in the corresponding position */
 +    if (b->parent)
 +        pred_ctx += !!b->parent->ibuf[b->parent->stride * (y>>1) + (x>>1)] << 1;
 +
 +    if (b->orientation == subband_hl)
 +        sign_pred = buf[-b->stride];
 +
 +    /* Determine if the pixel has only zeros in its neighbourhood */
 +    if (x) {
 +        pred_ctx += !(buf[-1] | buf[-b->stride] | buf[-1-b->stride]);
 +        if (b->orientation == subband_lh)
 +            sign_pred = buf[-1];
 +    } else {
 +        pred_ctx += !buf[-b->stride];
 +    }
 +
 +    coeff = dirac_get_arith_uint(c, pred_ctx, CTX_COEFF_DATA);
 +    if (coeff) {
 +        coeff = (coeff * qfactor + qoffset + 2) >> 2;
 +        sign  = dirac_get_arith_bit(c, SIGN_CTX(sign_pred));
 +        coeff = (coeff ^ -sign) + sign;
 +    }
 +    *buf = coeff;
 +}
 +
 +static inline int coeff_unpack_golomb(GetBitContext *gb, int qfactor, int qoffset)
 +{
 +    int sign, coeff;
 +
 +    coeff = svq3_get_ue_golomb(gb);
 +    if (coeff) {
 +        coeff = (coeff * qfactor + qoffset + 2) >> 2;
 +        sign  = get_bits1(gb);
 +        coeff = (coeff ^ -sign) + sign;
 +    }
 +    return coeff;
 +}
 +
 +/**
 + * Decode the coeffs in the rectangle defined by left, right, top, bottom
 + * [DIRAC_STD] 13.4.3.2 Codeblock unpacking loop. codeblock()
 + */
 +static inline void codeblock(DiracContext *s, SubBand *b,
 +                             GetBitContext *gb, DiracArith *c,
 +                             int left, int right, int top, int bottom,
 +                             int blockcnt_one, int is_arith)
 +{
 +    int x, y, zero_block;
 +    int qoffset, qfactor;
 +    IDWTELEM *buf;
 +
 +    /* check for any coded coefficients in this codeblock */
 +    if (!blockcnt_one) {
 +        if (is_arith)
 +            zero_block = dirac_get_arith_bit(c, CTX_ZERO_BLOCK);
 +        else
 +            zero_block = get_bits1(gb);
 +
 +        if (zero_block)
 +            return;
 +    }
 +
 +    if (s->codeblock_mode && !(s->old_delta_quant && blockcnt_one)) {
 +        int quant = b->quant;
 +        if (is_arith)
 +            quant += dirac_get_arith_int(c, CTX_DELTA_Q_F, CTX_DELTA_Q_DATA);
 +        else
 +            quant += dirac_get_se_golomb(gb);
 +        if (quant < 0) {
 +            av_log(s->avctx, AV_LOG_ERROR, "Invalid quant\n");
 +            return;
 +        }
 +        b->quant = quant;
 +    }
 +
 +    b->quant = FFMIN(b->quant, MAX_QUANT);
 +
 +    qfactor = qscale_tab[b->quant];
 +    /* TODO: context pointer? */
 +    if (!s->num_refs)
 +        qoffset = qoffset_intra_tab[b->quant];
 +    else
 +        qoffset = qoffset_inter_tab[b->quant];
 +
 +    buf = b->ibuf + top * b->stride;
 +    for (y = top; y < bottom; y++) {
 +        for (x = left; x < right; x++) {
 +            /* [DIRAC_STD] 13.4.4 Subband coefficients. coeff_unpack() */
 +            if (is_arith)
 +                coeff_unpack_arith(c, qfactor, qoffset, b, buf+x, x, y);
 +            else
 +                buf[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
 +        }
 +        buf += b->stride;
 +    }
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 13.3 intra_dc_prediction(band)
 + */
 +static inline void intra_dc_prediction(SubBand *b)
 +{
 +    IDWTELEM *buf = b->ibuf;
 +    int x, y;
 +
 +    for (x = 1; x < b->width; x++)
 +        buf[x] += buf[x-1];
 +    buf += b->stride;
 +
 +    for (y = 1; y < b->height; y++) {
 +        buf[0] += buf[-b->stride];
 +
 +        for (x = 1; x < b->width; x++) {
 +            int pred = buf[x - 1] + buf[x - b->stride] + buf[x - b->stride-1];
 +            buf[x]  += divide3(pred);
 +        }
 +        buf += b->stride;
 +    }
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 13.4.2 Non-skipped subbands.  subband_coeffs()
 + */
 +static av_always_inline void decode_subband_internal(DiracContext *s, SubBand *b, int is_arith)
 +{
 +    int cb_x, cb_y, left, right, top, bottom;
 +    DiracArith c;
 +    GetBitContext gb;
 +    int cb_width  = s->codeblock[b->level + (b->orientation != subband_ll)].width;
 +    int cb_height = s->codeblock[b->level + (b->orientation != subband_ll)].height;
 +    int blockcnt_one = (cb_width + cb_height) == 2;
 +
 +    if (!b->length)
 +        return;
 +
 +    init_get_bits(&gb, b->coeff_data, b->length*8);
 +
 +    if (is_arith)
 +        ff_dirac_init_arith_decoder(&c, &gb, b->length);
 +
 +    top = 0;
 +    for (cb_y = 0; cb_y < cb_height; cb_y++) {
 +        bottom = (b->height * (cb_y+1)) / cb_height;
 +        left = 0;
 +        for (cb_x = 0; cb_x < cb_width; cb_x++) {
 +            right = (b->width * (cb_x+1)) / cb_width;
 +            codeblock(s, b, &gb, &c, left, right, top, bottom, blockcnt_one, is_arith);
 +            left = right;
 +        }
 +        top = bottom;
 +    }
 +
 +    if (b->orientation == subband_ll && s->num_refs == 0)
 +        intra_dc_prediction(b);
 +}
 +
 +static int decode_subband_arith(AVCodecContext *avctx, void *b)
 +{
 +    DiracContext *s = avctx->priv_data;
 +    decode_subband_internal(s, b, 1);
 +    return 0;
 +}
 +
 +static int decode_subband_golomb(AVCodecContext *avctx, void *arg)
 +{
 +    DiracContext *s = avctx->priv_data;
 +    SubBand **b     = arg;
 +    decode_subband_internal(s, *b, 0);
 +    return 0;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * [DIRAC_STD] 13.4.1 core_transform_data()
 + */
 +static void decode_component(DiracContext *s, int comp)
 +{
 +    AVCodecContext *avctx = s->avctx;
 +    SubBand *bands[3*MAX_DWT_LEVELS+1];
 +    enum dirac_subband orientation;
 +    int level, num_bands = 0;
 +
 +    /* Unpack all subbands at all levels. */
 +    for (level = 0; level < s->wavelet_depth; level++) {
 +        for (orientation = !!level; orientation < 4; orientation++) {
 +            SubBand *b = &s->plane[comp].band[level][orientation];
 +            bands[num_bands++] = b;
 +
 +            align_get_bits(&s->gb);
 +            /* [DIRAC_STD] 13.4.2 subband() */
 +            b->length = svq3_get_ue_golomb(&s->gb);
 +            if (b->length) {
 +                b->quant = svq3_get_ue_golomb(&s->gb);
 +                align_get_bits(&s->gb);
 +                b->coeff_data = s->gb.buffer + get_bits_count(&s->gb)/8;
 +                b->length = FFMIN(b->length, FFMAX(get_bits_left(&s->gb)/8, 0));
 +                skip_bits_long(&s->gb, b->length*8);
 +            }
 +        }
 +        /* arithmetic coding has inter-level dependencies, so we can only execute one level at a time */
 +        if (s->is_arith)
 +            avctx->execute(avctx, decode_subband_arith, &s->plane[comp].band[level][!!level],
 +                           NULL, 4-!!level, sizeof(SubBand));
 +    }
 +    /* golomb coding has no inter-level dependencies, so we can execute all subbands in parallel */
 +    if (!s->is_arith)
 +        avctx->execute(avctx, decode_subband_golomb, bands, NULL, num_bands, sizeof(SubBand*));
 +}
 +
 +/* [DIRAC_STD] 13.5.5.2 Luma slice subband data. luma_slice_band(level,orient,sx,sy) --> if b2 == NULL */
 +/* [DIRAC_STD] 13.5.5.3 Chroma slice subband data. chroma_slice_band(level,orient,sx,sy) --> if b2 != NULL */
 +static void lowdelay_subband(DiracContext *s, GetBitContext *gb, int quant,
 +                             int slice_x, int slice_y, int bits_end,
 +                             SubBand *b1, SubBand *b2)
 +{
 +    int left   = b1->width  * slice_x    / s->lowdelay.num_x;
 +    int right  = b1->width  *(slice_x+1) / s->lowdelay.num_x;
 +    int top    = b1->height * slice_y    / s->lowdelay.num_y;
 +    int bottom = b1->height *(slice_y+1) / s->lowdelay.num_y;
 +
 +    int qfactor = qscale_tab[FFMIN(quant, MAX_QUANT)];
 +    int qoffset = qoffset_intra_tab[FFMIN(quant, MAX_QUANT)];
 +
 +    IDWTELEM *buf1 =      b1->ibuf + top * b1->stride;
 +    IDWTELEM *buf2 = b2 ? b2->ibuf + top * b2->stride : NULL;
 +    int x, y;
 +    /* we have to constantly check for overread since the spec explictly
 +       requires this, with the meaning that all remaining coeffs are set to 0 */
 +    if (get_bits_count(gb) >= bits_end)
 +        return;
 +
 +    for (y = top; y < bottom; y++) {
 +        for (x = left; x < right; x++) {
 +            buf1[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
 +            if (get_bits_count(gb) >= bits_end)
 +                return;
 +            if (buf2) {
 +                buf2[x] = coeff_unpack_golomb(gb, qfactor, qoffset);
 +                if (get_bits_count(gb) >= bits_end)
 +                    return;
 +            }
 +        }
 +        buf1 += b1->stride;
 +        if (buf2)
 +            buf2 += b2->stride;
 +    }
 +}
 +
 +struct lowdelay_slice {
 +    GetBitContext gb;
 +    int slice_x;
 +    int slice_y;
 +    int bytes;
 +};
 +
 +
 +/**
 + * Dirac Specification ->
 + * 13.5.2 Slices. slice(sx,sy)
 + */
 +static int decode_lowdelay_slice(AVCodecContext *avctx, void *arg)
 +{
 +    DiracContext *s = avctx->priv_data;
 +    struct lowdelay_slice *slice = arg;
 +    GetBitContext *gb = &slice->gb;
 +    enum dirac_subband orientation;
 +    int level, quant, chroma_bits, chroma_end;
 +
 +    int quant_base  = get_bits(gb, 7); /*[DIRAC_STD] qindex */
 +    int length_bits = av_log2(8 * slice->bytes)+1;
 +    int luma_bits   = get_bits_long(gb, length_bits);
 +    int luma_end    = get_bits_count(gb) + FFMIN(luma_bits, get_bits_left(gb));
 +
 +    /* [DIRAC_STD] 13.5.5.2 luma_slice_band */
 +    for (level = 0; level < s->wavelet_depth; level++)
 +        for (orientation = !!level; orientation < 4; orientation++) {
 +            quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
 +            lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, luma_end,
 +                             &s->plane[0].band[level][orientation], NULL);
 +        }
 +
 +    /* consume any unused bits from luma */
 +    skip_bits_long(gb, get_bits_count(gb) - luma_end);
 +
 +    chroma_bits = 8*slice->bytes - 7 - length_bits - luma_bits;
 +    chroma_end  = get_bits_count(gb) + FFMIN(chroma_bits, get_bits_left(gb));
 +    /* [DIRAC_STD] 13.5.5.3 chroma_slice_band */
 +    for (level = 0; level < s->wavelet_depth; level++)
 +        for (orientation = !!level; orientation < 4; orientation++) {
 +            quant = FFMAX(quant_base - s->lowdelay.quant[level][orientation], 0);
 +            lowdelay_subband(s, gb, quant, slice->slice_x, slice->slice_y, chroma_end,
 +                             &s->plane[1].band[level][orientation],
 +                             &s->plane[2].band[level][orientation]);
 +        }
 +
 +    return 0;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 13.5.1 low_delay_transform_data()
 + */
 +static void decode_lowdelay(DiracContext *s)
 +{
 +    AVCodecContext *avctx = s->avctx;
 +    int slice_x, slice_y, bytes, bufsize;
 +    const uint8_t *buf;
 +    struct lowdelay_slice *slices;
 +    int slice_num = 0;
 +
 +    slices = av_mallocz(s->lowdelay.num_x * s->lowdelay.num_y * sizeof(struct lowdelay_slice));
 +
 +    align_get_bits(&s->gb);
 +    /*[DIRAC_STD] 13.5.2 Slices. slice(sx,sy) */
 +    buf = s->gb.buffer + get_bits_count(&s->gb)/8;
 +    bufsize = get_bits_left(&s->gb);
 +
 +    for (slice_y = 0; bufsize > 0 && slice_y < s->lowdelay.num_y; slice_y++)
 +        for (slice_x = 0; bufsize > 0 && slice_x < s->lowdelay.num_x; slice_x++) {
 +            bytes = (slice_num+1) * s->lowdelay.bytes.num / s->lowdelay.bytes.den
 +                - slice_num    * s->lowdelay.bytes.num / s->lowdelay.bytes.den;
 +
 +            slices[slice_num].bytes   = bytes;
 +            slices[slice_num].slice_x = slice_x;
 +            slices[slice_num].slice_y = slice_y;
 +            init_get_bits(&slices[slice_num].gb, buf, bufsize);
 +            slice_num++;
 +
 +            buf     += bytes;
 +            bufsize -= bytes*8;
 +        }
 +
 +    avctx->execute(avctx, decode_lowdelay_slice, slices, NULL, slice_num,
 +                   sizeof(struct lowdelay_slice)); /* [DIRAC_STD] 13.5.2 Slices */
 +    intra_dc_prediction(&s->plane[0].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 +    intra_dc_prediction(&s->plane[1].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 +    intra_dc_prediction(&s->plane[2].band[0][0]);  /* [DIRAC_STD] 13.3 intra_dc_prediction() */
 +    av_free(slices);
 +}
 +
 +static void init_planes(DiracContext *s)
 +{
 +    int i, w, h, level, orientation;
 +
 +    for (i = 0; i < 3; i++) {
 +        Plane *p = &s->plane[i];
 +
 +        p->width       = s->source.width  >> (i ? s->chroma_x_shift : 0);
 +        p->height      = s->source.height >> (i ? s->chroma_y_shift : 0);
 +        p->idwt_width  = w = CALC_PADDING(p->width , s->wavelet_depth);
 +        p->idwt_height = h = CALC_PADDING(p->height, s->wavelet_depth);
 +        p->idwt_stride = FFALIGN(p->idwt_width, 8);
 +
 +        for (level = s->wavelet_depth-1; level >= 0; level--) {
 +            w = w>>1;
 +            h = h>>1;
 +            for (orientation = !!level; orientation < 4; orientation++) {
 +                SubBand *b = &p->band[level][orientation];
 +
 +                b->ibuf   = p->idwt_buf;
 +                b->level  = level;
 +                b->stride = p->idwt_stride << (s->wavelet_depth - level);
 +                b->width  = w;
 +                b->height = h;
 +                b->orientation = orientation;
 +
 +                if (orientation & 1)
 +                    b->ibuf += w;
 +                if (orientation > 1)
 +                    b->ibuf += b->stride>>1;
 +
 +                if (level)
 +                    b->parent = &p->band[level-1][orientation];
 +            }
 +        }
 +
 +        if (i > 0) {
 +            p->xblen = s->plane[0].xblen >> s->chroma_x_shift;
 +            p->yblen = s->plane[0].yblen >> s->chroma_y_shift;
 +            p->xbsep = s->plane[0].xbsep >> s->chroma_x_shift;
 +            p->ybsep = s->plane[0].ybsep >> s->chroma_y_shift;
 +        }
 +
 +        p->xoffset = (p->xblen - p->xbsep)/2;
 +        p->yoffset = (p->yblen - p->ybsep)/2;
 +    }
 +}
 +
 +/**
 + * Unpack the motion compensation parameters
 + * Dirac Specification ->
 + * 11.2 Picture prediction data. picture_prediction()
 + */
 +static int dirac_unpack_prediction_parameters(DiracContext *s)
 +{
 +    static const uint8_t default_blen[] = { 4, 12, 16, 24 };
 +    static const uint8_t default_bsep[] = { 4,  8, 12, 16 };
 +
 +    GetBitContext *gb = &s->gb;
 +    unsigned idx, ref;
 +
 +    align_get_bits(gb);
 +    /* [DIRAC_STD] 11.2.2 Block parameters. block_parameters() */
 +    /* Luma and Chroma are equal. 11.2.3 */
 +    idx = svq3_get_ue_golomb(gb); /* [DIRAC_STD] index */
 +
 +    if (idx > 4) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Block prediction index too high\n");
 +        return -1;
 +    }
 +
 +    if (idx == 0) {
 +        s->plane[0].xblen = svq3_get_ue_golomb(gb);
 +        s->plane[0].yblen = svq3_get_ue_golomb(gb);
 +        s->plane[0].xbsep = svq3_get_ue_golomb(gb);
 +        s->plane[0].ybsep = svq3_get_ue_golomb(gb);
 +    } else {
 +        /*[DIRAC_STD] preset_block_params(index). Table 11.1 */
 +        s->plane[0].xblen = default_blen[idx-1];
 +        s->plane[0].yblen = default_blen[idx-1];
 +        s->plane[0].xbsep = default_bsep[idx-1];
 +        s->plane[0].ybsep = default_bsep[idx-1];
 +    }
 +    /*[DIRAC_STD] 11.2.4 motion_data_dimensions()
 +      Calculated in function dirac_unpack_block_motion_data */
 +
 +    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) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Block separation too small\n");
 +        return -1;
 +    }
 +    if (s->plane[0].xbsep > s->plane[0].xblen || s->plane[0].ybsep > s->plane[0].yblen) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Block separation greater than size\n");
 +        return -1;
 +    }
 +    if (FFMAX(s->plane[0].xblen, s->plane[0].yblen) > MAX_BLOCKSIZE) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Unsupported large block size\n");
 +        return -1;
 +    }
 +
 +    /*[DIRAC_STD] 11.2.5 Motion vector precision. motion_vector_precision()
 +      Read motion vector precision */
 +    s->mv_precision = svq3_get_ue_golomb(gb);
 +    if (s->mv_precision > 3) {
 +        av_log(s->avctx, AV_LOG_ERROR, "MV precision finer than eighth-pel\n");
 +        return -1;
 +    }
 +
 +    /*[DIRAC_STD] 11.2.6 Global motion. global_motion()
 +      Read the global motion compensation parameters */
 +    s->globalmc_flag = get_bits1(gb);
 +    if (s->globalmc_flag) {
 +        memset(s->globalmc, 0, sizeof(s->globalmc));
 +        /* [DIRAC_STD] pan_tilt(gparams) */
 +        for (ref = 0; ref < s->num_refs; ref++) {
 +            if (get_bits1(gb)) {
 +                s->globalmc[ref].pan_tilt[0] = dirac_get_se_golomb(gb);
 +                s->globalmc[ref].pan_tilt[1] = dirac_get_se_golomb(gb);
 +            }
 +            /* [DIRAC_STD] zoom_rotate_shear(gparams)
 +               zoom/rotation/shear parameters */
 +            if (get_bits1(gb)) {
 +                s->globalmc[ref].zrs_exp   = svq3_get_ue_golomb(gb);
 +                s->globalmc[ref].zrs[0][0] = dirac_get_se_golomb(gb);
 +                s->globalmc[ref].zrs[0][1] = dirac_get_se_golomb(gb);
 +                s->globalmc[ref].zrs[1][0] = dirac_get_se_golomb(gb);
 +                s->globalmc[ref].zrs[1][1] = dirac_get_se_golomb(gb);
 +            } else {
 +                s->globalmc[ref].zrs[0][0] = 1;
 +                s->globalmc[ref].zrs[1][1] = 1;
 +            }
 +            /* [DIRAC_STD] perspective(gparams) */
 +            if (get_bits1(gb)) {
 +                s->globalmc[ref].perspective_exp = svq3_get_ue_golomb(gb);
 +                s->globalmc[ref].perspective[0]  = dirac_get_se_golomb(gb);
 +                s->globalmc[ref].perspective[1]  = dirac_get_se_golomb(gb);
 +            }
 +        }
 +    }
 +
 +    /*[DIRAC_STD] 11.2.7 Picture prediction mode. prediction_mode()
 +      Picture prediction mode, not currently used. */
 +    if (svq3_get_ue_golomb(gb)) {
 +        av_log(s->avctx, AV_LOG_ERROR, "Unknown picture prediction mode\n");
 +        return -1;
 +    }
 +
 +    /* [DIRAC_STD] 11.2.8 Reference picture weight. reference_picture_weights()
 +       just data read, weight calculation will be done later on. */
 +    s->weight_log2denom = 1;
 +    s->weight[0]        = 1;
 +    s->weight[1]        = 1;
 +
 +    if (get_bits1(gb)) {
 +        s->weight_log2denom = svq3_get_ue_golomb(gb);
 +        s->weight[0] = dirac_get_se_golomb(gb);
 +        if (s->num_refs == 2)
 +            s->weight[1] = dirac_get_se_golomb(gb);
 +    }
 +    return 0;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 11.3 Wavelet transform data. wavelet_transform()
 + */
 +static int dirac_unpack_idwt_params(DiracContext *s)
 +{
 +    GetBitContext *gb = &s->gb;
 +    int i, level;
 +    unsigned tmp;
 +
 +#define CHECKEDREAD(dst, cond, errmsg) \
 +    tmp = svq3_get_ue_golomb(gb); \
 +    if (cond) { \
 +        av_log(s->avctx, AV_LOG_ERROR, errmsg); \
 +        return -1; \
 +    }\
 +    dst = tmp;
 +
 +    align_get_bits(gb);
 +
 +    s->zero_res = s->num_refs ? get_bits1(gb) : 0;
 +    if (s->zero_res)
 +        return 0;
 +
 +    /*[DIRAC_STD] 11.3.1 Transform parameters. transform_parameters() */
 +    CHECKEDREAD(s->wavelet_idx, tmp > 6, "wavelet_idx is too big\n")
 +
 +    CHECKEDREAD(s->wavelet_depth, tmp > MAX_DWT_LEVELS || tmp < 1, "invalid number of DWT decompositions\n")
 +
 +    if (!s->low_delay) {
 +        /* Codeblock parameters (core syntax only) */
 +        if (get_bits1(gb)) {
 +            for (i = 0; i <= s->wavelet_depth; i++) {
 +                CHECKEDREAD(s->codeblock[i].width , tmp < 1, "codeblock width invalid\n")
 +                CHECKEDREAD(s->codeblock[i].height, tmp < 1, "codeblock height invalid\n")
 +            }
 +
 +            CHECKEDREAD(s->codeblock_mode, tmp > 1, "unknown codeblock mode\n")
 +        } else
 +            for (i = 0; i <= s->wavelet_depth; i++)
 +                s->codeblock[i].width = s->codeblock[i].height = 1;
 +    } else {
 +        /* Slice parameters + quantization matrix*/
 +        /*[DIRAC_STD] 11.3.4 Slice coding Parameters (low delay syntax only). slice_parameters() */
 +        s->lowdelay.num_x     = svq3_get_ue_golomb(gb);
 +        s->lowdelay.num_y     = svq3_get_ue_golomb(gb);
 +        s->lowdelay.bytes.num = svq3_get_ue_golomb(gb);
 +        s->lowdelay.bytes.den = svq3_get_ue_golomb(gb);
 +
 +        if (s->lowdelay.bytes.den <= 0) {
 +            av_log(s->avctx,AV_LOG_ERROR,"Invalid lowdelay.bytes.den\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        /* [DIRAC_STD] 11.3.5 Quantisation matrices (low-delay syntax). quant_matrix() */
 +        if (get_bits1(gb)) {
 +            av_log(s->avctx,AV_LOG_DEBUG,"Low Delay: Has Custom Quantization Matrix!\n");
 +            /* custom quantization matrix */
 +            s->lowdelay.quant[0][0] = svq3_get_ue_golomb(gb);
 +            for (level = 0; level < s->wavelet_depth; level++) {
 +                s->lowdelay.quant[level][1] = svq3_get_ue_golomb(gb);
 +                s->lowdelay.quant[level][2] = svq3_get_ue_golomb(gb);
 +                s->lowdelay.quant[level][3] = svq3_get_ue_golomb(gb);
 +            }
 +        } else {
 +            if (s->wavelet_depth > 4) {
 +                av_log(s->avctx,AV_LOG_ERROR,"Mandatory custom low delay matrix missing for depth %d\n", s->wavelet_depth);
 +                return AVERROR_INVALIDDATA;
 +            }
 +            /* default quantization matrix */
 +            for (level = 0; level < s->wavelet_depth; level++)
 +                for (i = 0; i < 4; i++) {
 +                    s->lowdelay.quant[level][i] = default_qmat[s->wavelet_idx][level][i];
 +                    /* haar with no shift differs for different depths */
 +                    if (s->wavelet_idx == 3)
 +                        s->lowdelay.quant[level][i] += 4*(s->wavelet_depth-1 - level);
 +                }
 +        }
 +    }
 +    return 0;
 +}
 +
 +static inline int pred_sbsplit(uint8_t *sbsplit, int stride, int x, int y)
 +{
 +    static const uint8_t avgsplit[7] = { 0, 0, 1, 1, 1, 2, 2 };
 +
 +    if (!(x|y))
 +        return 0;
 +    else if (!y)
 +        return sbsplit[-1];
 +    else if (!x)
 +        return sbsplit[-stride];
 +
 +    return avgsplit[sbsplit[-1] + sbsplit[-stride] + sbsplit[-stride-1]];
 +}
 +
 +static inline int pred_block_mode(DiracBlock *block, int stride, int x, int y, int refmask)
 +{
 +    int pred;
 +
 +    if (!(x|y))
 +        return 0;
 +    else if (!y)
 +        return block[-1].ref & refmask;
 +    else if (!x)
 +        return block[-stride].ref & refmask;
 +
 +    /* return the majority */
 +    pred = (block[-1].ref & refmask) + (block[-stride].ref & refmask) + (block[-stride-1].ref & refmask);
 +    return (pred >> 1) & refmask;
 +}
 +
 +static inline void pred_block_dc(DiracBlock *block, int stride, int x, int y)
 +{
 +    int i, n = 0;
 +
 +    memset(block->u.dc, 0, sizeof(block->u.dc));
 +
 +    if (x && !(block[-1].ref & 3)) {
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] += block[-1].u.dc[i];
 +        n++;
 +    }
 +
 +    if (y && !(block[-stride].ref & 3)) {
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] += block[-stride].u.dc[i];
 +        n++;
 +    }
 +
 +    if (x && y && !(block[-1-stride].ref & 3)) {
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] += block[-1-stride].u.dc[i];
 +        n++;
 +    }
 +
 +    if (n == 2) {
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] = (block->u.dc[i]+1)>>1;
 +    } else if (n == 3) {
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] = divide3(block->u.dc[i]);
 +    }
 +}
 +
 +static inline void pred_mv(DiracBlock *block, int stride, int x, int y, int ref)
 +{
 +    int16_t *pred[3];
 +    int refmask = ref+1;
 +    int mask = refmask | DIRAC_REF_MASK_GLOBAL; /*  exclude gmc blocks */
 +    int n = 0;
 +
 +    if (x && (block[-1].ref & mask) == refmask)
 +        pred[n++] = block[-1].u.mv[ref];
 +
 +    if (y && (block[-stride].ref & mask) == refmask)
 +        pred[n++] = block[-stride].u.mv[ref];
 +
 +    if (x && y && (block[-stride-1].ref & mask) == refmask)
 +        pred[n++] = block[-stride-1].u.mv[ref];
 +
 +    switch (n) {
 +    case 0:
 +        block->u.mv[ref][0] = 0;
 +        block->u.mv[ref][1] = 0;
 +        break;
 +    case 1:
 +        block->u.mv[ref][0] = pred[0][0];
 +        block->u.mv[ref][1] = pred[0][1];
 +        break;
 +    case 2:
 +        block->u.mv[ref][0] = (pred[0][0] + pred[1][0] + 1) >> 1;
 +        block->u.mv[ref][1] = (pred[0][1] + pred[1][1] + 1) >> 1;
 +        break;
 +    case 3:
 +        block->u.mv[ref][0] = mid_pred(pred[0][0], pred[1][0], pred[2][0]);
 +        block->u.mv[ref][1] = mid_pred(pred[0][1], pred[1][1], pred[2][1]);
 +        break;
 +    }
 +}
 +
 +static void global_mv(DiracContext *s, DiracBlock *block, int x, int y, int ref)
 +{
 +    int ez      = s->globalmc[ref].zrs_exp;
 +    int ep      = s->globalmc[ref].perspective_exp;
 +    int (*A)[2] = s->globalmc[ref].zrs;
 +    int *b      = s->globalmc[ref].pan_tilt;
 +    int *c      = s->globalmc[ref].perspective;
 +
 +    int m       = (1<<ep) - (c[0]*x + c[1]*y);
 +    int mx      = m * ((A[0][0] * x + A[0][1]*y) + (1<<ez) * b[0]);
 +    int my      = m * ((A[1][0] * x + A[1][1]*y) + (1<<ez) * b[1]);
 +
 +    block->u.mv[ref][0] = (mx + (1<<(ez+ep))) >> (ez+ep);
 +    block->u.mv[ref][1] = (my + (1<<(ez+ep))) >> (ez+ep);
 +}
 +
 +static void decode_block_params(DiracContext *s, DiracArith arith[8], DiracBlock *block,
 +                                int stride, int x, int y)
 +{
 +    int i;
 +
 +    block->ref  = pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF1);
 +    block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF1);
 +
 +    if (s->num_refs == 2) {
 +        block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_REF2);
 +        block->ref ^= dirac_get_arith_bit(arith, CTX_PMODE_REF2) << 1;
 +    }
 +
 +    if (!block->ref) {
 +        pred_block_dc(block, stride, x, y);
 +        for (i = 0; i < 3; i++)
 +            block->u.dc[i] += dirac_get_arith_int(arith+1+i, CTX_DC_F1, CTX_DC_DATA);
 +        return;
 +    }
 +
 +    if (s->globalmc_flag) {
 +        block->ref |= pred_block_mode(block, stride, x, y, DIRAC_REF_MASK_GLOBAL);
 +        block->ref ^= dirac_get_arith_bit(arith, CTX_GLOBAL_BLOCK) << 2;
 +    }
 +
 +    for (i = 0; i < s->num_refs; i++)
 +        if (block->ref & (i+1)) {
 +            if (block->ref & DIRAC_REF_MASK_GLOBAL) {
 +                global_mv(s, block, x, y, i);
 +            } else {
 +                pred_mv(block, stride, x, y, i);
 +                block->u.mv[i][0] += dirac_get_arith_int(arith + 4 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
 +                block->u.mv[i][1] += dirac_get_arith_int(arith + 5 + 2 * i, CTX_MV_F1, CTX_MV_DATA);
 +            }
 +        }
 +}
 +
 +/**
 + * Copies the current block to the other blocks covered by the current superblock split mode
 + */
 +static void propagate_block_data(DiracBlock *block, int stride, int size)
 +{
 +    int x, y;
 +    DiracBlock *dst = block;
 +
 +    for (x = 1; x < size; x++)
 +        dst[x] = *block;
 +
 +    for (y = 1; y < size; y++) {
 +        dst += stride;
 +        for (x = 0; x < size; x++)
 +            dst[x] = *block;
 +    }
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 12. Block motion data syntax
 + */
 +static int dirac_unpack_block_motion_data(DiracContext *s)
 +{
 +    GetBitContext *gb = &s->gb;
 +    uint8_t *sbsplit = s->sbsplit;
 +    int i, x, y, q, p;
 +    DiracArith arith[8];
 +
 +    align_get_bits(gb);
 +
 +    /* [DIRAC_STD] 11.2.4 and 12.2.1 Number of blocks and superblocks */
 +    s->sbwidth  = DIVRNDUP(s->source.width,  4*s->plane[0].xbsep);
 +    s->sbheight = DIVRNDUP(s->source.height, 4*s->plane[0].ybsep);
 +    s->blwidth  = 4 * s->sbwidth;
 +    s->blheight = 4 * s->sbheight;
 +
 +    /* [DIRAC_STD] 12.3.1 Superblock splitting modes. superblock_split_modes()
 +       decode superblock split modes */
 +    ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));     /* svq3_get_ue_golomb(gb) is the length */
 +    for (y = 0; y < s->sbheight; y++) {
 +        for (x = 0; x < s->sbwidth; x++) {
 +            unsigned int split  = dirac_get_arith_uint(arith, CTX_SB_F1, CTX_SB_DATA);
 +            if (split > 2)
 +                return -1;
 +            sbsplit[x] = (split + pred_sbsplit(sbsplit+x, s->sbwidth, x, y)) % 3;
 +        }
 +        sbsplit += s->sbwidth;
 +    }
 +
 +    /* setup arith decoding */
 +    ff_dirac_init_arith_decoder(arith, gb, svq3_get_ue_golomb(gb));
 +    for (i = 0; i < s->num_refs; i++) {
 +        ff_dirac_init_arith_decoder(arith + 4 + 2 * i, gb, svq3_get_ue_golomb(gb));
 +        ff_dirac_init_arith_decoder(arith + 5 + 2 * i, gb, svq3_get_ue_golomb(gb));
 +    }
 +    for (i = 0; i < 3; i++)
 +        ff_dirac_init_arith_decoder(arith+1+i, gb, svq3_get_ue_golomb(gb));
 +
 +    for (y = 0; y < s->sbheight; y++)
 +        for (x = 0; x < s->sbwidth; x++) {
 +            int blkcnt = 1 << s->sbsplit[y * s->sbwidth + x];
 +            int step   = 4 >> s->sbsplit[y * s->sbwidth + x];
 +
 +            for (q = 0; q < blkcnt; q++)
 +                for (p = 0; p < blkcnt; p++) {
 +                    int bx = 4 * x + p*step;
 +                    int by = 4 * y + q*step;
 +                    DiracBlock *block = &s->blmotion[by*s->blwidth + bx];
 +                    decode_block_params(s, arith, block, s->blwidth, bx, by);
 +                    propagate_block_data(block, s->blwidth, step);
 +                }
 +        }
 +
 +    return 0;
 +}
 +
 +static int weight(int i, int blen, int offset)
 +{
 +#define ROLLOFF(i) offset == 1 ? ((i) ? 5 : 3) :        \
 +    (1 + (6*(i) + offset - 1) / (2*offset - 1))
 +
 +    if (i < 2*offset)
 +        return ROLLOFF(i);
 +    else if (i > blen-1 - 2*offset)
 +        return ROLLOFF(blen-1 - i);
 +    return 8;
 +}
 +
 +static void init_obmc_weight_row(Plane *p, uint8_t *obmc_weight, int stride,
 +                                 int left, int right, int wy)
 +{
 +    int x;
 +    for (x = 0; left && x < p->xblen >> 1; x++)
 +        obmc_weight[x] = wy*8;
 +    for (; x < p->xblen >> right; x++)
 +        obmc_weight[x] = wy*weight(x, p->xblen, p->xoffset);
 +    for (; x < p->xblen; x++)
 +        obmc_weight[x] = wy*8;
 +    for (; x < stride; x++)
 +        obmc_weight[x] = 0;
 +}
 +
 +static void init_obmc_weight(Plane *p, uint8_t *obmc_weight, int stride,
 +                             int left, int right, int top, int bottom)
 +{
 +    int y;
 +    for (y = 0; top && y < p->yblen >> 1; y++) {
 +        init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
 +        obmc_weight += stride;
 +    }
 +    for (; y < p->yblen >> bottom; y++) {
 +        int wy = weight(y, p->yblen, p->yoffset);
 +        init_obmc_weight_row(p, obmc_weight, stride, left, right, wy);
 +        obmc_weight += stride;
 +    }
 +    for (; y < p->yblen; y++) {
 +        init_obmc_weight_row(p, obmc_weight, stride, left, right, 8);
 +        obmc_weight += stride;
 +    }
 +}
 +
 +static void init_obmc_weights(DiracContext *s, Plane *p, int by)
 +{
 +    int top = !by;
 +    int bottom = by == s->blheight-1;
 +
 +    /* don't bother re-initing for rows 2 to blheight-2, the weights don't change */
 +    if (top || bottom || by == 1) {
 +        init_obmc_weight(p, s->obmc_weight[0], MAX_BLOCKSIZE, 1, 0, top, bottom);
 +        init_obmc_weight(p, s->obmc_weight[1], MAX_BLOCKSIZE, 0, 0, top, bottom);
 +        init_obmc_weight(p, s->obmc_weight[2], MAX_BLOCKSIZE, 0, 1, top, bottom);
 +    }
 +}
 +
 +static const uint8_t epel_weights[4][4][4] = {
 +    {{ 16,  0,  0,  0 },
 +     { 12,  4,  0,  0 },
 +     {  8,  8,  0,  0 },
 +     {  4, 12,  0,  0 }},
 +    {{ 12,  0,  4,  0 },
 +     {  9,  3,  3,  1 },
 +     {  6,  6,  2,  2 },
 +     {  3,  9,  1,  3 }},
 +    {{  8,  0,  8,  0 },
 +     {  6,  2,  6,  2 },
 +     {  4,  4,  4,  4 },
 +     {  2,  6,  2,  6 }},
 +    {{  4,  0, 12,  0 },
 +     {  3,  1,  9,  3 },
 +     {  2,  2,  6,  6 },
 +     {  1,  3,  3,  9 }}
 +};
 +
 +/**
 + * For block x,y, determine which of the hpel planes to do bilinear
 + * interpolation from and set src[] to the location in each hpel plane
 + * to MC from.
 + *
 + * @return the index of the put_dirac_pixels_tab function to use
 + *  0 for 1 plane (fpel,hpel), 1 for 2 planes (qpel), 2 for 4 planes (qpel), and 3 for epel
 + */
 +static int mc_subpel(DiracContext *s, DiracBlock *block, const uint8_t *src[5],
 +                     int x, int y, int ref, int plane)
 +{
 +    Plane *p = &s->plane[plane];
 +    uint8_t **ref_hpel = s->ref_pics[ref]->hpel[plane];
 +    int motion_x = block->u.mv[ref][0];
 +    int motion_y = block->u.mv[ref][1];
 +    int mx, my, i, epel, nplanes = 0;
 +
 +    if (plane) {
 +        motion_x >>= s->chroma_x_shift;
 +        motion_y >>= s->chroma_y_shift;
 +    }
 +
 +    mx         = motion_x & ~(-1 << s->mv_precision);
 +    my         = motion_y & ~(-1 << s->mv_precision);
 +    motion_x >>= s->mv_precision;
 +    motion_y >>= s->mv_precision;
 +    /* normalize subpel coordinates to epel */
 +    /* TODO: template this function? */
 +    mx      <<= 3 - s->mv_precision;
 +    my      <<= 3 - s->mv_precision;
 +
 +    x += motion_x;
 +    y += motion_y;
 +    epel = (mx|my)&1;
 +
 +    /* hpel position */
 +    if (!((mx|my)&3)) {
 +        nplanes = 1;
 +        src[0] = ref_hpel[(my>>1)+(mx>>2)] + y*p->stride + x;
 +    } else {
 +        /* qpel or epel */
 +        nplanes = 4;
 +        for (i = 0; i < 4; i++)
 +            src[i] = ref_hpel[i] + y*p->stride + x;
 +
 +        /* if we're interpolating in the right/bottom halves, adjust the planes as needed
 +           we increment x/y because the edge changes for half of the pixels */
 +        if (mx > 4) {
 +            src[0] += 1;
 +            src[2] += 1;
 +            x++;
 +        }
 +        if (my > 4) {
 +            src[0] += p->stride;
 +            src[1] += p->stride;
 +            y++;
 +        }
 +
 +        /* hpel planes are:
 +           [0]: F  [1]: H
 +           [2]: V  [3]: C */
 +        if (!epel) {
 +            /* check if we really only need 2 planes since either mx or my is
 +               a hpel position. (epel weights of 0 handle this there) */
 +            if (!(mx&3)) {
 +                /* mx == 0: average [0] and [2]
 +                   mx == 4: average [1] and [3] */
 +                src[!mx] = src[2 + !!mx];
 +                nplanes = 2;
 +            } else if (!(my&3)) {
 +                src[0] = src[(my>>1)  ];
 +                src[1] = src[(my>>1)+1];
 +                nplanes = 2;
 +            }
 +        } else {
 +            /* adjust the ordering if needed so the weights work */
 +            if (mx > 4) {
 +                FFSWAP(const uint8_t *, src[0], src[1]);
 +                FFSWAP(const uint8_t *, src[2], src[3]);
 +            }
 +            if (my > 4) {
 +                FFSWAP(const uint8_t *, src[0], src[2]);
 +                FFSWAP(const uint8_t *, src[1], src[3]);
 +            }
 +            src[4] = epel_weights[my&3][mx&3];
 +        }
 +    }
 +
 +    /* fixme: v/h _edge_pos */
 +    if ((unsigned)x > FFMAX(p->width +EDGE_WIDTH/2 - p->xblen, 0) ||
 +        (unsigned)y > FFMAX(p->height+EDGE_WIDTH/2 - p->yblen, 0)) {
 +        for (i = 0; i < nplanes; i++) {
 +            ff_emulated_edge_mc(s->edge_emu_buffer[i], src[i], p->stride,
 +                                p->xblen, p->yblen, x, y,
 +                                p->width+EDGE_WIDTH/2, p->height+EDGE_WIDTH/2);
 +            src[i] = s->edge_emu_buffer[i];
 +        }
 +    }
 +    return (nplanes>>1) + epel;
 +}
 +
 +static void add_dc(uint16_t *dst, int dc, int stride,
 +                   uint8_t *obmc_weight, int xblen, int yblen)
 +{
 +    int x, y;
 +    dc += 128;
 +
 +    for (y = 0; y < yblen; y++) {
 +        for (x = 0; x < xblen; x += 2) {
 +            dst[x  ] += dc * obmc_weight[x  ];
 +            dst[x+1] += dc * obmc_weight[x+1];
 +        }
 +        dst          += stride;
 +        obmc_weight  += MAX_BLOCKSIZE;
 +    }
 +}
 +
 +static void block_mc(DiracContext *s, DiracBlock *block,
 +                     uint16_t *mctmp, uint8_t *obmc_weight,
 +                     int plane, int dstx, int dsty)
 +{
 +    Plane *p = &s->plane[plane];
 +    const uint8_t *src[5];
 +    int idx;
 +
 +    switch (block->ref&3) {
 +    case 0: /* DC */
 +        add_dc(mctmp, block->u.dc[plane], p->stride, obmc_weight, p->xblen, p->yblen);
 +        return;
 +    case 1:
 +    case 2:
 +        idx = mc_subpel(s, block, src, dstx, dsty, (block->ref&3)-1, plane);
 +        s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
 +        if (s->weight_func)
 +            s->weight_func(s->mcscratch, p->stride, s->weight_log2denom,
 +                           s->weight[0] + s->weight[1], p->yblen);
 +        break;
 +    case 3:
 +        idx = mc_subpel(s, block, src, dstx, dsty, 0, plane);
 +        s->put_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
 +        idx = mc_subpel(s, block, src, dstx, dsty, 1, plane);
 +        if (s->biweight_func) {
 +            /* fixme: +32 is a quick hack */
 +            s->put_pixels_tab[idx](s->mcscratch + 32, src, p->stride, p->yblen);
 +            s->biweight_func(s->mcscratch, s->mcscratch+32, p->stride, s->weight_log2denom,
 +                             s->weight[0], s->weight[1], p->yblen);
 +        } else
 +            s->avg_pixels_tab[idx](s->mcscratch, src, p->stride, p->yblen);
 +        break;
 +    }
 +    s->add_obmc(mctmp, s->mcscratch, p->stride, obmc_weight, p->yblen);
 +}
 +
 +static void mc_row(DiracContext *s, DiracBlock *block, uint16_t *mctmp, int plane, int dsty)
 +{
 +    Plane *p = &s->plane[plane];
 +    int x, dstx = p->xbsep - p->xoffset;
 +
 +    block_mc(s, block, mctmp, s->obmc_weight[0], plane, -p->xoffset, dsty);
 +    mctmp += p->xbsep;
 +
 +    for (x = 1; x < s->blwidth-1; x++) {
 +        block_mc(s, block+x, mctmp, s->obmc_weight[1], plane, dstx, dsty);
 +        dstx  += p->xbsep;
 +        mctmp += p->xbsep;
 +    }
 +    block_mc(s, block+x, mctmp, s->obmc_weight[2], plane, dstx, dsty);
 +}
 +
 +static void select_dsp_funcs(DiracContext *s, int width, int height, int xblen, int yblen)
 +{
 +    int idx = 0;
 +    if (xblen > 8)
 +        idx = 1;
 +    if (xblen > 16)
 +        idx = 2;
 +
 +    memcpy(s->put_pixels_tab, s->diracdsp.put_dirac_pixels_tab[idx], sizeof(s->put_pixels_tab));
 +    memcpy(s->avg_pixels_tab, s->diracdsp.avg_dirac_pixels_tab[idx], sizeof(s->avg_pixels_tab));
 +    s->add_obmc = s->diracdsp.add_dirac_obmc[idx];
 +    if (s->weight_log2denom > 1 || s->weight[0] != 1 || s->weight[1] != 1) {
 +        s->weight_func   = s->diracdsp.weight_dirac_pixels_tab[idx];
 +        s->biweight_func = s->diracdsp.biweight_dirac_pixels_tab[idx];
 +    } else {
 +        s->weight_func   = NULL;
 +        s->biweight_func = NULL;
 +    }
 +}
 +
 +static void interpolate_refplane(DiracContext *s, DiracFrame *ref, int plane, int width, int height)
 +{
 +    /* chroma allocates an edge of 8 when subsampled
 +       which for 4:2:2 means an h edge of 16 and v edge of 8
 +       just use 8 for everything for the moment */
 +    int i, edge = EDGE_WIDTH/2;
 +
 +    ref->hpel[plane][0] = ref->avframe.data[plane];
 +    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 */
 +
 +    /* no need for hpel if we only have fpel vectors */
 +    if (!s->mv_precision)
 +        return;
 +
 +    for (i = 1; i < 4; i++) {
 +        if (!ref->hpel_base[plane][i])
 +            ref->hpel_base[plane][i] = av_malloc((height+2*edge) * ref->avframe.linesize[plane] + 32);
 +        /* we need to be 16-byte aligned even for chroma */
 +        ref->hpel[plane][i] = ref->hpel_base[plane][i] + edge*ref->avframe.linesize[plane] + 16;
 +    }
 +
 +    if (!ref->interpolated[plane]) {
 +        s->diracdsp.dirac_hpel_filter(ref->hpel[plane][1], ref->hpel[plane][2],
 +                                      ref->hpel[plane][3], ref->hpel[plane][0],
 +                                      ref->avframe.linesize[plane], width, height);
 +        s->dsp.draw_edges(ref->hpel[plane][1], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(ref->hpel[plane][2], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
 +        s->dsp.draw_edges(ref->hpel[plane][3], ref->avframe.linesize[plane], width, height, edge, edge, EDGE_TOP | EDGE_BOTTOM);
 +    }
 +    ref->interpolated[plane] = 1;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 13.0 Transform data syntax. transform_data()
 + */
 +static int dirac_decode_frame_internal(DiracContext *s)
 +{
 +    DWTContext d;
 +    int y, i, comp, dsty;
 +
 +    if (s->low_delay) {
 +        /* [DIRAC_STD] 13.5.1 low_delay_transform_data() */
 +        for (comp = 0; comp < 3; comp++) {
 +            Plane *p = &s->plane[comp];
 +            memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
 +        }
 +        if (!s->zero_res)
 +            decode_lowdelay(s);
 +    }
 +
 +    for (comp = 0; comp < 3; comp++) {
 +        Plane *p       = &s->plane[comp];
 +        uint8_t *frame = s->current_picture->avframe.data[comp];
 +
 +        /* FIXME: small resolutions */
 +        for (i = 0; i < 4; i++)
 +            s->edge_emu_buffer[i] = s->edge_emu_buffer_base + i*FFALIGN(p->width, 16);
 +
 +        if (!s->zero_res && !s->low_delay)
 +        {
 +            memset(p->idwt_buf, 0, p->idwt_stride * p->idwt_height * sizeof(IDWTELEM));
 +            decode_component(s, comp); /* [DIRAC_STD] 13.4.1 core_transform_data() */
 +        }
 +        if (ff_spatial_idwt_init2(&d, p->idwt_buf, p->idwt_width, p->idwt_height, p->idwt_stride,
 +                                  s->wavelet_idx+2, s->wavelet_depth, p->idwt_tmp))
 +            return -1;
 +
 +        if (!s->num_refs) { /* intra */
 +            for (y = 0; y < p->height; y += 16) {
 +                ff_spatial_idwt_slice2(&d, y+16); /* decode */
 +                s->diracdsp.put_signed_rect_clamped(frame + y*p->stride, p->stride,
 +                                                    p->idwt_buf + y*p->idwt_stride, p->idwt_stride, p->width, 16);
 +            }
 +        } else { /* inter */
 +            int rowheight = p->ybsep*p->stride;
 +
 +            select_dsp_funcs(s, p->width, p->height, p->xblen, p->yblen);
 +
 +            for (i = 0; i < s->num_refs; i++)
 +                interpolate_refplane(s, s->ref_pics[i], comp, p->width, p->height);
 +
 +            memset(s->mctmp, 0, 4*p->yoffset*p->stride);
 +
 +            dsty = -p->yoffset;
 +            for (y = 0; y < s->blheight; y++) {
 +                int h     = 0,
 +                    start = FFMAX(dsty, 0);
 +                uint16_t *mctmp    = s->mctmp + y*rowheight;
 +                DiracBlock *blocks = s->blmotion + y*s->blwidth;
 +
 +                init_obmc_weights(s, p, y);
 +
 +                if (y == s->blheight-1 || start+p->ybsep > p->height)
 +                    h = p->height - start;
 +                else
 +                    h = p->ybsep - (start - dsty);
 +                if (h < 0)
 +                    break;
 +
 +                memset(mctmp+2*p->yoffset*p->stride, 0, 2*rowheight);
 +                mc_row(s, blocks, mctmp, comp, dsty);
 +
 +                mctmp += (start - dsty)*p->stride + p->xoffset;
 +                ff_spatial_idwt_slice2(&d, start + h); /* decode */
 +                s->diracdsp.add_rect_clamped(frame + start*p->stride, mctmp, p->stride,
 +                                             p->idwt_buf + start*p->idwt_stride, p->idwt_stride, p->width, h);
 +
 +                dsty += p->ybsep;
 +            }
 +        }
 +    }
 +
 +
 +    return 0;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 11.1.1 Picture Header. picture_header()
 + */
 +static int dirac_decode_picture_header(DiracContext *s)
 +{
 +    int retire, picnum;
 +    int i, j, refnum, refdist;
 +    GetBitContext *gb = &s->gb;
 +
 +    /* [DIRAC_STD] 11.1.1 Picture Header. picture_header() PICTURE_NUM */
 +    picnum = s->current_picture->avframe.display_picture_number = get_bits_long(gb, 32);
 +
 +
 +    av_log(s->avctx,AV_LOG_DEBUG,"PICTURE_NUM: %d\n",picnum);
 +
 +    /* if this is the first keyframe after a sequence header, start our
 +       reordering from here */
 +    if (s->frame_number < 0)
 +        s->frame_number = picnum;
 +
 +    s->ref_pics[0] = s->ref_pics[1] = NULL;
 +    for (i = 0; i < s->num_refs; i++) {
 +        refnum = picnum + dirac_get_se_golomb(gb);
 +        refdist = INT_MAX;
 +
 +        /* find the closest reference to the one we want */
 +        /* Jordi: this is needed if the referenced picture hasn't yet arrived */
 +        for (j = 0; j < MAX_REFERENCE_FRAMES && refdist; j++)
 +            if (s->ref_frames[j]
 +                && FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum) < refdist) {
 +                s->ref_pics[i] = s->ref_frames[j];
 +                refdist = FFABS(s->ref_frames[j]->avframe.display_picture_number - refnum);
 +            }
 +
 +        if (!s->ref_pics[i] || refdist)
 +            av_log(s->avctx, AV_LOG_DEBUG, "Reference not found\n");
 +
 +        /* if there were no references at all, allocate one */
 +        if (!s->ref_pics[i])
 +            for (j = 0; j < MAX_FRAMES; j++)
 +                if (!s->all_frames[j].avframe.data[0]) {
 +                    s->ref_pics[i] = &s->all_frames[j];
-         if (avctx->get_buffer(avctx, &pic->avframe) < 0) {
++                    ff_get_buffer(s->avctx, &s->ref_pics[i]->avframe);
 +                    break;
 +                }
 +    }
 +
 +    /* retire the reference frames that are not used anymore */
 +    if (s->current_picture->avframe.reference) {
 +        retire = picnum + dirac_get_se_golomb(gb);
 +        if (retire != picnum) {
 +            DiracFrame *retire_pic = remove_frame(s->ref_frames, retire);
 +
 +            if (retire_pic)
 +                retire_pic->avframe.reference &= DELAYED_PIC_REF;
 +            else
 +                av_log(s->avctx, AV_LOG_DEBUG, "Frame to retire not found\n");
 +        }
 +
 +        /* if reference array is full, remove the oldest as per the spec */
 +        while (add_frame(s->ref_frames, MAX_REFERENCE_FRAMES, s->current_picture)) {
 +            av_log(s->avctx, AV_LOG_ERROR, "Reference frame overflow\n");
 +            remove_frame(s->ref_frames, s->ref_frames[0]->avframe.display_picture_number)->avframe.reference &= DELAYED_PIC_REF;
 +        }
 +    }
 +
 +    if (s->num_refs) {
 +        if (dirac_unpack_prediction_parameters(s))  /* [DIRAC_STD] 11.2 Picture Prediction Data. picture_prediction() */
 +            return -1;
 +        if (dirac_unpack_block_motion_data(s))      /* [DIRAC_STD] 12. Block motion data syntax                       */
 +            return -1;
 +    }
 +    if (dirac_unpack_idwt_params(s))                /* [DIRAC_STD] 11.3 Wavelet transform data                        */
 +        return -1;
 +
 +    init_planes(s);
 +    return 0;
 +}
 +
 +static int get_delayed_pic(DiracContext *s, AVFrame *picture, int *data_size)
 +{
 +    DiracFrame *out = s->delay_frames[0];
 +    int i, out_idx  = 0;
 +
 +    /* find frame with lowest picture number */
 +    for (i = 1; s->delay_frames[i]; i++)
 +        if (s->delay_frames[i]->avframe.display_picture_number < out->avframe.display_picture_number) {
 +            out     = s->delay_frames[i];
 +            out_idx = i;
 +        }
 +
 +    for (i = out_idx; s->delay_frames[i]; i++)
 +        s->delay_frames[i] = s->delay_frames[i+1];
 +
 +    if (out) {
 +        out->avframe.reference ^= DELAYED_PIC_REF;
 +        *data_size = sizeof(AVFrame);
 +        *(AVFrame *)picture = out->avframe;
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * Dirac Specification ->
 + * 9.6 Parse Info Header Syntax. parse_info()
 + * 4 byte start code + byte parse code + 4 byte size + 4 byte previous size
 + */
 +#define DATA_UNIT_HEADER_SIZE 13
 +
 +/* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3
 +   inside the function parse_sequence() */
 +static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
 +{
 +    DiracContext *s   = avctx->priv_data;
 +    DiracFrame *pic   = NULL;
 +    int i, parse_code = buf[4];
 +    unsigned tmp;
 +
 +    if (size < DATA_UNIT_HEADER_SIZE)
 +        return -1;
 +
 +    init_get_bits(&s->gb, &buf[13], 8*(size - DATA_UNIT_HEADER_SIZE));
 +
 +    if (parse_code == pc_seq_header) {
 +        if (s->seen_sequence_header)
 +            return 0;
 +
 +        /* [DIRAC_STD] 10. Sequence header */
 +        if (avpriv_dirac_parse_sequence_header(avctx, &s->gb, &s->source))
 +            return -1;
 +
 +        avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
 +
 +        if (alloc_sequence_buffers(s))
 +            return -1;
 +
 +        s->seen_sequence_header = 1;
 +    } else if (parse_code == pc_eos) { /* [DIRAC_STD] End of Sequence */
 +        free_sequence_buffers(s);
 +        s->seen_sequence_header = 0;
 +    } else if (parse_code == pc_aux_data) {
 +        if (buf[13] == 1) {     /* encoder implementation/version */
 +            int ver[3];
 +            /* versions older than 1.0.8 don't store quant delta for
 +               subbands with only one codeblock */
 +            if (sscanf(buf+14, "Schroedinger %d.%d.%d", ver, ver+1, ver+2) == 3)
 +                if (ver[0] == 1 && ver[1] == 0 && ver[2] <= 7)
 +                    s->old_delta_quant = 1;
 +        }
 +    } else if (parse_code & 0x8) {  /* picture data unit */
 +        if (!s->seen_sequence_header) {
 +            av_log(avctx, AV_LOG_DEBUG, "Dropping frame without sequence header\n");
 +            return -1;
 +        }
 +
 +        /* find an unused frame */
 +        for (i = 0; i < MAX_FRAMES; i++)
 +            if (s->all_frames[i].avframe.data[0] == NULL)
 +                pic = &s->all_frames[i];
 +        if (!pic) {
 +            av_log(avctx, AV_LOG_ERROR, "framelist full\n");
 +            return -1;
 +        }
 +
 +        avcodec_get_frame_defaults(&pic->avframe);
 +
 +        /* [DIRAC_STD] Defined in 9.6.1 ... */
 +        tmp            =  parse_code & 0x03;                   /* [DIRAC_STD] num_refs()      */
 +        if (tmp > 2) {
 +            av_log(avctx, AV_LOG_ERROR, "num_refs of 3\n");
 +            return -1;
 +        }
 +        s->num_refs    = tmp;
 +        s->is_arith    = (parse_code & 0x48) == 0x08;          /* [DIRAC_STD] using_ac()      */
 +        s->low_delay   = (parse_code & 0x88) == 0x88;          /* [DIRAC_STD] is_low_delay()  */
 +        pic->avframe.reference = (parse_code & 0x0C) == 0x0C;  /* [DIRAC_STD]  is_reference() */
 +        pic->avframe.key_frame = s->num_refs == 0;             /* [DIRAC_STD] is_intra()      */
 +        pic->avframe.pict_type = s->num_refs + 1;              /* Definition of AVPictureType in avutil.h */
 +
++        if (ff_get_buffer(avctx, &pic->avframe) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +            return -1;
 +        }
 +        s->current_picture = pic;
 +        s->plane[0].stride = pic->avframe.linesize[0];
 +        s->plane[1].stride = pic->avframe.linesize[1];
 +        s->plane[2].stride = pic->avframe.linesize[2];
 +
 +        /* [DIRAC_STD] 11.1 Picture parse. picture_parse() */
 +        if (dirac_decode_picture_header(s))
 +            return -1;
 +
 +        /* [DIRAC_STD] 13.0 Transform data syntax. transform_data() */
 +        if (dirac_decode_frame_internal(s))
 +            return -1;
 +    }
 +    return 0;
 +}
 +
 +static int dirac_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
 +{
 +    DiracContext *s     = avctx->priv_data;
 +    DiracFrame *picture = data;
 +    uint8_t *buf        = pkt->data;
 +    int buf_size        = pkt->size;
 +    int i, data_unit_size, buf_idx = 0;
 +
 +    /* release unused frames */
 +    for (i = 0; i < MAX_FRAMES; i++)
 +        if (s->all_frames[i].avframe.data[0] && !s->all_frames[i].avframe.reference) {
 +            avctx->release_buffer(avctx, &s->all_frames[i].avframe);
 +            memset(s->all_frames[i].interpolated, 0, sizeof(s->all_frames[i].interpolated));
 +        }
 +
 +    s->current_picture = NULL;
 +    *data_size = 0;
 +
 +    /* end of stream, so flush delayed pics */
 +    if (buf_size == 0)
 +        return get_delayed_pic(s, (AVFrame *)data, data_size);
 +
 +    for (;;) {
 +        /*[DIRAC_STD] Here starts the code from parse_info() defined in 9.6
 +          [DIRAC_STD] PARSE_INFO_PREFIX = "BBCD" as defined in ISO/IEC 646
 +          BBCD start code search */
 +        for (; buf_idx + DATA_UNIT_HEADER_SIZE < buf_size; buf_idx++) {
 +            if (buf[buf_idx  ] == 'B' && buf[buf_idx+1] == 'B' &&
 +                buf[buf_idx+2] == 'C' && buf[buf_idx+3] == 'D')
 +                break;
 +        }
 +        /* BBCD found or end of data */
 +        if (buf_idx + DATA_UNIT_HEADER_SIZE >= buf_size)
 +            break;
 +
 +        data_unit_size = AV_RB32(buf+buf_idx+5);
 +        if (buf_idx + data_unit_size > buf_size || !data_unit_size) {
 +            if(buf_idx + data_unit_size > buf_size)
 +            av_log(s->avctx, AV_LOG_ERROR,
 +                   "Data unit with size %d is larger than input buffer, discarding\n",
 +                   data_unit_size);
 +            buf_idx += 4;
 +            continue;
 +        }
 +        /* [DIRAC_STD] dirac_decode_data_unit makes reference to the while defined in 9.3 inside the function parse_sequence() */
 +        if (dirac_decode_data_unit(avctx, buf+buf_idx, data_unit_size))
 +        {
 +            av_log(s->avctx, AV_LOG_ERROR,"Error in dirac_decode_data_unit\n");
 +            return -1;
 +        }
 +        buf_idx += data_unit_size;
 +    }
 +
 +    if (!s->current_picture)
 +        return buf_size;
 +
 +    if (s->current_picture->avframe.display_picture_number > s->frame_number) {
 +        DiracFrame *delayed_frame = remove_frame(s->delay_frames, s->frame_number);
 +
 +        s->current_picture->avframe.reference |= DELAYED_PIC_REF;
 +
 +        if (add_frame(s->delay_frames, MAX_DELAY, s->current_picture)) {
 +            int min_num = s->delay_frames[0]->avframe.display_picture_number;
 +            /* Too many delayed frames, so we display the frame with the lowest pts */
 +            av_log(avctx, AV_LOG_ERROR, "Delay frame overflow\n");
 +            delayed_frame = s->delay_frames[0];
 +
 +            for (i = 1; s->delay_frames[i]; i++)
 +                if (s->delay_frames[i]->avframe.display_picture_number < min_num)
 +                    min_num = s->delay_frames[i]->avframe.display_picture_number;
 +
 +            delayed_frame = remove_frame(s->delay_frames, min_num);
 +            add_frame(s->delay_frames, MAX_DELAY, s->current_picture);
 +        }
 +
 +        if (delayed_frame) {
 +            delayed_frame->avframe.reference ^= DELAYED_PIC_REF;
 +            *(AVFrame*)data = delayed_frame->avframe;
 +            *data_size = sizeof(AVFrame);
 +        }
 +    } else if (s->current_picture->avframe.display_picture_number == s->frame_number) {
 +        /* The right frame at the right time :-) */
 +        *(AVFrame*)data = s->current_picture->avframe;
 +        *data_size = sizeof(AVFrame);
 +    }
 +
 +    if (*data_size)
 +        s->frame_number = picture->avframe.display_picture_number + 1;
 +
 +    return buf_idx;
 +}
 +
 +AVCodec ff_dirac_decoder = {
 +    .name           = "dirac",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_DIRAC,
 +    .priv_data_size = sizeof(DiracContext),
 +    .init           = dirac_decode_init,
 +    .close          = dirac_decode_end,
 +    .decode         = dirac_decode_frame,
 +    .capabilities   = CODEC_CAP_DELAY,
 +    .flush          = dirac_decode_flush,
 +    .long_name      = NULL_IF_CONFIG_SMALL("BBC Dirac VC-2"),
 +};
@@@ -30,7 -30,7 +30,8 @@@
  #include "get_bits.h"
  #include "dnxhddata.h"
  #include "dsputil.h"
+ #include "internal.h"
 +#include "thread.h"
  
  typedef struct DNXHDContext {
      AVCodecContext *avctx;
@@@ -207,13 -208,10 +208,13 @@@ static int dpcm_decode_frame(AVCodecCon
          av_log(avctx, AV_LOG_ERROR, "packet is too small\n");
          return AVERROR(EINVAL);
      }
 +    if (out % avctx->channels) {
 +        av_log(avctx, AV_LOG_WARNING, "channels have differing number of samples\n");
 +    }
  
      /* get output buffer */
 -    s->frame.nb_samples = out / avctx->channels;
 +    s->frame.nb_samples = (out + avctx->channels - 1) / avctx->channels;
-     if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
+     if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return ret;
      }
@@@ -187,7 -156,11 +188,7 @@@ static int decode_frame(AVCodecContext 
  
      if (s->picture.data[0])
          avctx->release_buffer(avctx, &s->picture);
-     if (avctx->get_buffer(avctx, p) < 0) {
 -    if (av_image_check_size(w, h, 0, avctx))
 -        return -1;
 -    if (w != avctx->width || h != avctx->height)
 -        avcodec_set_dimensions(avctx, w, h);
+     if (ff_get_buffer(avctx, p) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return -1;
      }
Simple merge
Simple merge
Simple merge
@@@ -179,11 -172,9 +180,11 @@@ static int cmv_decode_frame(AVCodecCont
      FFSWAP(AVFrame, s->last_frame, s->last2_frame);
      FFSWAP(AVFrame, s->frame, s->last_frame);
  
 -    s->frame.reference = 1;
 -    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID;
 +    s->frame.reference = 3;
 +    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID |
 +                            FF_BUFFER_HINTS_READABLE |
 +                            FF_BUFFER_HINTS_PRESERVE;
-     if (avctx->get_buffer(avctx, &s->frame)<0) {
+     if (ff_get_buffer(avctx, &s->frame)<0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return -1;
      }
@@@ -263,15 -254,13 +264,15 @@@ static int decode_frame(AVCodecContext 
          avcodec_set_dimensions(avctx, width, height);
          if (s->frame.data[0])
              avctx->release_buffer(avctx, &s->frame);
 +        if (s->last_frame.data[0])
 +            avctx->release_buffer(avctx, &s->last_frame);
      }
  
 -    s->frame.reference = 1;
 +    s->frame.reference = 3;
      if (!s->frame.data[0]) {
-         if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
 -        if (ff_get_buffer(avctx, &s->frame) < 0) {
++        if ((ret = ff_get_buffer(avctx, &s->frame)) < 0) {
              av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -            return -1;
 +            return ret;
          }
      }
  
Simple merge
Simple merge
Simple merge
index 97547bb,0000000..b56bb44
mode 100644,000000..100644
--- /dev/null
@@@ -1,319 -1,0 +1,321 @@@
-     if (avctx->get_buffer(avctx, &new_frame)) {
 +/*
 + * Escape 130 Video Decoder
 + * Copyright (C) 2008 Eli Friedman (eli.friedman <at> gmail.com)
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "avcodec.h"
 +
 +#define BITSTREAM_READER_LE
 +#include "get_bits.h"
++#include "internal.h"
++
 +
 +typedef struct Escape130Context {
 +    AVFrame frame;
 +    uint8_t *bases;
 +} Escape130Context;
 +
 +/**
 + * Initialize the decoder
 + * @param avctx decoder context
 + * @return 0 success, negative on error
 + */
 +static av_cold int escape130_decode_init(AVCodecContext *avctx)
 +{
 +    Escape130Context *s = avctx->priv_data;
 +    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 +
 +    if((avctx->width&1) || (avctx->height&1)){
 +        av_log(avctx, AV_LOG_ERROR, "Dimensions are not a multiple of the block size\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    s->bases= av_malloc(avctx->width * avctx->height /4);
 +
 +    return 0;
 +}
 +
 +static av_cold int escape130_decode_close(AVCodecContext *avctx)
 +{
 +    Escape130Context *s = avctx->priv_data;
 +
 +    if (s->frame.data[0])
 +        avctx->release_buffer(avctx, &s->frame);
 +
 +    av_freep(&s->bases);
 +
 +    return 0;
 +}
 +
 +static unsigned decode_skip_count(GetBitContext* gb) {
 +    unsigned value;
 +    // This function reads a maximum of 27 bits,
 +    // which is within the padding space
 +    if (get_bits_left(gb) < 1+3)
 +        return -1;
 +
 +    value = get_bits1(gb);
 +    if (value)
 +        return 0;
 +
 +    value = get_bits(gb, 3);
 +    if (value)
 +        return value;
 +
 +    value = get_bits(gb, 8);
 +    if (value)
 +        return value + 7;
 +
 +    value = get_bits(gb, 15);
 +    if (value)
 +        return value + 262;
 +
 +    return -1;
 +}
 +
 +/**
 + * Decode a single frame
 + * @param avctx decoder context
 + * @param data decoded frame
 + * @param data_size size of the decoded frame
 + * @param buf input buffer
 + * @param buf_size input buffer size
 + * @return 0 success, -1 on error
 + */
 +static int escape130_decode_frame(AVCodecContext *avctx,
 +                                  void *data, int *data_size,
 +                                  AVPacket *avpkt)
 +{
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size = avpkt->size;
 +    Escape130Context *s = avctx->priv_data;
 +
 +    GetBitContext gb;
 +    unsigned i;
 +
 +    uint8_t *old_y, *old_cb, *old_cr,
 +            *new_y, *new_cb, *new_cr;
 +    unsigned old_y_stride, old_cb_stride, old_cr_stride,
 +             new_y_stride, new_cb_stride, new_cr_stride;
 +    unsigned total_blocks = avctx->width * avctx->height / 4,
 +             block_index, row_index = 0;
 +    unsigned y[4] = {0}, cb = 16, cr = 16;
 +    unsigned skip = -1;
 +    unsigned y_base = 0;
 +    uint8_t *yb= s->bases;
 +
 +    AVFrame new_frame = { { 0 } };
 +
 +    init_get_bits(&gb, buf, buf_size * 8);
 +
 +    if (get_bits_left(&gb) < 128)
 +        return -1;
 +
 +    // Header; no useful information in here
 +    skip_bits_long(&gb, 128);
 +
 +    new_frame.reference = 3;
++    if (ff_get_buffer(avctx, &new_frame)) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return -1;
 +    }
 +
 +    new_y = new_frame.data[0];
 +    new_cb = new_frame.data[1];
 +    new_cr = new_frame.data[2];
 +    new_y_stride = new_frame.linesize[0];
 +    new_cb_stride = new_frame.linesize[1];
 +    new_cr_stride = new_frame.linesize[2];
 +    old_y = s->frame.data[0];
 +    old_cb = s->frame.data[1];
 +    old_cr = s->frame.data[2];
 +    old_y_stride = s->frame.linesize[0];
 +    old_cb_stride = s->frame.linesize[1];
 +    old_cr_stride = s->frame.linesize[2];
 +
 +    av_log(avctx, AV_LOG_DEBUG,
 +           "Strides: %i, %i\n",
 +           new_y_stride, new_cb_stride);
 +
 +    for (block_index = 0; block_index < total_blocks; block_index++) {
 +        // Note that this call will make us skip the rest of the blocks
 +        // if the frame prematurely ends
 +        if (skip == -1)
 +            skip = decode_skip_count(&gb);
 +
 +        if (skip) {
 +            if (old_y) {
 +                y[0] = old_y[0] / 4;
 +                y[1] = old_y[1] / 4;
 +                y[2] = old_y[old_y_stride] / 4;
 +                y[3] = old_y[old_y_stride+1] / 4;
 +                y_base= yb[0];
 +                cb = old_cb[0] / 8;
 +                cr = old_cr[0] / 8;
 +            } else {
 +                y_base=y[0] = y[1] = y[2] = y[3] = 0;
 +                cb = cr = 16;
 +            }
 +        } else {
 +            if (get_bits1(&gb)) {
 +                static const uint8_t offset_table[] = {2, 4, 10, 20};
 +                static const int8_t sign_table[64][4] =
 +                    { {0, 0, 0, 0},
 +                      {-1, 1, 0, 0},
 +                      {1, -1, 0, 0},
 +                      {-1, 0, 1, 0},
 +                      {-1, 1, 1, 0},
 +                      {0, -1, 1, 0},
 +                      {1, -1, 1, 0},
 +                      {-1, -1, 1, 0},
 +                      {1, 0, -1, 0},
 +                      {0, 1, -1, 0},
 +                      {1, 1, -1, 0},
 +                      {-1, 1, -1, 0},
 +                      {1, -1, -1, 0},
 +                      {-1, 0, 0, 1},
 +                      {-1, 1, 0, 1},
 +                      {0, -1, 0, 1},
 +
 +                      {0, 0, 0, 0},
 +                      {1, -1, 0, 1},
 +                      {-1, -1, 0, 1},
 +                      {-1, 0, 1, 1},
 +                      {-1, 1, 1, 1},
 +                      {0, -1, 1, 1},
 +                      {1, -1, 1, 1},
 +                      {-1, -1, 1, 1},
 +                      {0, 0, -1, 1},
 +                      {1, 0, -1, 1},
 +                      {-1, 0, -1, 1},
 +                      {0, 1, -1, 1},
 +                      {1, 1, -1, 1},
 +                      {-1, 1, -1, 1},
 +                      {0, -1, -1, 1},
 +                      {1, -1, -1, 1},
 +
 +                      {0, 0, 0, 0},
 +                      {-1, -1, -1, 1},
 +                      {1, 0, 0, -1},
 +                      {0, 1, 0, -1},
 +                      {1, 1, 0, -1},
 +                      {-1, 1, 0, -1},
 +                      {1, -1, 0, -1},
 +                      {0, 0, 1, -1},
 +                      {1, 0, 1, -1},
 +                      {-1, 0, 1, -1},
 +                      {0, 1, 1, -1},
 +                      {1, 1, 1, -1},
 +                      {-1, 1, 1, -1},
 +                      {0, -1, 1, -1},
 +                      {1, -1, 1, -1},
 +                      {-1, -1, 1, -1},
 +
 +                      {0, 0, 0, 0},
 +                      {1, 0, -1, -1},
 +                      {0, 1, -1, -1},
 +                      {1, 1, -1, -1},
 +                      {-1, 1, -1, -1},
 +                      {1, -1, -1, -1} };
 +                unsigned sign_selector = get_bits(&gb, 6);
 +                unsigned difference_selector = get_bits(&gb, 2);
 +                y_base = 2 * get_bits(&gb, 5);
 +                for (i = 0; i < 4; i++) {
 +                    y[i] = av_clip((int)y_base + offset_table[difference_selector] *
 +                                            sign_table[sign_selector][i], 0, 63);
 +                }
 +            } else if (get_bits1(&gb)) {
 +                if (get_bits1(&gb)) {
 +                    y_base = get_bits(&gb, 6);
 +                } else {
 +                    unsigned adjust_index = get_bits(&gb, 3);
 +                    static const int8_t adjust[] = {-4, -3, -2, -1, 1, 2, 3, 4};
 +                    y_base = (y_base + adjust[adjust_index]) & 63;
 +                }
 +                for (i = 0; i < 4; i++)
 +                    y[i] = y_base;
 +            }
 +
 +            if (get_bits1(&gb)) {
 +                if (get_bits1(&gb)) {
 +                    cb = get_bits(&gb, 5);
 +                    cr = get_bits(&gb, 5);
 +                } else {
 +                    unsigned adjust_index = get_bits(&gb, 3);
 +                    static const int8_t adjust[2][8] =
 +                        {  { 1, 1, 0, -1, -1, -1,  0,  1 },
 +                           { 0, 1, 1,  1,  0, -1, -1, -1 } };
 +                    cb = (cb + adjust[0][adjust_index]) & 31;
 +                    cr = (cr + adjust[1][adjust_index]) & 31;
 +                }
 +            }
 +        }
 +        *yb++= y_base;
 +
 +        new_y[0] = y[0] * 4;
 +        new_y[1] = y[1] * 4;
 +        new_y[new_y_stride] = y[2] * 4;
 +        new_y[new_y_stride + 1] = y[3] * 4;
 +        *new_cb = cb * 8;
 +        *new_cr = cr * 8;
 +
 +        if (old_y)
 +            old_y += 2, old_cb++, old_cr++;
 +        new_y += 2, new_cb++, new_cr++;
 +        row_index++;
 +        if (avctx->width / 2 == row_index) {
 +            row_index = 0;
 +            if (old_y) {
 +                old_y  += old_y_stride * 2  - avctx->width;
 +                old_cb += old_cb_stride - avctx->width / 2;
 +                old_cr += old_cr_stride - avctx->width / 2;
 +            }
 +            new_y  += new_y_stride * 2  - avctx->width;
 +            new_cb += new_cb_stride - avctx->width / 2;
 +            new_cr += new_cr_stride - avctx->width / 2;
 +        }
 +
 +        skip--;
 +    }
 +
 +    av_log(avctx, AV_LOG_DEBUG,
 +           "Escape sizes: %i, %i\n",
 +           buf_size, get_bits_count(&gb) / 8);
 +
 +    if (s->frame.data[0])
 +        avctx->release_buffer(avctx, &s->frame);
 +
 +    *(AVFrame*)data = s->frame = new_frame;
 +    *data_size = sizeof(AVFrame);
 +
 +    return buf_size;
 +}
 +
 +
 +AVCodec ff_escape130_decoder = {
 +    .name           = "escape130",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_ESCAPE130,
 +    .priv_data_size = sizeof(Escape130Context),
 +    .init           = escape130_decode_init,
 +    .close          = escape130_decode_close,
 +    .decode         = escape130_decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Escape 130"),
 +};
Simple merge
index c63b90f,0000000..eb3b455
mode 100644,000000..100644
--- /dev/null
@@@ -1,482 -1,0 +1,484 @@@
-     r = avc->get_buffer(avc, &ws->frame);
 +/*
 + * Wavesynth pseudo-codec
 + * Copyright (c) 2011 Nicolas George
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/intreadwrite.h"
 +#include "libavutil/log.h"
 +#include "avcodec.h"
++#include "internal.h"
++
 +
 +#define SIN_BITS 14
 +#define WS_MAX_CHANNELS 32
 +#define INF_TS 0x7FFFFFFFFFFFFFFF
 +
 +#define PINK_UNIT 128
 +
 +/*
 +   Format of the extradata and packets
 +
 +   THIS INFORMATION IS NOT PART OF THE PUBLIC API OR ABI.
 +   IT CAN CHANGE WITHOUT NOTIFICATION.
 +
 +   All numbers are in little endian.
 +
 +   The codec extradata define a set of intervals with uniform content.
 +   Overlapping intervals are added together.
 +
 +   extradata:
 +       uint32      number of intervals
 +       ...         intervals
 +
 +   interval:
 +       int64       start timestamp; time_base must be 1/sample_rate;
 +                   start timestamps must be in ascending order
 +       int64       end timestamp
 +       uint32      type
 +       uint32      channels mask
 +       ...         additional information, depends on type
 +
 +   sine interval (type fourcc "SINE"):
 +       int32       start frequency, in 1/(1<<16) Hz
 +       int32       end frequency
 +       int32       start amplitude, 1<<16 is the full amplitude
 +       int32       end amplitude
 +       uint32      start phase, 0 is sin(0), 0x20000000 is sin(pi/2), etc.;
 +                   n | (1<<31) means to match the phase of previous channel #n
 +
 +   pink noise interval (type fourcc "NOIS"):
 +       int32       start amplitude
 +       int32       end amplitude
 +
 +   The input packets encode the time and duration of the requested segment.
 +
 +   packet:
 +       int64       start timestamp
 +       int32       duration
 +
 +*/
 +
 +enum ws_interval_type {
 +    WS_SINE  = MKTAG('S','I','N','E'),
 +    WS_NOISE = MKTAG('N','O','I','S'),
 +};
 +
 +struct ws_interval {
 +    int64_t ts_start, ts_end;
 +    uint64_t phi0, dphi0, ddphi;
 +    uint64_t amp0, damp;
 +    uint64_t phi, dphi, amp;
 +    uint32_t channels;
 +    enum ws_interval_type type;
 +    int next;
 +};
 +
 +struct wavesynth_context {
 +    int64_t cur_ts;
 +    int64_t next_ts;
 +    int32_t *sin;
 +    AVFrame frame;
 +    struct ws_interval *inter;
 +    uint32_t dither_state;
 +    uint32_t pink_state;
 +    int32_t pink_pool[PINK_UNIT];
 +    unsigned pink_need, pink_pos;
 +    int nb_inter;
 +    int cur_inter;
 +    int next_inter;
 +};
 +
 +#define LCG_A 1284865837
 +#define LCG_C 4150755663
 +#define LCG_AI 849225893 /* A*AI = 1 [mod 1<<32] */
 +
 +static uint32_t lcg_next(uint32_t *s)
 +{
 +    *s = *s * LCG_A + LCG_C;
 +    return *s;
 +}
 +
 +static void lcg_seek(uint32_t *s, int64_t dt)
 +{
 +    uint32_t a, c, t = *s;
 +
 +    if (dt >= 0) {
 +        a = LCG_A;
 +        c = LCG_C;
 +    } else { /* coefficients for a step backward */
 +        a = LCG_AI;
 +        c = (uint32_t)(LCG_AI * LCG_C);
 +        dt = -dt;
 +    }
 +    while (dt) {
 +        if (dt & 1)
 +            t = a * t + c;
 +        c *= a + 1; /* coefficients for a double step */
 +        a *= a;
 +        dt >>= 1;
 +    }
 +    *s = t;
 +}
 +
 +/* Emulate pink noise by summing white noise at the sampling frequency,
 + * white noise at half the sampling frequency (each value taken twice),
 + * etc., with a total of 8 octaves.
 + * This is known as the Voss-McCartney algorithm. */
 +
 +static void pink_fill(struct wavesynth_context *ws)
 +{
 +    int32_t vt[7] = { 0 }, v = 0;
 +    int i, j;
 +
 +    ws->pink_pos = 0;
 +    if (!ws->pink_need)
 +        return;
 +    for (i = 0; i < PINK_UNIT; i++) {
 +        for (j = 0; j < 7; j++) {
 +            if ((i >> j) & 1)
 +                break;
 +            v -= vt[j];
 +            vt[j] = (int32_t)lcg_next(&ws->pink_state) >> 3;
 +            v += vt[j];
 +        }
 +        ws->pink_pool[i] = v + ((int32_t)lcg_next(&ws->pink_state) >> 3);
 +    }
 +    lcg_next(&ws->pink_state); /* so we use exactly 256 steps */
 +}
 +
 +/**
 + * @return  (1<<64) * a / b, without overflow, if a < b
 + */
 +static uint64_t frac64(uint64_t a, uint64_t b)
 +{
 +    uint64_t r = 0;
 +    int i;
 +
 +    if (b < (uint64_t)1 << 32) { /* b small, use two 32-bits steps */
 +        a <<= 32;
 +        return ((a / b) << 32) | ((a % b) << 32) / b;
 +    }
 +    if (b < (uint64_t)1 << 48) { /* b medium, use four 16-bits steps */
 +        for (i = 0; i < 4; i++) {
 +            a <<= 16;
 +            r = (r << 16) | (a / b);
 +            a %= b;
 +        }
 +        return r;
 +    }
 +    for (i = 63; i >= 0; i--) {
 +        if (a >= (uint64_t)1 << 63 || a << 1 >= b) {
 +            r |= (uint64_t)1 << i;
 +            a = (a << 1) - b;
 +        } else {
 +            a <<= 1;
 +        }
 +    }
 +    return r;
 +}
 +
 +static uint64_t phi_at(struct ws_interval *in, int64_t ts)
 +{
 +    uint64_t dt = ts - in->ts_start;
 +    uint64_t dt2 = dt & 1 ? /* dt * (dt - 1) / 2 without overflow */
 +                   dt * ((dt - 1) >> 1) : (dt >> 1) * (dt - 1);
 +    return in->phi0 + dt * in->dphi0 + dt2 * in->ddphi;
 +}
 +
 +static void wavesynth_seek(struct wavesynth_context *ws, int64_t ts)
 +{
 +    int *last, i;
 +    struct ws_interval *in;
 +
 +    last = &ws->cur_inter;
 +    for (i = 0; i < ws->nb_inter; i++) {
 +        in = &ws->inter[i];
 +        if (ts < in->ts_start)
 +            break;
 +        if (ts >= in->ts_end)
 +            continue;
 +        *last = i;
 +        last = &in->next;
 +        in->phi  = phi_at(in, ts);
 +        in->dphi = in->dphi0 + (ts - in->ts_start) * in->ddphi;
 +        in->amp  = in->amp0  + (ts - in->ts_start) * in->damp;
 +    }
 +    ws->next_inter = i;
 +    ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
 +    *last = -1;
 +    lcg_seek(&ws->dither_state, ts - ws->cur_ts);
 +    if (ws->pink_need) {
 +        int64_t pink_ts_cur  = (ws->cur_ts + PINK_UNIT - 1) & ~(PINK_UNIT - 1);
 +        int64_t pink_ts_next = ts & ~(PINK_UNIT - 1);
 +        int pos = ts & (PINK_UNIT - 1);
 +        lcg_seek(&ws->pink_state, (pink_ts_next - pink_ts_cur) << 1);
 +        if (pos) {
 +            pink_fill(ws);
 +            ws->pink_pos = pos;
 +        } else {
 +            ws->pink_pos = PINK_UNIT;
 +        }
 +    }
 +    ws->cur_ts = ts;
 +}
 +
 +static int wavesynth_parse_extradata(AVCodecContext *avc)
 +{
 +    struct wavesynth_context *ws = avc->priv_data;
 +    struct ws_interval *in;
 +    uint8_t *edata, *edata_end;
 +    int32_t f1, f2, a1, a2;
 +    uint32_t phi;
 +    int64_t dphi1, dphi2, dt, cur_ts = -0x8000000000000000;
 +    int i;
 +
 +    if (avc->extradata_size < 4)
 +        return AVERROR(EINVAL);
 +    edata = avc->extradata;
 +    edata_end = edata + avc->extradata_size;
 +    ws->nb_inter = AV_RL32(edata);
 +    edata += 4;
 +    if (ws->nb_inter < 0)
 +        return AVERROR(EINVAL);
 +    ws->inter = av_calloc(ws->nb_inter, sizeof(*ws->inter));
 +    if (!ws->inter)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i < ws->nb_inter; i++) {
 +        in = &ws->inter[i];
 +        if (edata_end - edata < 24)
 +            return AVERROR(EINVAL);
 +        in->ts_start = AV_RL64(edata +  0);
 +        in->ts_end   = AV_RL64(edata +  8);
 +        in->type     = AV_RL32(edata + 16);
 +        in->channels = AV_RL32(edata + 20);
 +        edata += 24;
 +        if (in->ts_start < cur_ts || in->ts_end <= in->ts_start)
 +            return AVERROR(EINVAL);
 +        cur_ts = in->ts_start;
 +        dt = in->ts_end - in->ts_start;
 +        switch (in->type) {
 +            case WS_SINE:
 +                if (edata_end - edata < 20)
 +                    return AVERROR(EINVAL);
 +                f1  = AV_RL32(edata +  0);
 +                f2  = AV_RL32(edata +  4);
 +                a1  = AV_RL32(edata +  8);
 +                a2  = AV_RL32(edata + 12);
 +                phi = AV_RL32(edata + 16);
 +                edata += 20;
 +                dphi1 = frac64(f1, (int64_t)avc->sample_rate << 16);
 +                dphi2 = frac64(f2, (int64_t)avc->sample_rate << 16);
 +                in->dphi0 = dphi1;
 +                in->ddphi = (dphi2 - dphi1) / dt;
 +                if (phi & 0x80000000) {
 +                    phi &= ~0x80000000;
 +                    if (phi >= i)
 +                        return AVERROR(EINVAL);
 +                    in->phi0 = phi_at(&ws->inter[phi], in->ts_start);
 +                } else {
 +                    in->phi0 = (uint64_t)phi << 33;
 +                }
 +                break;
 +            case WS_NOISE:
 +                if (edata_end - edata < 8)
 +                    return AVERROR(EINVAL);
 +                a1  = AV_RL32(edata +  0);
 +                a2  = AV_RL32(edata +  4);
 +                edata += 8;
 +                break;
 +            default:
 +                return AVERROR(EINVAL);
 +        }
 +        in->amp0 = (int64_t)a1 << 32;
 +        in->damp = (((int64_t)a2 << 32) - ((int64_t)a1 << 32)) / dt;
 +    }
 +    if (edata != edata_end)
 +        return AVERROR(EINVAL);
 +    return 0;
 +}
 +
 +static av_cold int wavesynth_init(AVCodecContext *avc)
 +{
 +    struct wavesynth_context *ws = avc->priv_data;
 +    int i, r;
 +
 +    if (avc->channels > WS_MAX_CHANNELS) {
 +        av_log(avc, AV_LOG_ERROR,
 +               "This implementation is limited to %d channels.\n",
 +               WS_MAX_CHANNELS);
 +        return AVERROR(EINVAL);
 +    }
 +    r = wavesynth_parse_extradata(avc);
 +    if (r < 0) {
 +        av_log(avc, AV_LOG_ERROR, "Invalid intervals definitions.\n");
 +        goto fail;
 +    }
 +    ws->sin = av_malloc(sizeof(*ws->sin) << SIN_BITS);
 +    if (!ws->sin) {
 +        r = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +    for (i = 0; i < 1 << SIN_BITS; i++)
 +        ws->sin[i] = floor(32767 * sin(2 * M_PI * i / (1 << SIN_BITS)));
 +    ws->dither_state = MKTAG('D','I','T','H');
 +    for (i = 0; i < ws->nb_inter; i++)
 +        ws->pink_need += ws->inter[i].type == WS_NOISE;
 +    ws->pink_state = MKTAG('P','I','N','K');
 +    ws->pink_pos = PINK_UNIT;
 +    avcodec_get_frame_defaults(&ws->frame);
 +    avc->coded_frame = &ws->frame;
 +    wavesynth_seek(ws, 0);
 +    avc->sample_fmt = AV_SAMPLE_FMT_S16;
 +    return 0;
 +
 +fail:
 +    av_free(ws->inter);
 +    av_free(ws->sin);
 +    return r;
 +}
 +
 +static void wavesynth_synth_sample(struct wavesynth_context *ws, int64_t ts,
 +                                   int32_t *channels)
 +{
 +    int32_t amp, val, *cv;
 +    struct ws_interval *in;
 +    int i, *last, pink;
 +    uint32_t c, all_ch = 0;
 +
 +    i = ws->cur_inter;
 +    last = &ws->cur_inter;
 +    if (ws->pink_pos == PINK_UNIT)
 +        pink_fill(ws);
 +    pink = ws->pink_pool[ws->pink_pos++] >> 16;
 +    while (i >= 0) {
 +        in = &ws->inter[i];
 +        i = in->next;
 +        if (ts >= in->ts_end) {
 +            *last = i;
 +            continue;
 +        }
 +        last = &in->next;
 +        amp = in->amp >> 32;
 +        in->amp  += in->damp;
 +        switch (in->type) {
 +            case WS_SINE:
 +                val = amp * ws->sin[in->phi >> (64 - SIN_BITS)];
 +                in->phi  += in->dphi;
 +                in->dphi += in->ddphi;
 +                break;
 +            case WS_NOISE:
 +                val = amp * pink;
 +                break;
 +            default:
 +                val = 0;
 +        }
 +        all_ch |= in->channels;
 +        for (c = in->channels, cv = channels; c; c >>= 1, cv++)
 +            if (c & 1)
 +                *cv += val;
 +    }
 +    val = (int32_t)lcg_next(&ws->dither_state) >> 16;
 +    for (c = all_ch, cv = channels; c; c >>= 1, cv++)
 +        if (c & 1)
 +            *cv += val;
 +}
 +
 +static void wavesynth_enter_intervals(struct wavesynth_context *ws, int64_t ts)
 +{
 +    int *last, i;
 +    struct ws_interval *in;
 +
 +    last = &ws->cur_inter;
 +    for (i = ws->cur_inter; i >= 0; i = ws->inter[i].next)
 +        last = &ws->inter[i].next;
 +    for (i = ws->next_inter; i < ws->nb_inter; i++) {
 +        in = &ws->inter[i];
 +        if (ts < in->ts_start)
 +            break;
 +        if (ts >= in->ts_end)
 +            continue;
 +        *last = i;
 +        last = &in->next;
 +        in->phi = in->phi0;
 +        in->dphi = in->dphi0;
 +        in->amp = in->amp0;
 +    }
 +    ws->next_inter = i;
 +    ws->next_ts = i < ws->nb_inter ? ws->inter[i].ts_start : INF_TS;
 +    *last = -1;
 +}
 +
 +static int wavesynth_decode(AVCodecContext *avc, void *rframe, int *rgot_frame,
 +                            AVPacket *packet)
 +{
 +    struct wavesynth_context *ws = avc->priv_data;
 +    int64_t ts;
 +    int duration;
 +    int s, c, r;
 +    int16_t *pcm;
 +    int32_t channels[WS_MAX_CHANNELS];
 +
 +    *rgot_frame = 0;
 +    if (packet->size != 12)
 +        return AVERROR_INVALIDDATA;
 +    ts = AV_RL64(packet->data);
 +    if (ts != ws->cur_ts)
 +        wavesynth_seek(ws, ts);
 +    duration = AV_RL32(packet->data + 8);
 +    if (duration <= 0)
 +        return AVERROR(EINVAL);
 +    ws->frame.nb_samples = duration;
++    r = ff_get_buffer(avc, &ws->frame);
 +    if (r < 0)
 +        return r;
 +    pcm = (int16_t *)ws->frame.data[0];
 +    for (s = 0; s < duration; s++, ts++) {
 +        memset(channels, 0, avc->channels * sizeof(*channels));
 +        if (ts >= ws->next_ts)
 +            wavesynth_enter_intervals(ws, ts);
 +        wavesynth_synth_sample(ws, ts, channels);
 +        for (c = 0; c < avc->channels; c++)
 +            *(pcm++) = channels[c] >> 16;
 +    }
 +    ws->cur_ts += duration;
 +    *rgot_frame = 1;
 +    *(AVFrame *)rframe = ws->frame;
 +    return packet->size;
 +}
 +
 +static av_cold int wavesynth_close(AVCodecContext *avc)
 +{
 +    struct wavesynth_context *ws = avc->priv_data;
 +
 +    av_free(ws->sin);
 +    av_free(ws->inter);
 +    return 0;
 +}
 +
 +AVCodec ff_ffwavesynth_decoder = {
 +    .name           = "wavesynth",
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = AV_CODEC_ID_FFWAVESYNTH,
 +    .priv_data_size = sizeof(struct wavesynth_context),
 +    .init           = wavesynth_init,
 +    .close          = wavesynth_close,
 +    .decode         = wavesynth_decode,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Wave synthesis pseudo-codec"),
 +};
Simple merge
index ab095dc,0000000..0ac018b
mode 100644,000000..100644
--- /dev/null
@@@ -1,270 -1,0 +1,270 @@@
-             ret = c->parent_avctx->get_buffer(c->parent_avctx, new);
 +/*
 + * Copyright (c) 2012 Michael Niedermayer <michaelni@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "frame_thread_encoder.h"
 +
 +#include "libavutil/fifo.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/imgutils.h"
 +#include "avcodec.h"
 +#include "internal.h"
 +#include "thread.h"
 +
 +#if HAVE_PTHREADS
 +#include <pthread.h>
 +#elif HAVE_W32THREADS
 +#include "w32pthreads.h"
 +#elif HAVE_OS2THREADS
 +#include "os2threads.h"
 +#endif
 +
 +#define MAX_THREADS 64
 +#define BUFFER_SIZE (2*MAX_THREADS)
 +
 +typedef struct{
 +    void *indata;
 +    void *outdata;
 +    int64_t return_code;
 +    unsigned index;
 +} Task;
 +
 +typedef struct{
 +    AVCodecContext *parent_avctx;
 +    pthread_mutex_t buffer_mutex;
 +
 +    AVFifoBuffer *task_fifo;
 +    pthread_mutex_t task_fifo_mutex;
 +    pthread_cond_t task_fifo_cond;
 +
 +    Task finished_tasks[BUFFER_SIZE];
 +    pthread_mutex_t finished_task_mutex;
 +    pthread_cond_t finished_task_cond;
 +
 +    unsigned task_index;
 +    unsigned finished_task_index;
 +
 +    pthread_t worker[MAX_THREADS];
 +    int exit;
 +} ThreadContext;
 +
 +static void * attribute_align_arg worker(void *v){
 +    AVCodecContext *avctx = v;
 +    ThreadContext *c = avctx->internal->frame_thread_encoder;
 +    AVPacket *pkt = NULL;
 +
 +    while(!c->exit){
 +        int got_packet, ret;
 +        AVFrame *frame;
 +        Task task;
 +
 +        if(!pkt) pkt= av_mallocz(sizeof(*pkt));
 +        if(!pkt) continue;
 +        av_init_packet(pkt);
 +
 +        pthread_mutex_lock(&c->task_fifo_mutex);
 +        while (av_fifo_size(c->task_fifo) <= 0 || c->exit) {
 +            if(c->exit){
 +                pthread_mutex_unlock(&c->task_fifo_mutex);
 +                goto end;
 +            }
 +            pthread_cond_wait(&c->task_fifo_cond, &c->task_fifo_mutex);
 +        }
 +        av_fifo_generic_read(c->task_fifo, &task, sizeof(task), NULL);
 +        pthread_mutex_unlock(&c->task_fifo_mutex);
 +        frame = task.indata;
 +
 +        ret = avcodec_encode_video2(avctx, pkt, frame, &got_packet);
 +        pthread_mutex_lock(&c->buffer_mutex);
 +        c->parent_avctx->release_buffer(c->parent_avctx, frame);
 +        pthread_mutex_unlock(&c->buffer_mutex);
 +        av_freep(&frame);
 +        if(got_packet) {
 +            av_dup_packet(pkt);
 +        } else {
 +            pkt->data = NULL;
 +            pkt->size = 0;
 +        }
 +        pthread_mutex_lock(&c->finished_task_mutex);
 +        c->finished_tasks[task.index].outdata = pkt; pkt = NULL;
 +        c->finished_tasks[task.index].return_code = ret;
 +        pthread_cond_signal(&c->finished_task_cond);
 +        pthread_mutex_unlock(&c->finished_task_mutex);
 +    }
 +end:
 +    av_free(pkt);
 +    pthread_mutex_lock(&c->buffer_mutex);
 +    avcodec_close(avctx);
 +    pthread_mutex_unlock(&c->buffer_mutex);
 +    av_freep(&avctx);
 +    return NULL;
 +}
 +
 +int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options){
 +    int i=0;
 +    ThreadContext *c;
 +
 +
 +    if(   !(avctx->thread_type & FF_THREAD_FRAME)
 +       || !(avctx->codec->capabilities & CODEC_CAP_INTRA_ONLY))
 +        return 0;
 +
 +    if(!avctx->thread_count) {
 +        avctx->thread_count = ff_get_logical_cpus(avctx);
 +        avctx->thread_count = FFMIN(avctx->thread_count, MAX_THREADS);
 +    }
 +
 +    if(avctx->thread_count <= 1)
 +        return 0;
 +
 +    if(avctx->thread_count > MAX_THREADS)
 +        return AVERROR(EINVAL);
 +
 +    av_assert0(!avctx->internal->frame_thread_encoder);
 +    c = avctx->internal->frame_thread_encoder = av_mallocz(sizeof(ThreadContext));
 +    if(!c)
 +        return AVERROR(ENOMEM);
 +
 +    c->parent_avctx = avctx;
 +
 +    c->task_fifo = av_fifo_alloc(sizeof(Task) * BUFFER_SIZE);
 +    if(!c->task_fifo)
 +        goto fail;
 +
 +    pthread_mutex_init(&c->task_fifo_mutex, NULL);
 +    pthread_mutex_init(&c->finished_task_mutex, NULL);
 +    pthread_mutex_init(&c->buffer_mutex, NULL);
 +    pthread_cond_init(&c->task_fifo_cond, NULL);
 +    pthread_cond_init(&c->finished_task_cond, NULL);
 +
 +    for(i=0; i<avctx->thread_count ; i++){
 +        AVDictionary *tmp = NULL;
 +        void *tmpv;
 +        AVCodecContext *thread_avctx = avcodec_alloc_context3(avctx->codec);
 +        if(!thread_avctx)
 +            goto fail;
 +        tmpv = thread_avctx->priv_data;
 +        *thread_avctx = *avctx;
 +        thread_avctx->priv_data = tmpv;
 +        thread_avctx->internal = NULL;
 +        memcpy(thread_avctx->priv_data, avctx->priv_data, avctx->codec->priv_data_size);
 +        thread_avctx->thread_count = 1;
 +        thread_avctx->active_thread_type &= ~FF_THREAD_FRAME;
 +
 +        av_dict_copy(&tmp, options, 0);
 +        av_dict_set(&tmp, "threads", "1", 0);
 +        if(avcodec_open2(thread_avctx, avctx->codec, &tmp) < 0) {
 +            av_dict_free(&tmp);
 +            goto fail;
 +        }
 +        av_dict_free(&tmp);
 +        av_assert0(!thread_avctx->internal->frame_thread_encoder);
 +        thread_avctx->internal->frame_thread_encoder = c;
 +        if(pthread_create(&c->worker[i], NULL, worker, thread_avctx)) {
 +            goto fail;
 +        }
 +    }
 +
 +    avctx->active_thread_type = FF_THREAD_FRAME;
 +
 +    return 0;
 +fail:
 +    avctx->thread_count = i;
 +    av_log(avctx, AV_LOG_ERROR, "ff_frame_thread_encoder_init failed\n");
 +    ff_frame_thread_encoder_free(avctx);
 +    return -1;
 +}
 +
 +void ff_frame_thread_encoder_free(AVCodecContext *avctx){
 +    int i;
 +    ThreadContext *c= avctx->internal->frame_thread_encoder;
 +
 +    pthread_mutex_lock(&c->task_fifo_mutex);
 +    c->exit = 1;
 +    pthread_cond_broadcast(&c->task_fifo_cond);
 +    pthread_mutex_unlock(&c->task_fifo_mutex);
 +
 +    for (i=0; i<avctx->thread_count; i++) {
 +         pthread_join(c->worker[i], NULL);
 +    }
 +
 +    pthread_mutex_destroy(&c->task_fifo_mutex);
 +    pthread_mutex_destroy(&c->finished_task_mutex);
 +    pthread_mutex_destroy(&c->buffer_mutex);
 +    pthread_cond_destroy(&c->task_fifo_cond);
 +    pthread_cond_destroy(&c->finished_task_cond);
 +    av_fifo_free(c->task_fifo); c->task_fifo = NULL;
 +    av_freep(&avctx->internal->frame_thread_encoder);
 +}
 +
 +int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr){
 +    ThreadContext *c = avctx->internal->frame_thread_encoder;
 +    Task task;
 +    int ret;
 +
 +    av_assert1(!*got_packet_ptr);
 +
 +    if(frame){
 +        if(!(avctx->flags & CODEC_FLAG_INPUT_PRESERVED)){
 +            AVFrame *new = avcodec_alloc_frame();
 +            if(!new)
 +                return AVERROR(ENOMEM);
 +            pthread_mutex_lock(&c->buffer_mutex);
++            ret = ff_get_buffer(c->parent_avctx, new);
 +            pthread_mutex_unlock(&c->buffer_mutex);
 +            if(ret<0)
 +                return ret;
 +            new->pts = frame->pts;
 +            new->quality = frame->quality;
 +            new->pict_type = frame->pict_type;
 +            av_image_copy(new->data, new->linesize, (const uint8_t **)frame->data, frame->linesize,
 +                          avctx->pix_fmt, avctx->width, avctx->height);
 +            frame = new;
 +        }
 +
 +        task.index = c->task_index;
 +        task.indata = (void*)frame;
 +        pthread_mutex_lock(&c->task_fifo_mutex);
 +        av_fifo_generic_write(c->task_fifo, &task, sizeof(task), NULL);
 +        pthread_cond_signal(&c->task_fifo_cond);
 +        pthread_mutex_unlock(&c->task_fifo_mutex);
 +
 +        c->task_index = (c->task_index+1) % BUFFER_SIZE;
 +
 +        if(!c->finished_tasks[c->finished_task_index].outdata && (c->task_index - c->finished_task_index) % BUFFER_SIZE <= avctx->thread_count)
 +            return 0;
 +    }
 +
 +    if(c->task_index == c->finished_task_index)
 +        return 0;
 +
 +    pthread_mutex_lock(&c->finished_task_mutex);
 +    while (!c->finished_tasks[c->finished_task_index].outdata) {
 +        pthread_cond_wait(&c->finished_task_cond, &c->finished_task_mutex);
 +    }
 +    task = c->finished_tasks[c->finished_task_index];
 +    *pkt = *(AVPacket*)(task.outdata);
 +    if(pkt->data)
 +        *got_packet_ptr = 1;
 +    av_freep(&c->finished_tasks[c->finished_task_index].outdata);
 +    c->finished_task_index = (c->finished_task_index+1) % BUFFER_SIZE;
 +    pthread_mutex_unlock(&c->finished_task_mutex);
 +
 +    return task.return_code;
 +}
  
  #include "avcodec.h"
  #include "bytestream.h"
+ #include "internal.h"
 +#include "libavutil/opt.h"
 +
 +typedef struct {
 +    AVClass *av_class;
 +    int change_field_order;
 +} FRWUContext;
  
  static av_cold int decode_init(AVCodecContext *avctx)
  {
Simple merge
@@@ -34,8 -33,8 +34,9 @@@
  #include "get_bits.h"
  #include "acelp_vectors.h"
  #include "celp_filters.h"
 +#include "celp_math.h"
  #include "g723_1_data.h"
+ #include "internal.h"
  
  #define CNG_RANDOM_SEED 12345
  
@@@ -1187,9 -1221,9 +1188,9 @@@ static int g723_1_decode_frame(AVCodecC
      }
  
      p->frame.nb_samples = FRAME_LEN;
-     if ((ret = avctx->get_buffer(avctx, &p->frame)) < 0) {
+     if ((ret = ff_get_buffer(avctx, &p->frame)) < 0) {
 -         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -         return ret;
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
      }
  
      out = (int16_t *)p->frame.data[0];
Simple merge
index 036614d,0000000..b44120f
mode 100644,000000..100644
--- /dev/null
@@@ -1,726 -1,0 +1,728 @@@
-     if ((ret = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
 +/*
 + * G.729, G729 Annex D decoders
 + * Copyright (c) 2008 Vladimir Voroshilov
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include <inttypes.h>
 +#include <string.h>
 +
 +#include "avcodec.h"
 +#include "libavutil/avutil.h"
 +#include "get_bits.h"
 +#include "dsputil.h"
++#include "internal.h"
++
 +
 +#include "g729.h"
 +#include "lsp.h"
 +#include "celp_math.h"
 +#include "celp_filters.h"
 +#include "acelp_filters.h"
 +#include "acelp_pitch_delay.h"
 +#include "acelp_vectors.h"
 +#include "g729data.h"
 +#include "g729postfilter.h"
 +
 +/**
 + * minimum quantized LSF value (3.2.4)
 + * 0.005 in Q13
 + */
 +#define LSFQ_MIN                   40
 +
 +/**
 + * maximum quantized LSF value (3.2.4)
 + * 3.135 in Q13
 + */
 +#define LSFQ_MAX                   25681
 +
 +/**
 + * minimum LSF distance (3.2.4)
 + * 0.0391 in Q13
 + */
 +#define LSFQ_DIFF_MIN              321
 +
 +/// interpolation filter length
 +#define INTERPOL_LEN              11
 +
 +/**
 + * minimum gain pitch value (3.8, Equation 47)
 + * 0.2 in (1.14)
 + */
 +#define SHARP_MIN                  3277
 +
 +/**
 + * maximum gain pitch value (3.8, Equation 47)
 + * (EE) This does not comply with the specification.
 + * Specification says about 0.8, which should be
 + * 13107 in (1.14), but reference C code uses
 + * 13017 (equals to 0.7945) instead of it.
 + */
 +#define SHARP_MAX                  13017
 +
 +/**
 + * MR_ENERGY (mean removed energy) = mean_energy + 10 * log10(2^26  * subframe_size) in (7.13)
 + */
 +#define MR_ENERGY 1018156
 +
 +#define DECISION_NOISE        0
 +#define DECISION_INTERMEDIATE 1
 +#define DECISION_VOICE        2
 +
 +typedef enum {
 +    FORMAT_G729_8K = 0,
 +    FORMAT_G729D_6K4,
 +    FORMAT_COUNT,
 +} G729Formats;
 +
 +typedef struct {
 +    uint8_t ac_index_bits[2];   ///< adaptive codebook index for second subframe (size in bits)
 +    uint8_t parity_bit;         ///< parity bit for pitch delay
 +    uint8_t gc_1st_index_bits;  ///< gain codebook (first stage) index (size in bits)
 +    uint8_t gc_2nd_index_bits;  ///< gain codebook (second stage) index (size in bits)
 +    uint8_t fc_signs_bits;      ///< number of pulses in fixed-codebook vector
 +    uint8_t fc_indexes_bits;    ///< size (in bits) of fixed-codebook index entry
 +} G729FormatDescription;
 +
 +typedef struct {
 +    DSPContext dsp;
 +    AVFrame frame;
 +
 +    /// past excitation signal buffer
 +    int16_t exc_base[2*SUBFRAME_SIZE+PITCH_DELAY_MAX+INTERPOL_LEN];
 +
 +    int16_t* exc;               ///< start of past excitation data in buffer
 +    int pitch_delay_int_prev;   ///< integer part of previous subframe's pitch delay (4.1.3)
 +
 +    /// (2.13) LSP quantizer outputs
 +    int16_t  past_quantizer_output_buf[MA_NP + 1][10];
 +    int16_t* past_quantizer_outputs[MA_NP + 1];
 +
 +    int16_t lsfq[10];           ///< (2.13) quantized LSF coefficients from previous frame
 +    int16_t lsp_buf[2][10];     ///< (0.15) LSP coefficients (previous and current frames) (3.2.5)
 +    int16_t *lsp[2];            ///< pointers to lsp_buf
 +
 +    int16_t quant_energy[4];    ///< (5.10) past quantized energy
 +
 +    /// previous speech data for LP synthesis filter
 +    int16_t syn_filter_data[10];
 +
 +
 +    /// residual signal buffer (used in long-term postfilter)
 +    int16_t residual[SUBFRAME_SIZE + RES_PREV_DATA_SIZE];
 +
 +    /// previous speech data for residual calculation filter
 +    int16_t res_filter_data[SUBFRAME_SIZE+10];
 +
 +    /// previous speech data for short-term postfilter
 +    int16_t pos_filter_data[SUBFRAME_SIZE+10];
 +
 +    /// (1.14) pitch gain of current and five previous subframes
 +    int16_t past_gain_pitch[6];
 +
 +    /// (14.1) gain code from current and previous subframe
 +    int16_t past_gain_code[2];
 +
 +    /// voice decision on previous subframe (0-noise, 1-intermediate, 2-voice), G.729D
 +    int16_t voice_decision;
 +
 +    int16_t onset;              ///< detected onset level (0-2)
 +    int16_t was_periodic;       ///< whether previous frame was declared as periodic or not (4.4)
 +    int16_t ht_prev_data;       ///< previous data for 4.2.3, equation 86
 +    int gain_coeff;             ///< (1.14) gain coefficient (4.2.4)
 +    uint16_t rand_value;        ///< random number generator value (4.4.4)
 +    int ma_predictor_prev;      ///< switched MA predictor of LSP quantizer from last good frame
 +
 +    /// (14.14) high-pass filter data (past input)
 +    int hpf_f[2];
 +
 +    /// high-pass filter data (past output)
 +    int16_t hpf_z[2];
 +}  G729Context;
 +
 +static const G729FormatDescription format_g729_8k = {
 +    .ac_index_bits     = {8,5},
 +    .parity_bit        = 1,
 +    .gc_1st_index_bits = GC_1ST_IDX_BITS_8K,
 +    .gc_2nd_index_bits = GC_2ND_IDX_BITS_8K,
 +    .fc_signs_bits     = 4,
 +    .fc_indexes_bits   = 13,
 +};
 +
 +static const G729FormatDescription format_g729d_6k4 = {
 +    .ac_index_bits     = {8,4},
 +    .parity_bit        = 0,
 +    .gc_1st_index_bits = GC_1ST_IDX_BITS_6K4,
 +    .gc_2nd_index_bits = GC_2ND_IDX_BITS_6K4,
 +    .fc_signs_bits     = 2,
 +    .fc_indexes_bits   = 9,
 +};
 +
 +/**
 + * @brief pseudo random number generator
 + */
 +static inline uint16_t g729_prng(uint16_t value)
 +{
 +    return 31821 * value + 13849;
 +}
 +
 +/**
 + * Get parity bit of bit 2..7
 + */
 +static inline int get_parity(uint8_t value)
 +{
 +   return (0x6996966996696996ULL >> (value >> 2)) & 1;
 +}
 +
 +/**
 + * Decodes LSF (Line Spectral Frequencies) from L0-L3 (3.2.4).
 + * @param[out] lsfq (2.13) quantized LSF coefficients
 + * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
 + * @param ma_predictor switched MA predictor of LSP quantizer
 + * @param vq_1st first stage vector of quantizer
 + * @param vq_2nd_low second stage lower vector of LSP quantizer
 + * @param vq_2nd_high second stage higher vector of LSP quantizer
 + */
 +static void lsf_decode(int16_t* lsfq, int16_t* past_quantizer_outputs[MA_NP + 1],
 +                       int16_t ma_predictor,
 +                       int16_t vq_1st, int16_t vq_2nd_low, int16_t vq_2nd_high)
 +{
 +    int i,j;
 +    static const uint8_t min_distance[2]={10, 5}; //(2.13)
 +    int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
 +
 +    for (i = 0; i < 5; i++) {
 +        quantizer_output[i]     = cb_lsp_1st[vq_1st][i    ] + cb_lsp_2nd[vq_2nd_low ][i    ];
 +        quantizer_output[i + 5] = cb_lsp_1st[vq_1st][i + 5] + cb_lsp_2nd[vq_2nd_high][i + 5];
 +    }
 +
 +    for (j = 0; j < 2; j++) {
 +        for (i = 1; i < 10; i++) {
 +            int diff = (quantizer_output[i - 1] - quantizer_output[i] + min_distance[j]) >> 1;
 +            if (diff > 0) {
 +                quantizer_output[i - 1] -= diff;
 +                quantizer_output[i    ] += diff;
 +            }
 +        }
 +    }
 +
 +    for (i = 0; i < 10; i++) {
 +        int sum = quantizer_output[i] * cb_ma_predictor_sum[ma_predictor][i];
 +        for (j = 0; j < MA_NP; j++)
 +            sum += past_quantizer_outputs[j][i] * cb_ma_predictor[ma_predictor][j][i];
 +
 +        lsfq[i] = sum >> 15;
 +    }
 +
 +    ff_acelp_reorder_lsf(lsfq, LSFQ_DIFF_MIN, LSFQ_MIN, LSFQ_MAX, 10);
 +}
 +
 +/**
 + * Restores past LSP quantizer output using LSF from previous frame
 + * @param[in,out] lsfq (2.13) quantized LSF coefficients
 + * @param[in,out] past_quantizer_outputs (2.13) quantizer outputs from previous frames
 + * @param ma_predictor_prev MA predictor from previous frame
 + * @param lsfq_prev (2.13) quantized LSF coefficients from previous frame
 + */
 +static void lsf_restore_from_previous(int16_t* lsfq,
 +                                      int16_t* past_quantizer_outputs[MA_NP + 1],
 +                                      int ma_predictor_prev)
 +{
 +    int16_t* quantizer_output = past_quantizer_outputs[MA_NP];
 +    int i,k;
 +
 +    for (i = 0; i < 10; i++) {
 +        int tmp = lsfq[i] << 15;
 +
 +        for (k = 0; k < MA_NP; k++)
 +            tmp -= past_quantizer_outputs[k][i] * cb_ma_predictor[ma_predictor_prev][k][i];
 +
 +        quantizer_output[i] = ((tmp >> 15) * cb_ma_predictor_sum_inv[ma_predictor_prev][i]) >> 12;
 +    }
 +}
 +
 +/**
 + * Constructs new excitation signal and applies phase filter to it
 + * @param[out] out constructed speech signal
 + * @param in original excitation signal
 + * @param fc_cur (2.13) original fixed-codebook vector
 + * @param gain_code (14.1) gain code
 + * @param subframe_size length of the subframe
 + */
 +static void g729d_get_new_exc(
 +        int16_t* out,
 +        const int16_t* in,
 +        const int16_t* fc_cur,
 +        int dstate,
 +        int gain_code,
 +        int subframe_size)
 +{
 +    int i;
 +    int16_t fc_new[SUBFRAME_SIZE];
 +
 +    ff_celp_convolve_circ(fc_new, fc_cur, phase_filter[dstate], subframe_size);
 +
 +    for(i=0; i<subframe_size; i++)
 +    {
 +        out[i]  = in[i];
 +        out[i] -= (gain_code * fc_cur[i] + 0x2000) >> 14;
 +        out[i] += (gain_code * fc_new[i] + 0x2000) >> 14;
 +    }
 +}
 +
 +/**
 + * Makes decision about onset in current subframe
 + * @param past_onset decision result of previous subframe
 + * @param past_gain_code gain code of current and previous subframe
 + *
 + * @return onset decision result for current subframe
 + */
 +static int g729d_onset_decision(int past_onset, const int16_t* past_gain_code)
 +{
 +    if((past_gain_code[0] >> 1) > past_gain_code[1])
 +        return 2;
 +    else
 +        return FFMAX(past_onset-1, 0);
 +}
 +
 +/**
 + * Makes decision about voice presence in current subframe
 + * @param onset onset level
 + * @param prev_voice_decision voice decision result from previous subframe
 + * @param past_gain_pitch pitch gain of current and previous subframes
 + *
 + * @return voice decision result for current subframe
 + */
 +static int16_t g729d_voice_decision(int onset, int prev_voice_decision, const int16_t* past_gain_pitch)
 +{
 +    int i, low_gain_pitch_cnt, voice_decision;
 +
 +    if(past_gain_pitch[0] >= 14745)      // 0.9
 +        voice_decision = DECISION_VOICE;
 +    else if (past_gain_pitch[0] <= 9830) // 0.6
 +        voice_decision = DECISION_NOISE;
 +    else
 +        voice_decision = DECISION_INTERMEDIATE;
 +
 +    for(i=0, low_gain_pitch_cnt=0; i<6; i++)
 +        if(past_gain_pitch[i] < 9830)
 +            low_gain_pitch_cnt++;
 +
 +    if(low_gain_pitch_cnt > 2 && !onset)
 +        voice_decision = DECISION_NOISE;
 +
 +    if(!onset && voice_decision > prev_voice_decision + 1)
 +        voice_decision--;
 +
 +    if(onset && voice_decision < DECISION_VOICE)
 +        voice_decision++;
 +
 +    return voice_decision;
 +}
 +
 +static int32_t scalarproduct_int16_c(const int16_t * v1, const int16_t * v2, int order)
 +{
 +    int res = 0;
 +
 +    while (order--)
 +        res += *v1++ * *v2++;
 +
 +    return res;
 +}
 +
 +static av_cold int decoder_init(AVCodecContext * avctx)
 +{
 +    G729Context* ctx = avctx->priv_data;
 +    int i,k;
 +
 +    if (avctx->channels != 1) {
 +        av_log(avctx, AV_LOG_ERROR, "Only mono sound is supported (requested channels: %d).\n", avctx->channels);
 +        return AVERROR(EINVAL);
 +    }
 +    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
 +
 +    /* Both 8kbit/s and 6.4kbit/s modes uses two subframes per frame. */
 +    avctx->frame_size = SUBFRAME_SIZE << 1;
 +
 +    ctx->gain_coeff = 16384; // 1.0 in (1.14)
 +
 +    for (k = 0; k < MA_NP + 1; k++) {
 +        ctx->past_quantizer_outputs[k] = ctx->past_quantizer_output_buf[k];
 +        for (i = 1; i < 11; i++)
 +            ctx->past_quantizer_outputs[k][i - 1] = (18717 * i) >> 3;
 +    }
 +
 +    ctx->lsp[0] = ctx->lsp_buf[0];
 +    ctx->lsp[1] = ctx->lsp_buf[1];
 +    memcpy(ctx->lsp[0], lsp_init, 10 * sizeof(int16_t));
 +
 +    ctx->exc = &ctx->exc_base[PITCH_DELAY_MAX+INTERPOL_LEN];
 +
 +    ctx->pitch_delay_int_prev = PITCH_DELAY_MIN;
 +
 +    /* random seed initialization */
 +    ctx->rand_value = 21845;
 +
 +    /* quantized prediction error */
 +    for(i=0; i<4; i++)
 +        ctx->quant_energy[i] = -14336; // -14 in (5.10)
 +
 +    ff_dsputil_init(&ctx->dsp, avctx);
 +    ctx->dsp.scalarproduct_int16 = scalarproduct_int16_c;
 +
 +    avcodec_get_frame_defaults(&ctx->frame);
 +    avctx->coded_frame = &ctx->frame;
 +
 +    return 0;
 +}
 +
 +static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame_ptr,
 +                        AVPacket *avpkt)
 +{
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size       = avpkt->size;
 +    int16_t *out_frame;
 +    GetBitContext gb;
 +    const G729FormatDescription *format;
 +    int frame_erasure = 0;    ///< frame erasure detected during decoding
 +    int bad_pitch = 0;        ///< parity check failed
 +    int i;
 +    int16_t *tmp;
 +    G729Formats packet_type;
 +    G729Context *ctx = avctx->priv_data;
 +    int16_t lp[2][11];           // (3.12)
 +    uint8_t ma_predictor;     ///< switched MA predictor of LSP quantizer
 +    uint8_t quantizer_1st;    ///< first stage vector of quantizer
 +    uint8_t quantizer_2nd_lo; ///< second stage lower vector of quantizer (size in bits)
 +    uint8_t quantizer_2nd_hi; ///< second stage higher vector of quantizer (size in bits)
 +
 +    int pitch_delay_int[2];      // pitch delay, integer part
 +    int pitch_delay_3x;          // pitch delay, multiplied by 3
 +    int16_t fc[SUBFRAME_SIZE];   // fixed-codebook vector
 +    int16_t synth[SUBFRAME_SIZE+10]; // fixed-codebook vector
 +    int j, ret;
 +    int gain_before, gain_after;
 +    int is_periodic = 0;         // whether one of the subframes is declared as periodic or not
 +
 +    ctx->frame.nb_samples = SUBFRAME_SIZE<<1;
++    if ((ret = ff_get_buffer(avctx, &ctx->frame)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
 +    }
 +    out_frame = (int16_t*) ctx->frame.data[0];
 +
 +    if (buf_size == 10) {
 +        packet_type = FORMAT_G729_8K;
 +        format = &format_g729_8k;
 +        //Reset voice decision
 +        ctx->onset = 0;
 +        ctx->voice_decision = DECISION_VOICE;
 +        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729 @ 8kbit/s");
 +    } else if (buf_size == 8) {
 +        packet_type = FORMAT_G729D_6K4;
 +        format = &format_g729d_6k4;
 +        av_log(avctx, AV_LOG_DEBUG, "Packet type: %s\n", "G.729D @ 6.4kbit/s");
 +    } else {
 +        av_log(avctx, AV_LOG_ERROR, "Packet size %d is unknown.\n", buf_size);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    for (i=0; i < buf_size; i++)
 +        frame_erasure |= buf[i];
 +    frame_erasure = !frame_erasure;
 +
 +    init_get_bits(&gb, buf, 8*buf_size);
 +
 +    ma_predictor     = get_bits(&gb, 1);
 +    quantizer_1st    = get_bits(&gb, VQ_1ST_BITS);
 +    quantizer_2nd_lo = get_bits(&gb, VQ_2ND_BITS);
 +    quantizer_2nd_hi = get_bits(&gb, VQ_2ND_BITS);
 +
 +    if(frame_erasure)
 +        lsf_restore_from_previous(ctx->lsfq, ctx->past_quantizer_outputs,
 +                                  ctx->ma_predictor_prev);
 +    else {
 +        lsf_decode(ctx->lsfq, ctx->past_quantizer_outputs,
 +                   ma_predictor,
 +                   quantizer_1st, quantizer_2nd_lo, quantizer_2nd_hi);
 +        ctx->ma_predictor_prev = ma_predictor;
 +    }
 +
 +    tmp = ctx->past_quantizer_outputs[MA_NP];
 +    memmove(ctx->past_quantizer_outputs + 1, ctx->past_quantizer_outputs,
 +            MA_NP * sizeof(int16_t*));
 +    ctx->past_quantizer_outputs[0] = tmp;
 +
 +    ff_acelp_lsf2lsp(ctx->lsp[1], ctx->lsfq, 10);
 +
 +    ff_acelp_lp_decode(&lp[0][0], &lp[1][0], ctx->lsp[1], ctx->lsp[0], 10);
 +
 +    FFSWAP(int16_t*, ctx->lsp[1], ctx->lsp[0]);
 +
 +    for (i = 0; i < 2; i++) {
 +        int gain_corr_factor;
 +
 +        uint8_t ac_index;      ///< adaptive codebook index
 +        uint8_t pulses_signs;  ///< fixed-codebook vector pulse signs
 +        int fc_indexes;        ///< fixed-codebook indexes
 +        uint8_t gc_1st_index;  ///< gain codebook (first stage) index
 +        uint8_t gc_2nd_index;  ///< gain codebook (second stage) index
 +
 +        ac_index      = get_bits(&gb, format->ac_index_bits[i]);
 +        if(!i && format->parity_bit)
 +            bad_pitch = get_parity(ac_index) == get_bits1(&gb);
 +        fc_indexes    = get_bits(&gb, format->fc_indexes_bits);
 +        pulses_signs  = get_bits(&gb, format->fc_signs_bits);
 +        gc_1st_index  = get_bits(&gb, format->gc_1st_index_bits);
 +        gc_2nd_index  = get_bits(&gb, format->gc_2nd_index_bits);
 +
 +        if (frame_erasure)
 +            pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
 +        else if(!i) {
 +            if (bad_pitch)
 +                pitch_delay_3x   = 3 * ctx->pitch_delay_int_prev;
 +            else
 +                pitch_delay_3x = ff_acelp_decode_8bit_to_1st_delay3(ac_index);
 +        } else {
 +            int pitch_delay_min = av_clip(ctx->pitch_delay_int_prev - 5,
 +                                          PITCH_DELAY_MIN, PITCH_DELAY_MAX - 9);
 +
 +            if(packet_type == FORMAT_G729D_6K4)
 +                pitch_delay_3x = ff_acelp_decode_4bit_to_2nd_delay3(ac_index, pitch_delay_min);
 +            else
 +                pitch_delay_3x = ff_acelp_decode_5_6_bit_to_2nd_delay3(ac_index, pitch_delay_min);
 +        }
 +
 +        /* Round pitch delay to nearest (used everywhere except ff_acelp_interpolate). */
 +        pitch_delay_int[i]  = (pitch_delay_3x + 1) / 3;
 +
 +        if (frame_erasure) {
 +            ctx->rand_value = g729_prng(ctx->rand_value);
 +            fc_indexes   = ctx->rand_value & ((1 << format->fc_indexes_bits) - 1);
 +
 +            ctx->rand_value = g729_prng(ctx->rand_value);
 +            pulses_signs = ctx->rand_value;
 +        }
 +
 +
 +        memset(fc, 0, sizeof(int16_t) * SUBFRAME_SIZE);
 +        switch (packet_type) {
 +            case FORMAT_G729_8K:
 +                ff_acelp_fc_pulse_per_track(fc, ff_fc_4pulses_8bits_tracks_13,
 +                                            ff_fc_4pulses_8bits_track_4,
 +                                            fc_indexes, pulses_signs, 3, 3);
 +                break;
 +            case FORMAT_G729D_6K4:
 +                ff_acelp_fc_pulse_per_track(fc, ff_fc_2pulses_9bits_track1_gray,
 +                                            ff_fc_2pulses_9bits_track2_gray,
 +                                            fc_indexes, pulses_signs, 1, 4);
 +                break;
 +        }
 +
 +        /*
 +          This filter enhances harmonic components of the fixed-codebook vector to
 +          improve the quality of the reconstructed speech.
 +
 +                     / fc_v[i],                                    i < pitch_delay
 +          fc_v[i] = <
 +                     \ fc_v[i] + gain_pitch * fc_v[i-pitch_delay], i >= pitch_delay
 +        */
 +        ff_acelp_weighted_vector_sum(fc + pitch_delay_int[i],
 +                                     fc + pitch_delay_int[i],
 +                                     fc, 1 << 14,
 +                                     av_clip(ctx->past_gain_pitch[0], SHARP_MIN, SHARP_MAX),
 +                                     0, 14,
 +                                     SUBFRAME_SIZE - pitch_delay_int[i]);
 +
 +        memmove(ctx->past_gain_pitch+1, ctx->past_gain_pitch, 5 * sizeof(int16_t));
 +        ctx->past_gain_code[1] = ctx->past_gain_code[0];
 +
 +        if (frame_erasure) {
 +            ctx->past_gain_pitch[0] = (29491 * ctx->past_gain_pitch[0]) >> 15; // 0.90 (0.15)
 +            ctx->past_gain_code[0]  = ( 2007 * ctx->past_gain_code[0] ) >> 11; // 0.98 (0.11)
 +
 +            gain_corr_factor = 0;
 +        } else {
 +            if (packet_type == FORMAT_G729D_6K4) {
 +                ctx->past_gain_pitch[0]  = cb_gain_1st_6k4[gc_1st_index][0] +
 +                                           cb_gain_2nd_6k4[gc_2nd_index][0];
 +                gain_corr_factor = cb_gain_1st_6k4[gc_1st_index][1] +
 +                                   cb_gain_2nd_6k4[gc_2nd_index][1];
 +
 +                /* Without check below overflow can occur in ff_acelp_update_past_gain.
 +                   It is not issue for G.729, because gain_corr_factor in it's case is always
 +                   greater than 1024, while in G.729D it can be even zero. */
 +                gain_corr_factor = FFMAX(gain_corr_factor, 1024);
 +#ifndef G729_BITEXACT
 +                gain_corr_factor >>= 1;
 +#endif
 +            } else {
 +                ctx->past_gain_pitch[0]  = cb_gain_1st_8k[gc_1st_index][0] +
 +                                           cb_gain_2nd_8k[gc_2nd_index][0];
 +                gain_corr_factor = cb_gain_1st_8k[gc_1st_index][1] +
 +                                   cb_gain_2nd_8k[gc_2nd_index][1];
 +            }
 +
 +            /* Decode the fixed-codebook gain. */
 +            ctx->past_gain_code[0] = ff_acelp_decode_gain_code(&ctx->dsp, gain_corr_factor,
 +                                                               fc, MR_ENERGY,
 +                                                               ctx->quant_energy,
 +                                                               ma_prediction_coeff,
 +                                                               SUBFRAME_SIZE, 4);
 +#ifdef G729_BITEXACT
 +            /*
 +              This correction required to get bit-exact result with
 +              reference code, because gain_corr_factor in G.729D is
 +              two times larger than in original G.729.
 +
 +              If bit-exact result is not issue then gain_corr_factor
 +              can be simpler divided by 2 before call to g729_get_gain_code
 +              instead of using correction below.
 +            */
 +            if (packet_type == FORMAT_G729D_6K4) {
 +                gain_corr_factor >>= 1;
 +                ctx->past_gain_code[0] >>= 1;
 +            }
 +#endif
 +        }
 +        ff_acelp_update_past_gain(ctx->quant_energy, gain_corr_factor, 2, frame_erasure);
 +
 +        /* Routine requires rounding to lowest. */
 +        ff_acelp_interpolate(ctx->exc + i * SUBFRAME_SIZE,
 +                             ctx->exc + i * SUBFRAME_SIZE - pitch_delay_3x / 3,
 +                             ff_acelp_interp_filter, 6,
 +                             (pitch_delay_3x % 3) << 1,
 +                             10, SUBFRAME_SIZE);
 +
 +        ff_acelp_weighted_vector_sum(ctx->exc + i * SUBFRAME_SIZE,
 +                                     ctx->exc + i * SUBFRAME_SIZE, fc,
 +                                     (!ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_pitch[0],
 +                                     ( ctx->was_periodic && frame_erasure) ? 0 : ctx->past_gain_code[0],
 +                                     1 << 13, 14, SUBFRAME_SIZE);
 +
 +        memcpy(synth, ctx->syn_filter_data, 10 * sizeof(int16_t));
 +
 +        if (ff_celp_lp_synthesis_filter(
 +            synth+10,
 +            &lp[i][1],
 +            ctx->exc  + i * SUBFRAME_SIZE,
 +            SUBFRAME_SIZE,
 +            10,
 +            1,
 +            0,
 +            0x800))
 +            /* Overflow occurred, downscale excitation signal... */
 +            for (j = 0; j < 2 * SUBFRAME_SIZE + PITCH_DELAY_MAX + INTERPOL_LEN; j++)
 +                ctx->exc_base[j] >>= 2;
 +
 +        /* ... and make synthesis again. */
 +        if (packet_type == FORMAT_G729D_6K4) {
 +            int16_t exc_new[SUBFRAME_SIZE];
 +
 +            ctx->onset = g729d_onset_decision(ctx->onset, ctx->past_gain_code);
 +            ctx->voice_decision = g729d_voice_decision(ctx->onset, ctx->voice_decision, ctx->past_gain_pitch);
 +
 +            g729d_get_new_exc(exc_new, ctx->exc  + i * SUBFRAME_SIZE, fc, ctx->voice_decision, ctx->past_gain_code[0], SUBFRAME_SIZE);
 +
 +            ff_celp_lp_synthesis_filter(
 +                    synth+10,
 +                    &lp[i][1],
 +                    exc_new,
 +                    SUBFRAME_SIZE,
 +                    10,
 +                    0,
 +                    0,
 +                    0x800);
 +        } else {
 +            ff_celp_lp_synthesis_filter(
 +                    synth+10,
 +                    &lp[i][1],
 +                    ctx->exc  + i * SUBFRAME_SIZE,
 +                    SUBFRAME_SIZE,
 +                    10,
 +                    0,
 +                    0,
 +                    0x800);
 +        }
 +        /* Save data (without postfilter) for use in next subframe. */
 +        memcpy(ctx->syn_filter_data, synth+SUBFRAME_SIZE, 10 * sizeof(int16_t));
 +
 +        /* Calculate gain of unfiltered signal for use in AGC. */
 +        gain_before = 0;
 +        for (j = 0; j < SUBFRAME_SIZE; j++)
 +            gain_before += FFABS(synth[j+10]);
 +
 +        /* Call postfilter and also update voicing decision for use in next frame. */
 +        ff_g729_postfilter(
 +                &ctx->dsp,
 +                &ctx->ht_prev_data,
 +                &is_periodic,
 +                &lp[i][0],
 +                pitch_delay_int[0],
 +                ctx->residual,
 +                ctx->res_filter_data,
 +                ctx->pos_filter_data,
 +                synth+10,
 +                SUBFRAME_SIZE);
 +
 +        /* Calculate gain of filtered signal for use in AGC. */
 +        gain_after = 0;
 +        for(j=0; j<SUBFRAME_SIZE; j++)
 +            gain_after += FFABS(synth[j+10]);
 +
 +        ctx->gain_coeff = ff_g729_adaptive_gain_control(
 +                gain_before,
 +                gain_after,
 +                synth+10,
 +                SUBFRAME_SIZE,
 +                ctx->gain_coeff);
 +
 +        if (frame_erasure)
 +            ctx->pitch_delay_int_prev = FFMIN(ctx->pitch_delay_int_prev + 1, PITCH_DELAY_MAX);
 +        else
 +            ctx->pitch_delay_int_prev = pitch_delay_int[i];
 +
 +        memcpy(synth+8, ctx->hpf_z, 2*sizeof(int16_t));
 +        ff_acelp_high_pass_filter(
 +                out_frame + i*SUBFRAME_SIZE,
 +                ctx->hpf_f,
 +                synth+10,
 +                SUBFRAME_SIZE);
 +        memcpy(ctx->hpf_z, synth+8+SUBFRAME_SIZE, 2*sizeof(int16_t));
 +    }
 +
 +    ctx->was_periodic = is_periodic;
 +
 +    /* Save signal for use in next frame. */
 +    memmove(ctx->exc_base, ctx->exc_base + 2 * SUBFRAME_SIZE, (PITCH_DELAY_MAX+INTERPOL_LEN)*sizeof(int16_t));
 +
 +    *got_frame_ptr = 1;
 +    *(AVFrame*)data = ctx->frame;
 +    return buf_size;
 +}
 +
 +AVCodec ff_g729_decoder = {
 +    .name           = "g729",
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = AV_CODEC_ID_G729,
 +    .priv_data_size = sizeof(G729Context),
 +    .init           = decoder_init,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("G.729"),
 +};
  //#define DEBUG
  
  #include "libavutil/imgutils.h"
 +#include "libavutil/opt.h"
  #include "avcodec.h"
  #include "bytestream.h"
+ #include "internal.h"
  #include "lzw.h"
 +#include "gif.h"
  
 -#define GCE_DISPOSAL_NONE       0
 -#define GCE_DISPOSAL_INPLACE    1
 -#define GCE_DISPOSAL_BACKGROUND 2
 -#define GCE_DISPOSAL_RESTORE    3
 +/* This value is intentionally set to "transparent white" color.
 + * It is much better to have white background instead of black
 + * when gif image converted to format which not support transparency.
 + */
 +#define GIF_TRANSPARENT_COLOR    0x00ffffff
  
  typedef struct GifState {
 +    const AVClass *class;
      AVFrame picture;
      int screen_width;
      int screen_height;
@@@ -461,55 -290,29 +462,55 @@@ static int gif_decode_frame(AVCodecCont
      AVFrame *picture = data;
      int ret;
  
 +    s->picture.pts          = avpkt->pts;
 +    s->picture.pkt_pts      = avpkt->pts;
 +    s->picture.pkt_dts      = avpkt->dts;
 +    s->picture.pkt_duration = avpkt->duration;
 +
      s->bytestream = buf;
      s->bytestream_end = buf + buf_size;
 -    if (gif_read_header1(s) < 0)
 -        return -1;
  
 -    avctx->pix_fmt = AV_PIX_FMT_PAL8;
 -    if (av_image_check_size(s->screen_width, s->screen_height, 0, avctx))
 -        return -1;
 -    avcodec_set_dimensions(avctx, s->screen_width, s->screen_height);
 +    if (buf_size >= 6) {
 +        s->keyframe = memcmp(s->bytestream, gif87a_sig, 6) == 0 ||
 +                      memcmp(s->bytestream, gif89a_sig, 6) == 0;
 +    } else {
 +        s->keyframe = 0;
 +    }
  
 -    if (s->picture.data[0])
 -        avctx->release_buffer(avctx, &s->picture);
 -    if (ff_get_buffer(avctx, &s->picture) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -        return -1;
 +    if (s->keyframe) {
 +        if ((ret = gif_read_header1(s)) < 0)
 +            return ret;
 +
 +        if ((ret = av_image_check_size(s->screen_width, s->screen_height, 0, avctx)) < 0)
 +            return ret;
 +        avcodec_set_dimensions(avctx, s->screen_width, s->screen_height);
 +
 +        if (s->picture.data[0])
 +            avctx->release_buffer(avctx, &s->picture);
 +
-         if ((ret = avctx->get_buffer(avctx, &s->picture)) < 0) {
++        if ((ret = ff_get_buffer(avctx, &s->picture)) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +            return ret;
 +        }
 +
 +        s->picture.pict_type = AV_PICTURE_TYPE_I;
 +        s->picture.key_frame = 1;
 +    } else {
 +        if ((ret = avctx->reget_buffer(avctx, &s->picture)) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
 +            return ret;
 +        }
 +
 +        s->picture.pict_type = AV_PICTURE_TYPE_P;
 +        s->picture.key_frame = 0;
      }
 -    s->image_palette = (uint32_t *)s->picture.data[1];
 -    ret = gif_parse_next_image(s);
 +
 +    ret = gif_parse_next_image(s, got_picture);
      if (ret < 0)
          return ret;
 +    else if (*got_picture)
 +        *picture = s->picture;
  
 -    *picture = s->picture;
 -    *data_size = sizeof(AVPicture);
      return s->bytestream - buf;
  }
  
Simple merge
@@@ -227,13 -224,12 +228,13 @@@ static int idcin_decode_frame(AVCodecCo
      if (s->frame.data[0])
          avctx->release_buffer(avctx, &s->frame);
  
-     if ((ret = avctx->get_buffer(avctx, &s->frame))) {
 -    if (ff_get_buffer(avctx, &s->frame)) {
 -        av_log(avctx, AV_LOG_ERROR, "  id CIN Video: get_buffer() failed\n");
 -        return -1;
++    if ((ret = ff_get_buffer(avctx, &s->frame))) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
      }
  
 -    idcin_decode_vlcs(s);
 +    if (idcin_decode_vlcs(s))
 +        return AVERROR_INVALIDDATA;
  
      if (pal) {
          s->frame.palette_has_changed = 1;
  #include "bytestream.h"
  #include "avcodec.h"
  #include "get_bits.h"
+ #include "internal.h"
  
 +// TODO: masking bits
 +typedef enum {
 +    MASK_NONE,
 +    MASK_HAS_MASK,
 +    MASK_HAS_TRANSPARENT_COLOR,
 +    MASK_LASSO
 +} mask_type;
 +
  typedef struct {
      AVFrame frame;
      int planesize;
@@@ -606,15 -318,12 +607,15 @@@ static int decode_frame(AVCodecContext 
              av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
              return res;
          }
-     } else if ((res = avctx->get_buffer(avctx, &s->frame)) < 0) {
+     } else if ((res = ff_get_buffer(avctx, &s->frame)) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return res;
 -    } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt != AV_PIX_FMT_GRAY8) {
 +    } else if (avctx->bits_per_coded_sample <= 8 && avctx->pix_fmt == AV_PIX_FMT_PAL8) {
          if ((res = ff_cmap_read_palette(avctx, (uint32_t*)s->frame.data[1])) < 0)
              return res;
 +    } else if (avctx->pix_fmt == AV_PIX_FMT_RGB32 && avctx->bits_per_coded_sample <= 8) {
 +        if ((res = ff_cmap_read_palette(avctx, s->mask_palbuf)) < 0)
 +            return res;
      }
      s->init = 1;
  
Simple merge
@@@ -1084,15 -1056,6 +1085,15 @@@ static int decode_frame(AVCodecContext 
      /* use BS_BUFFER flag for buffer switching */
      ctx->buf_sel = (ctx->frame_flags >> BS_BUFFER) & 1;
  
-     if ((res = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
 +    if (ctx->frame.data[0])
 +        avctx->release_buffer(avctx, &ctx->frame);
 +
 +    ctx->frame.reference = 0;
++    if ((res = ff_get_buffer(avctx, &ctx->frame)) < 0) {
 +        av_log(ctx->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return res;
 +    }
 +
      /* decode luma plane */
      if ((res = decode_plane(ctx, avctx, ctx->planes, ctx->y_data_ptr, ctx->y_data_size, 40)))
          return res;
@@@ -169,22 -141,11 +169,29 @@@ static av_always_inline int64_t ff_samp
                          avctx->time_base);
  }
  
+ /**
+  * Get a buffer for a frame. This is a wrapper around
+  * AVCodecContext.get_buffer() and should be used instead calling get_buffer()
+  * directly.
+  */
+ int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame);
 +int ff_thread_can_start_frame(AVCodecContext *avctx);
 +
 +int ff_get_logical_cpus(AVCodecContext *avctx);
 +
 +int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx);
 +
 +/**
 + * Call avcodec_open2 recursively by decrementing counter, unlocking mutex,
 + * calling the function and then restoring again. Assumes the mutex is
 + * already locked
 + */
 +int ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
 +
 +/**
 + * Call avcodec_close recursively, counterpart to avcodec_open2_recursive.
 + */
 +int ff_codec_close_recursive(AVCodecContext *avctx);
 +
  #endif /* AVCODEC_INTERNAL_H */
@@@ -976,8 -973,8 +977,8 @@@ static int ipvideo_decode_frame(AVCodec
                       buf_size - s->decoding_map_size);
  
      s->current_frame.reference = 3;
-     if (avctx->get_buffer(avctx, &s->current_frame)) {
+     if (ff_get_buffer(avctx, &s->current_frame)) {
 -        av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
          return -1;
      }
  
Simple merge
index de94f51,0000000..a9b4ccf
mode 100644,000000..100644
--- /dev/null
@@@ -1,1106 -1,0 +1,1107 @@@
-     if ((ret = s->avctx->get_buffer(s->avctx, &s->picture)) < 0)
 +/*
 + * JPEG2000 image decoder
 + * Copyright (c) 2007 Kamil Nowosad
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * JPEG2000 image decoder
 + * @file
 + * @author Kamil Nowosad
 + */
 +
 +// #define DEBUG
 +
 +#include "avcodec.h"
 +#include "bytestream.h"
++#include "internal.h"
 +#include "j2k.h"
 +#include "libavutil/common.h"
 +
 +#define JP2_SIG_TYPE    0x6A502020
 +#define JP2_SIG_VALUE   0x0D0A870A
 +#define JP2_CODESTREAM  0x6A703263
 +
 +#define HAD_COC 0x01
 +#define HAD_QCC 0x02
 +
 +typedef struct {
 +   J2kComponent *comp;
 +   uint8_t properties[4];
 +   J2kCodingStyle codsty[4];
 +   J2kQuantStyle  qntsty[4];
 +} J2kTile;
 +
 +typedef struct {
 +    AVCodecContext *avctx;
 +    AVFrame picture;
 +    GetByteContext g;
 +
 +    int width, height; ///< image width and height
 +    int image_offset_x, image_offset_y;
 +    int tile_offset_x, tile_offset_y;
 +    uint8_t cbps[4]; ///< bits per sample in particular components
 +    uint8_t sgnd[4]; ///< if a component is signed
 +    uint8_t properties[4];
 +    int cdx[4], cdy[4];
 +    int precision;
 +    int ncomponents;
 +    int tile_width, tile_height; ///< tile size
 +    int numXtiles, numYtiles;
 +    int maxtilelen;
 +
 +    J2kCodingStyle codsty[4];
 +    J2kQuantStyle  qntsty[4];
 +
 +    int bit_index;
 +
 +    int curtileno;
 +
 +    J2kTile *tile;
 +} J2kDecoderContext;
 +
 +static int get_bits(J2kDecoderContext *s, int n)
 +{
 +    int res = 0;
 +
 +    while (--n >= 0){
 +        res <<= 1;
 +        if (s->bit_index == 0) {
 +            s->bit_index = 7 + (bytestream2_get_byte(&s->g) != 0xFFu);
 +        }
 +        s->bit_index--;
 +        res |= (bytestream2_peek_byte(&s->g) >> s->bit_index) & 1;
 +    }
 +    return res;
 +}
 +
 +static void j2k_flush(J2kDecoderContext *s)
 +{
 +    if (bytestream2_get_byte(&s->g) == 0xff)
 +        bytestream2_skip(&s->g, 1);
 +    s->bit_index = 8;
 +}
 +#if 0
 +void printcomp(J2kComponent *comp)
 +{
 +    int i;
 +    for (i = 0; i < comp->y1 - comp->y0; i++)
 +        ff_j2k_printv(comp->data + i * (comp->x1 - comp->x0), comp->x1 - comp->x0);
 +}
 +
 +static void nspaces(FILE *fd, int n)
 +{
 +    while(n--) putc(' ', fd);
 +}
 +
 +static void dump(J2kDecoderContext *s, FILE *fd)
 +{
 +    int tileno, compno, reslevelno, bandno, precno;
 +    fprintf(fd, "XSiz = %d, YSiz = %d, tile_width = %d, tile_height = %d\n"
 +                "numXtiles = %d, numYtiles = %d, ncomponents = %d\n"
 +                "tiles:\n",
 +            s->width, s->height, s->tile_width, s->tile_height,
 +            s->numXtiles, s->numYtiles, s->ncomponents);
 +    for (tileno = 0; tileno < s->numXtiles * s->numYtiles; tileno++){
 +        J2kTile *tile = s->tile + tileno;
 +        nspaces(fd, 2);
 +        fprintf(fd, "tile %d:\n", tileno);
 +        for(compno = 0; compno < s->ncomponents; compno++){
 +            J2kComponent *comp = tile->comp + compno;
 +            nspaces(fd, 4);
 +            fprintf(fd, "component %d:\n", compno);
 +            nspaces(fd, 4);
 +            fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d\n",
 +                        comp->x0, comp->x1, comp->y0, comp->y1);
 +            for(reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++){
 +                J2kResLevel *reslevel = comp->reslevel + reslevelno;
 +                nspaces(fd, 6);
 +                fprintf(fd, "reslevel %d:\n", reslevelno);
 +                nspaces(fd, 6);
 +                fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d, nbands = %d\n",
 +                        reslevel->x0, reslevel->x1, reslevel->y0,
 +                        reslevel->y1, reslevel->nbands);
 +                for(bandno = 0; bandno < reslevel->nbands; bandno++){
 +                    J2kBand *band = reslevel->band + bandno;
 +                    nspaces(fd, 8);
 +                    fprintf(fd, "band %d:\n", bandno);
 +                    nspaces(fd, 8);
 +                    fprintf(fd, "x0 = %d, x1 = %d, y0 = %d, y1 = %d,"
 +                                "codeblock_width = %d, codeblock_height = %d cblknx = %d cblkny = %d\n",
 +                                band->x0, band->x1,
 +                                band->y0, band->y1,
 +                                band->codeblock_width, band->codeblock_height,
 +                                band->cblknx, band->cblkny);
 +                    for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++){
 +                        J2kPrec *prec = band->prec + precno;
 +                        nspaces(fd, 10);
 +                        fprintf(fd, "prec %d:\n", precno);
 +                        nspaces(fd, 10);
 +                        fprintf(fd, "xi0 = %d, xi1 = %d, yi0 = %d, yi1 = %d\n",
 +                                     prec->xi0, prec->xi1, prec->yi0, prec->yi1);
 +                    }
 +                }
 +            }
 +        }
 +    }
 +}
 +#endif
 +
 +/** decode the value stored in node */
 +static int tag_tree_decode(J2kDecoderContext *s, J2kTgtNode *node, int threshold)
 +{
 +    J2kTgtNode *stack[30];
 +    int sp = -1, curval = 0;
 +
 +    if(!node)
 +        return AVERROR(EINVAL);
 +
 +    while(node && !node->vis){
 +        stack[++sp] = node;
 +        node = node->parent;
 +    }
 +
 +    if (node)
 +        curval = node->val;
 +    else
 +        curval = stack[sp]->val;
 +
 +    while(curval < threshold && sp >= 0){
 +        if (curval < stack[sp]->val)
 +            curval = stack[sp]->val;
 +        while (curval < threshold){
 +            int ret;
 +            if ((ret = get_bits(s, 1)) > 0){
 +                stack[sp]->vis++;
 +                break;
 +            } else if (!ret)
 +                curval++;
 +            else
 +                return ret;
 +        }
 +        stack[sp]->val = curval;
 +        sp--;
 +    }
 +    return curval;
 +}
 +
 +/* marker segments */
 +/** get sizes and offsets of image, tiles; number of components */
 +static int get_siz(J2kDecoderContext *s)
 +{
 +    int i, ret;
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 36)
 +        return AVERROR(EINVAL);
 +
 +                        bytestream2_get_be16u(&s->g); // Rsiz (skipped)
 +             s->width = bytestream2_get_be32u(&s->g); // width
 +            s->height = bytestream2_get_be32u(&s->g); // height
 +    s->image_offset_x = bytestream2_get_be32u(&s->g); // X0Siz
 +    s->image_offset_y = bytestream2_get_be32u(&s->g); // Y0Siz
 +
 +        s->tile_width = bytestream2_get_be32u(&s->g); // XTSiz
 +       s->tile_height = bytestream2_get_be32u(&s->g); // YTSiz
 +     s->tile_offset_x = bytestream2_get_be32u(&s->g); // XT0Siz
 +     s->tile_offset_y = bytestream2_get_be32u(&s->g); // YT0Siz
 +       s->ncomponents = bytestream2_get_be16u(&s->g); // CSiz
 +
 +    if(s->ncomponents <= 0 || s->ncomponents > 4) {
 +        av_log(s->avctx, AV_LOG_ERROR, "unsupported/invalid ncomponents: %d\n", s->ncomponents);
 +        return AVERROR(EINVAL);
 +    }
 +    if(s->tile_width<=0 || s->tile_height<=0)
 +        return AVERROR(EINVAL);
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 3 * s->ncomponents)
 +        return AVERROR(EINVAL);
 +
 +    for (i = 0; i < s->ncomponents; i++){ // Ssiz_i XRsiz_i, YRsiz_i
 +        uint8_t x = bytestream2_get_byteu(&s->g);
 +        s->cbps[i] = (x & 0x7f) + 1;
 +        s->precision = FFMAX(s->cbps[i], s->precision);
 +        s->sgnd[i] = !!(x & 0x80);
 +        s->cdx[i] = bytestream2_get_byteu(&s->g);
 +        s->cdy[i] = bytestream2_get_byteu(&s->g);
 +    }
 +
 +    s->numXtiles = ff_j2k_ceildiv(s->width - s->tile_offset_x, s->tile_width);
 +    s->numYtiles = ff_j2k_ceildiv(s->height - s->tile_offset_y, s->tile_height);
 +
 +    if(s->numXtiles * (uint64_t)s->numYtiles > INT_MAX/sizeof(J2kTile))
 +        return AVERROR(EINVAL);
 +
 +    s->tile = av_mallocz(s->numXtiles * s->numYtiles * sizeof(J2kTile));
 +    if (!s->tile)
 +        return AVERROR(ENOMEM);
 +
 +    for (i = 0; i < s->numXtiles * s->numYtiles; i++){
 +        J2kTile *tile = s->tile + i;
 +
 +        tile->comp = av_mallocz(s->ncomponents * sizeof(J2kComponent));
 +        if (!tile->comp)
 +            return AVERROR(ENOMEM);
 +    }
 +
 +    s->avctx->width  = s->width  - s->image_offset_x;
 +    s->avctx->height = s->height - s->image_offset_y;
 +
 +    switch(s->ncomponents){
 +    case 1:
 +        if (s->precision > 8) {
 +            s->avctx->pix_fmt = AV_PIX_FMT_GRAY16;
 +        } else {
 +            s->avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 +        }
 +        break;
 +    case 3:
 +        if (s->precision > 8) {
 +            s->avctx->pix_fmt = AV_PIX_FMT_RGB48;
 +        } else {
 +            s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
 +        }
 +        break;
 +    case 4:
 +        s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
 +        break;
 +    }
 +
 +    if (s->picture.data[0])
 +        s->avctx->release_buffer(s->avctx, &s->picture);
 +
++    if ((ret = ff_get_buffer(s->avctx, &s->picture)) < 0)
 +        return ret;
 +
 +    s->picture.pict_type = AV_PICTURE_TYPE_I;
 +    s->picture.key_frame = 1;
 +
 +    return 0;
 +}
 +
 +/** get common part for COD and COC segments */
 +static int get_cox(J2kDecoderContext *s, J2kCodingStyle *c)
 +{
 +    if (bytestream2_get_bytes_left(&s->g) < 5)
 +        return AVERROR(EINVAL);
 +          c->nreslevels = bytestream2_get_byteu(&s->g) + 1; // num of resolution levels - 1
 +     c->log2_cblk_width = bytestream2_get_byteu(&s->g) + 2; // cblk width
 +    c->log2_cblk_height = bytestream2_get_byteu(&s->g) + 2; // cblk height
 +
 +    c->cblk_style = bytestream2_get_byteu(&s->g);
 +    if (c->cblk_style != 0){ // cblk style
 +        av_log(s->avctx, AV_LOG_WARNING, "extra cblk styles %X\n", c->cblk_style);
 +    }
 +    c->transform = bytestream2_get_byteu(&s->g); // transformation
 +    if (c->csty & J2K_CSTY_PREC) {
 +        int i;
 +
 +        for (i = 0; i < c->nreslevels; i++)
 +            bytestream2_get_byte(&s->g);
 +    }
 +    return 0;
 +}
 +
 +/** get coding parameters for a particular tile or whole image*/
 +static int get_cod(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
 +{
 +    J2kCodingStyle tmp;
 +    int compno;
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 5)
 +        return AVERROR(EINVAL);
 +
 +    tmp.log2_prec_width  =
 +    tmp.log2_prec_height = 15;
 +
 +    tmp.csty = bytestream2_get_byteu(&s->g);
 +
 +    if (bytestream2_get_byteu(&s->g)){ // progression level
 +        av_log(s->avctx, AV_LOG_ERROR, "only LRCP progression supported\n");
 +        return -1;
 +    }
 +
 +    tmp.nlayers = bytestream2_get_be16u(&s->g);
 +        tmp.mct = bytestream2_get_byteu(&s->g); // multiple component transformation
 +
 +    get_cox(s, &tmp);
 +    for (compno = 0; compno < s->ncomponents; compno++){
 +        if (!(properties[compno] & HAD_COC))
 +            memcpy(c + compno, &tmp, sizeof(J2kCodingStyle));
 +    }
 +    return 0;
 +}
 +
 +/** get coding parameters for a component in the whole image on a particular tile */
 +static int get_coc(J2kDecoderContext *s, J2kCodingStyle *c, uint8_t *properties)
 +{
 +    int compno;
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 2)
 +        return AVERROR(EINVAL);
 +
 +    compno = bytestream2_get_byteu(&s->g);
 +
 +    c += compno;
 +    c->csty = bytestream2_get_byte(&s->g);
 +    get_cox(s, c);
 +
 +    properties[compno] |= HAD_COC;
 +    return 0;
 +}
 +
 +/** get common part for QCD and QCC segments */
 +static int get_qcx(J2kDecoderContext *s, int n, J2kQuantStyle *q)
 +{
 +    int i, x;
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 1)
 +        return AVERROR(EINVAL);
 +
 +    x = bytestream2_get_byteu(&s->g); // Sqcd
 +
 +    q->nguardbits = x >> 5;
 +      q->quantsty = x & 0x1f;
 +
 +    if (q->quantsty == J2K_QSTY_NONE){
 +        n -= 3;
 +        if (bytestream2_get_bytes_left(&s->g) < n || 32*3 < n)
 +            return AVERROR(EINVAL);
 +        for (i = 0; i < n; i++)
 +            q->expn[i] = bytestream2_get_byteu(&s->g) >> 3;
 +    } else if (q->quantsty == J2K_QSTY_SI){
 +        if (bytestream2_get_bytes_left(&s->g) < 2)
 +            return AVERROR(EINVAL);
 +        x = bytestream2_get_be16u(&s->g);
 +        q->expn[0] = x >> 11;
 +        q->mant[0] = x & 0x7ff;
 +        for (i = 1; i < 32 * 3; i++){
 +            int curexpn = FFMAX(0, q->expn[0] - (i-1)/3);
 +            q->expn[i] = curexpn;
 +            q->mant[i] = q->mant[0];
 +        }
 +    } else{
 +        n = (n - 3) >> 1;
 +        if (bytestream2_get_bytes_left(&s->g) < 2 * n || 32*3 < n)
 +            return AVERROR(EINVAL);
 +        for (i = 0; i < n; i++){
 +            x = bytestream2_get_be16u(&s->g);
 +            q->expn[i] = x >> 11;
 +            q->mant[i] = x & 0x7ff;
 +        }
 +    }
 +    return 0;
 +}
 +
 +/** get quantization parameters for a particular tile or a whole image */
 +static int get_qcd(J2kDecoderContext *s, int n, J2kQuantStyle *q, uint8_t *properties)
 +{
 +    J2kQuantStyle tmp;
 +    int compno;
 +
 +    if (get_qcx(s, n, &tmp))
 +        return -1;
 +    for (compno = 0; compno < s->ncomponents; compno++)
 +        if (!(properties[compno] & HAD_QCC))
 +            memcpy(q + compno, &tmp, sizeof(J2kQuantStyle));
 +    return 0;
 +}
 +
 +/** get quantization parameters for a component in the whole image on in a particular tile */
 +static int get_qcc(J2kDecoderContext *s, int n, J2kQuantStyle *q, uint8_t *properties)
 +{
 +    int compno;
 +
 +    if (bytestream2_get_bytes_left(&s->g) < 1)
 +        return AVERROR(EINVAL);
 +
 +    compno = bytestream2_get_byteu(&s->g);
 +    properties[compno] |= HAD_QCC;
 +    return get_qcx(s, n-1, q+compno);
 +}
 +
 +/** get start of tile segment */
 +static uint8_t get_sot(J2kDecoderContext *s)
 +{
 +    if (bytestream2_get_bytes_left(&s->g) < 8)
 +        return AVERROR(EINVAL);
 +
 +    s->curtileno = bytestream2_get_be16u(&s->g); ///< Isot
 +    if((unsigned)s->curtileno >= s->numXtiles * s->numYtiles){
 +        s->curtileno=0;
 +        return AVERROR(EINVAL);
 +    }
 +
 +    bytestream2_skipu(&s->g, 4); ///< Psot (ignored)
 +
 +    if (!bytestream2_get_byteu(&s->g)){ ///< TPsot
 +        J2kTile *tile = s->tile + s->curtileno;
 +
 +        /* copy defaults */
 +        memcpy(tile->codsty, s->codsty, s->ncomponents * sizeof(J2kCodingStyle));
 +        memcpy(tile->qntsty, s->qntsty, s->ncomponents * sizeof(J2kQuantStyle));
 +    }
 +    bytestream2_get_byteu(&s->g); ///< TNsot
 +
 +    return 0;
 +}
 +
 +static int init_tile(J2kDecoderContext *s, int tileno)
 +{
 +    int compno,
 +        tilex = tileno % s->numXtiles,
 +        tiley = tileno / s->numXtiles;
 +    J2kTile *tile = s->tile + tileno;
 +
 +    if (!tile->comp)
 +        return AVERROR(ENOMEM);
 +    for (compno = 0; compno < s->ncomponents; compno++){
 +        J2kComponent *comp = tile->comp + compno;
 +        J2kCodingStyle *codsty = tile->codsty + compno;
 +        J2kQuantStyle  *qntsty = tile->qntsty + compno;
 +        int ret; // global bandno
 +
 +        comp->coord[0][0] = FFMAX(tilex * s->tile_width + s->tile_offset_x, s->image_offset_x);
 +        comp->coord[0][1] = FFMIN((tilex+1)*s->tile_width + s->tile_offset_x, s->width);
 +        comp->coord[1][0] = FFMAX(tiley * s->tile_height + s->tile_offset_y, s->image_offset_y);
 +        comp->coord[1][1] = FFMIN((tiley+1)*s->tile_height + s->tile_offset_y, s->height);
 +
 +        if (ret = ff_j2k_init_component(comp, codsty, qntsty, s->cbps[compno], s->cdx[compno], s->cdy[compno]))
 +            return ret;
 +    }
 +    return 0;
 +}
 +
 +/** read the number of coding passes */
 +static int getnpasses(J2kDecoderContext *s)
 +{
 +    int num;
 +    if (!get_bits(s, 1))
 +        return 1;
 +    if (!get_bits(s, 1))
 +        return 2;
 +    if ((num = get_bits(s, 2)) != 3)
 +        return num < 0 ? num : 3 + num;
 +    if ((num = get_bits(s, 5)) != 31)
 +        return num < 0 ? num : 6 + num;
 +    num = get_bits(s, 7);
 +    return num < 0 ? num : 37 + num;
 +}
 +
 +static int getlblockinc(J2kDecoderContext *s)
 +{
 +    int res = 0, ret;
 +    while (ret = get_bits(s, 1)){
 +        if (ret < 0)
 +            return ret;
 +        res++;
 +    }
 +    return res;
 +}
 +
 +static int decode_packet(J2kDecoderContext *s, J2kCodingStyle *codsty, J2kResLevel *rlevel, int precno,
 +                         int layno, uint8_t *expn, int numgbits)
 +{
 +    int bandno, cblkny, cblknx, cblkno, ret;
 +
 +    if (!(ret = get_bits(s, 1))){
 +        j2k_flush(s);
 +        return 0;
 +    } else if (ret < 0)
 +        return ret;
 +
 +    for (bandno = 0; bandno < rlevel->nbands; bandno++){
 +        J2kBand *band = rlevel->band + bandno;
 +        J2kPrec *prec = band->prec + precno;
 +        int pos = 0;
 +
 +        if (band->coord[0][0] == band->coord[0][1]
 +        ||  band->coord[1][0] == band->coord[1][1])
 +            continue;
 +
 +        for (cblkny = prec->yi0; cblkny < prec->yi1; cblkny++)
 +            for(cblknx = prec->xi0, cblkno = cblkny * band->cblknx + cblknx; cblknx < prec->xi1; cblknx++, cblkno++, pos++){
 +                J2kCblk *cblk = band->cblk + cblkno;
 +                int incl, newpasses, llen;
 +
 +                if (cblk->npasses)
 +                    incl = get_bits(s, 1);
 +                else
 +                    incl = tag_tree_decode(s, prec->cblkincl + pos, layno+1) == layno;
 +                if (!incl)
 +                    continue;
 +                else if (incl < 0)
 +                    return incl;
 +
 +                if (!cblk->npasses)
 +                    cblk->nonzerobits = expn[bandno] + numgbits - 1 - tag_tree_decode(s, prec->zerobits + pos, 100);
 +                if ((newpasses = getnpasses(s)) < 0)
 +                    return newpasses;
 +                if ((llen = getlblockinc(s)) < 0)
 +                    return llen;
 +                cblk->lblock += llen;
 +                if ((ret = get_bits(s, av_log2(newpasses) + cblk->lblock)) < 0)
 +                    return ret;
 +                cblk->lengthinc = ret;
 +                cblk->npasses += newpasses;
 +            }
 +    }
 +    j2k_flush(s);
 +
 +    if (codsty->csty & J2K_CSTY_EPH) {
 +        if (bytestream2_peek_be16(&s->g) == J2K_EPH) {
 +            bytestream2_skip(&s->g, 2);
 +        } else {
 +            av_log(s->avctx, AV_LOG_ERROR, "EPH marker not found.\n");
 +        }
 +    }
 +
 +    for (bandno = 0; bandno < rlevel->nbands; bandno++){
 +        J2kBand *band = rlevel->band + bandno;
 +        int yi, cblknw = band->prec[precno].xi1 - band->prec[precno].xi0;
 +        for (yi = band->prec[precno].yi0; yi < band->prec[precno].yi1; yi++){
 +            int xi;
 +            for (xi = band->prec[precno].xi0; xi < band->prec[precno].xi1; xi++){
 +                J2kCblk *cblk = band->cblk + yi * cblknw + xi;
 +                if (bytestream2_get_bytes_left(&s->g) < cblk->lengthinc)
 +                    return AVERROR(EINVAL);
 +                bytestream2_get_bufferu(&s->g, cblk->data, cblk->lengthinc);
 +                cblk->length += cblk->lengthinc;
 +                cblk->lengthinc = 0;
 +            }
 +        }
 +    }
 +    return 0;
 +}
 +
 +static int decode_packets(J2kDecoderContext *s, J2kTile *tile)
 +{
 +    int layno, reslevelno, compno, precno, ok_reslevel;
 +    s->bit_index = 8;
 +    for (layno = 0; layno < tile->codsty[0].nlayers; layno++){
 +        ok_reslevel = 1;
 +        for (reslevelno = 0; ok_reslevel; reslevelno++){
 +            ok_reslevel = 0;
 +            for (compno = 0; compno < s->ncomponents; compno++){
 +                J2kCodingStyle *codsty = tile->codsty + compno;
 +                J2kQuantStyle  *qntsty = tile->qntsty + compno;
 +                if (reslevelno < codsty->nreslevels){
 +                    J2kResLevel *rlevel = tile->comp[compno].reslevel + reslevelno;
 +                    ok_reslevel = 1;
 +                    for (precno = 0; precno < rlevel->num_precincts_x * rlevel->num_precincts_y; precno++){
 +                        if (decode_packet(s, codsty, rlevel, precno, layno, qntsty->expn +
 +                                          (reslevelno ? 3*(reslevelno-1)+1 : 0), qntsty->nguardbits))
 +                            return -1;
 +                    }
 +                }
 +            }
 +        }
 +    }
 +    return 0;
 +}
 +
 +/* TIER-1 routines */
 +static void decode_sigpass(J2kT1Context *t1, int width, int height, int bpno, int bandno, int bpass_csty_symbol,
 +                           int vert_causal_ctx_csty_symbol)
 +{
 +    int mask = 3 << (bpno - 1), y0, x, y;
 +
 +    for (y0 = 0; y0 < height; y0 += 4)
 +        for (x = 0; x < width; x++)
 +            for (y = y0; y < height && y < y0+4; y++){
 +                if ((t1->flags[y+1][x+1] & J2K_T1_SIG_NB)
 +                && !(t1->flags[y+1][x+1] & (J2K_T1_SIG | J2K_T1_VIS))){
 +                    int vert_causal_ctx_csty_loc_symbol = vert_causal_ctx_csty_symbol && (x == 3 && y == 3);
 +                    if (ff_mqc_decode(&t1->mqc, t1->mqc.cx_states + ff_j2k_getnbctxno(t1->flags[y+1][x+1], bandno,
 +                   &nbs