Merge commit '716d413c13981da15323c7a3821860536eefdbbb'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 8 Oct 2012 18:54:00 +0000 (20:54 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 8 Oct 2012 19:06:57 +0000 (21:06 +0200)
* commit '716d413c13981da15323c7a3821860536eefdbbb':
  Replace PIX_FMT_* -> AV_PIX_FMT_*, PixelFormat -> AVPixelFormat

Conflicts:
doc/examples/muxing.c
ffmpeg.h
ffmpeg_filter.c
ffmpeg_opt.c
ffplay.c
ffprobe.c
libavcodec/8bps.c
libavcodec/aasc.c
libavcodec/aura.c
libavcodec/avcodec.h
libavcodec/avs.c
libavcodec/bfi.c
libavcodec/bmp.c
libavcodec/bmpenc.c
libavcodec/c93.c
libavcodec/cscd.c
libavcodec/cyuv.c
libavcodec/dpx.c
libavcodec/dpxenc.c
libavcodec/eatgv.c
libavcodec/escape124.c
libavcodec/ffv1.c
libavcodec/flashsv.c
libavcodec/fraps.c
libavcodec/h264.c
libavcodec/huffyuv.c
libavcodec/iff.c
libavcodec/imgconvert.c
libavcodec/indeo3.c
libavcodec/kmvc.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/libx264.c
libavcodec/ljpegenc.c
libavcodec/mjpegdec.c
libavcodec/mjpegenc.c
libavcodec/motionpixels.c
libavcodec/mpeg12.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videodec.c
libavcodec/mpegvideo_enc.c
libavcodec/pamenc.c
libavcodec/pcxenc.c
libavcodec/pgssubdec.c
libavcodec/pngdec.c
libavcodec/pngenc.c
libavcodec/pnm.c
libavcodec/pnmdec.c
libavcodec/pnmenc.c
libavcodec/ptx.c
libavcodec/qdrw.c
libavcodec/qpeg.c
libavcodec/qtrleenc.c
libavcodec/raw.c
libavcodec/rawdec.c
libavcodec/rl2.c
libavcodec/sgidec.c
libavcodec/sgienc.c
libavcodec/snowdec.c
libavcodec/snowenc.c
libavcodec/sunrast.c
libavcodec/targa.c
libavcodec/targaenc.c
libavcodec/tiff.c
libavcodec/tiffenc.c
libavcodec/tmv.c
libavcodec/truemotion2.c
libavcodec/utils.c
libavcodec/vb.c
libavcodec/vp3.c
libavcodec/wnv1.c
libavcodec/xl.c
libavcodec/xwddec.c
libavcodec/xwdenc.c
libavcodec/yop.c
libavdevice/v4l2.c
libavdevice/x11grab.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/buffersrc.c
libavfilter/drawutils.c
libavfilter/formats.c
libavfilter/src_movie.c
libavfilter/vf_ass.c
libavfilter/vf_drawtext.c
libavfilter/vf_fade.c
libavfilter/vf_format.c
libavfilter/vf_hflip.c
libavfilter/vf_lut.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_scale.c
libavfilter/vf_transpose.c
libavfilter/vf_yadif.c
libavfilter/video.c
libavfilter/vsrc_testsrc.c
libavformat/movenc.c
libavformat/mxf.h
libavformat/utils.c
libavformat/yuv4mpeg.c
libavutil/imgutils.c
libavutil/pixdesc.c
libswscale/input.c
libswscale/output.c
libswscale/swscale_internal.h
libswscale/swscale_unscaled.c
libswscale/utils.c
libswscale/x86/swscale_template.c
libswscale/x86/yuv2rgb.c
libswscale/x86/yuv2rgb_template.c
libswscale/yuv2rgb.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
370 files changed:
1  2 
cmdutils.c
cmdutils.h
doc/examples/decoding_encoding.c
doc/examples/filtering_video.c
doc/examples/muxing.c
doc/examples/scaling_video.c
doc/filters.texi
ffmpeg.h
ffmpeg_filter.c
ffmpeg_opt.c
ffplay.c
libavcodec/4xm.c
libavcodec/8bps.c
libavcodec/a64multienc.c
libavcodec/aasc.c
libavcodec/anm.c
libavcodec/ansi.c
libavcodec/asv1.c
libavcodec/aura.c
libavcodec/avcodec.h
libavcodec/avrndec.c
libavcodec/avs.c
libavcodec/avuidec.c
libavcodec/avuienc.c
libavcodec/bethsoftvideo.c
libavcodec/bfi.c
libavcodec/bink.c
libavcodec/bintext.c
libavcodec/bmp.c
libavcodec/bmpenc.c
libavcodec/bmv.c
libavcodec/c93.c
libavcodec/cavs.c
libavcodec/cdgraphics.c
libavcodec/cdxl.c
libavcodec/cinepak.c
libavcodec/cljr.c
libavcodec/cllc.c
libavcodec/cpia.c
libavcodec/crystalhd.c
libavcodec/cscd.c
libavcodec/cyuv.c
libavcodec/dfa.c
libavcodec/dirac.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dpx.c
libavcodec/dpxenc.c
libavcodec/dsicinav.c
libavcodec/dv.c
libavcodec/dv_profile.c
libavcodec/dv_profile.h
libavcodec/dvdec.c
libavcodec/dxa.c
libavcodec/dxva2_h264.c
libavcodec/dxva2_mpeg2.c
libavcodec/dxva2_vc1.c
libavcodec/eacmv.c
libavcodec/eamad.c
libavcodec/eatgq.c
libavcodec/eatgv.c
libavcodec/eatqi.c
libavcodec/escape124.c
libavcodec/escape130.c
libavcodec/exr.c
libavcodec/ffv1.c
libavcodec/flashsv.c
libavcodec/flashsv2enc.c
libavcodec/flashsvenc.c
libavcodec/flicvideo.c
libavcodec/flvenc.c
libavcodec/fraps.c
libavcodec/frwu.c
libavcodec/gif.c
libavcodec/gifdec.c
libavcodec/h261dec.c
libavcodec/h261enc.c
libavcodec/h263dec.c
libavcodec/h264.c
libavcodec/huffyuv.c
libavcodec/idcinvideo.c
libavcodec/iff.c
libavcodec/imgconvert.c
libavcodec/indeo2.c
libavcodec/indeo3.c
libavcodec/indeo4.c
libavcodec/indeo5.c
libavcodec/internal.h
libavcodec/interplayvideo.c
libavcodec/j2kdec.c
libavcodec/j2kenc.c
libavcodec/jpeglsenc.c
libavcodec/jvdec.c
libavcodec/kgv1dec.c
libavcodec/kmvc.c
libavcodec/lagarith.c
libavcodec/lcldec.c
libavcodec/lclenc.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/libschroedinger.h
libavcodec/libschroedingerdec.c
libavcodec/libschroedingerenc.c
libavcodec/libstagefright.cpp
libavcodec/libtheoraenc.c
libavcodec/libutvideodec.cpp
libavcodec/libutvideoenc.cpp
libavcodec/libvpxdec.c
libavcodec/libvpxenc.c
libavcodec/libx264.c
libavcodec/libxavs.c
libavcodec/libxvid.c
libavcodec/ljpegenc.c
libavcodec/loco.c
libavcodec/mdec.c
libavcodec/mimic.c
libavcodec/mjpegdec.c
libavcodec/mjpegenc.c
libavcodec/mmvideo.c
libavcodec/motionpixels.c
libavcodec/mpeg12.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videodec.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/msrle.c
libavcodec/mss1.c
libavcodec/mss2.c
libavcodec/mss3.c
libavcodec/mss4.c
libavcodec/msvideo1.c
libavcodec/msvideo1enc.c
libavcodec/nuv.c
libavcodec/options.c
libavcodec/paf.c
libavcodec/pamenc.c
libavcodec/pcx.c
libavcodec/pcxenc.c
libavcodec/pgssubdec.c
libavcodec/pictordec.c
libavcodec/pngdec.c
libavcodec/pngenc.c
libavcodec/pnm.c
libavcodec/pnmdec.c
libavcodec/pnmenc.c
libavcodec/proresdec2.c
libavcodec/proresdec_lgpl.c
libavcodec/proresenc_anatoliy.c
libavcodec/proresenc_kostya.c
libavcodec/ptx.c
libavcodec/qdrw.c
libavcodec/qpeg.c
libavcodec/qtrle.c
libavcodec/qtrleenc.c
libavcodec/r210dec.c
libavcodec/r210enc.c
libavcodec/raw.c
libavcodec/raw.h
libavcodec/rawdec.c
libavcodec/rawenc.c
libavcodec/rl2.c
libavcodec/roqvideodec.c
libavcodec/roqvideoenc.c
libavcodec/rpza.c
libavcodec/rv10.c
libavcodec/rv10enc.c
libavcodec/rv20enc.c
libavcodec/rv34.c
libavcodec/sanm.c
libavcodec/sgidec.c
libavcodec/sgienc.c
libavcodec/smacker.c
libavcodec/smc.c
libavcodec/snowdec.c
libavcodec/snowenc.c
libavcodec/sunrast.c
libavcodec/sunrastenc.c
libavcodec/svq1dec.c
libavcodec/svq1enc.c
libavcodec/svq3.c
libavcodec/targa.c
libavcodec/targa_y216dec.c
libavcodec/targaenc.c
libavcodec/tiertexseqv.c
libavcodec/tiff.c
libavcodec/tiffenc.c
libavcodec/tmv.c
libavcodec/truemotion1.c
libavcodec/truemotion2.c
libavcodec/tscc.c
libavcodec/tscc2.c
libavcodec/txd.c
libavcodec/ulti.c
libavcodec/utils.c
libavcodec/utvideodec.c
libavcodec/utvideoenc.c
libavcodec/v210dec.c
libavcodec/v210enc.c
libavcodec/v210x.c
libavcodec/v308dec.c
libavcodec/v308enc.c
libavcodec/v408dec.c
libavcodec/v408enc.c
libavcodec/v410dec.c
libavcodec/v410enc.c
libavcodec/vaapi_h264.c
libavcodec/vaapi_mpeg2.c
libavcodec/vaapi_mpeg4.c
libavcodec/vaapi_vc1.c
libavcodec/vb.c
libavcodec/vble.c
libavcodec/vc1dec.c
libavcodec/vcr1.c
libavcodec/vda_h264.c
libavcodec/vda_h264_dec.c
libavcodec/vdpau.c
libavcodec/vmdav.c
libavcodec/vmnc.c
libavcodec/vp3.c
libavcodec/vp56.c
libavcodec/vp8.c
libavcodec/vqavideo.c
libavcodec/wmv2enc.c
libavcodec/wnv1.c
libavcodec/xan.c
libavcodec/xbmdec.c
libavcodec/xbmenc.c
libavcodec/xl.c
libavcodec/xsubdec.c
libavcodec/xwddec.c
libavcodec/xwdenc.c
libavcodec/xxan.c
libavcodec/y41pdec.c
libavcodec/y41penc.c
libavcodec/yop.c
libavcodec/yuv4dec.c
libavcodec/yuv4enc.c
libavcodec/zmbv.c
libavcodec/zmbvenc.c
libavdevice/bktr.c
libavdevice/caca.c
libavdevice/dshow.c
libavdevice/fbdev.c
libavdevice/lavfi.c
libavdevice/libdc1394.c
libavdevice/sdl.c
libavdevice/v4l.c
libavdevice/v4l2.c
libavdevice/vfwcap.c
libavdevice/x11grab.c
libavfilter/avf_showspectrum.c
libavfilter/avf_showwaves.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/buffersink.h
libavfilter/buffersrc.c
libavfilter/drawutils.c
libavfilter/drawutils.h
libavfilter/f_ebur128.c
libavfilter/formats.c
libavfilter/internal.h
libavfilter/lavfutils.c
libavfilter/lavfutils.h
libavfilter/libmpcodecs/vf_mcdeint.c
libavfilter/libmpcodecs/vf_sab.c
libavfilter/libmpcodecs/vf_uspp.c
libavfilter/lswsutils.c
libavfilter/lswsutils.h
libavfilter/sink_buffer.c
libavfilter/src_buffer.c
libavfilter/vf_alphaextract.c
libavfilter/vf_alphamerge.c
libavfilter/vf_bbox.c
libavfilter/vf_blackdetect.c
libavfilter/vf_blackframe.c
libavfilter/vf_boxblur.c
libavfilter/vf_colormatrix.c
libavfilter/vf_crop.c
libavfilter/vf_cropdetect.c
libavfilter/vf_decimate.c
libavfilter/vf_delogo.c
libavfilter/vf_deshake.c
libavfilter/vf_drawbox.c
libavfilter/vf_edgedetect.c
libavfilter/vf_fade.c
libavfilter/vf_fieldorder.c
libavfilter/vf_format.c
libavfilter/vf_frei0r.c
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_hue.c
libavfilter/vf_idet.c
libavfilter/vf_libopencv.c
libavfilter/vf_lut.c
libavfilter/vf_mp.c
libavfilter/vf_overlay.c
libavfilter/vf_removelogo.c
libavfilter/vf_scale.c
libavfilter/vf_select.c
libavfilter/vf_smartblur.c
libavfilter/vf_super2xsai.c
libavfilter/vf_swapuv.c
libavfilter/vf_thumbnail.c
libavfilter/vf_tinterlace.c
libavfilter/vf_transpose.c
libavfilter/vf_unsharp.c
libavfilter/vf_yadif.c
libavfilter/video.c
libavfilter/vsrc_cellauto.c
libavfilter/vsrc_life.c
libavfilter/vsrc_mandelbrot.c
libavfilter/vsrc_mptestsrc.c
libavfilter/vsrc_testsrc.c
libavformat/bfi.c
libavformat/dvenc.c
libavformat/filmstripdec.c
libavformat/filmstripenc.c
libavformat/gif.c
libavformat/gxfenc.c
libavformat/icoenc.c
libavformat/iff.c
libavformat/img2dec.c
libavformat/lxfdec.c
libavformat/movenc.c
libavformat/mtv.c
libavformat/mxf.c
libavformat/mxf.h
libavformat/mxfdec.c
libavformat/rawdec.c
libavformat/rtpdec_xiph.c
libavformat/rtpenc_jpeg.c
libavformat/sdp.c
libavformat/segafilm.c
libavformat/siff.c
libavformat/smacker.c
libavformat/tmv.c
libavformat/utils.c
libavformat/yuv4mpeg.c
libavutil/imgutils.c
libavutil/imgutils.h
libavutil/opt.c
libavutil/pixdesc.c
libavutil/pixdesc.h
libavutil/pixfmt.h
libavutil/utils.c
libswscale/bfin/swscale_bfin.c
libswscale/bfin/yuv2rgb_bfin.c
libswscale/input.c
libswscale/options.c
libswscale/output.c
libswscale/ppc/swscale_altivec.c
libswscale/ppc/yuv2rgb_altivec.c
libswscale/ppc/yuv2yuv_altivec.c
libswscale/sparc/yuv2rgb_vis.c
libswscale/swscale-test.c
libswscale/swscale.c
libswscale/swscale.h
libswscale/swscale_internal.h
libswscale/swscale_unscaled.c
libswscale/utils.c
libswscale/x86/swscale.c
libswscale/x86/swscale_template.c
libswscale/x86/yuv2rgb.c
libswscale/x86/yuv2rgb_template.c
libswscale/yuv2rgb.c
tools/fourcc2pixfmt.c

diff --cc cmdutils.c
@@@ -1110,10 -882,8 +1110,10 @@@ int show_pix_fmts(void *optctx, const c
  #   define sws_isSupportedOutput(x) 0
  #endif
  
-     for (pix_fmt = 0; pix_fmt < PIX_FMT_NB; pix_fmt++) {
+     for (pix_fmt = 0; pix_fmt < AV_PIX_FMT_NB; pix_fmt++) {
          const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[pix_fmt];
 +        if(!pix_desc->name)
 +            continue;
          printf("%c%c%c%c%c %-16s       %d            %2d\n",
                 sws_isSupportedInput (pix_fmt)      ? 'I' : '.',
                 sws_isSupportedOutput(pix_fmt)      ? 'O' : '.',
diff --cc cmdutils.h
Simple merge
@@@ -356,14 -345,11 +356,14 @@@ static void video_encode_example(const 
      c->time_base= (AVRational){1,25};
      c->gop_size = 10; /* emit one intra frame every ten frames */
      c->max_b_frames=1;
-     c->pix_fmt = PIX_FMT_YUV420P;
+     c->pix_fmt = AV_PIX_FMT_YUV420P;
  
 +    if(codec_id == AV_CODEC_ID_H264)
 +        av_opt_set(c->priv_data, "preset", "slow", 0);
 +
      /* open it */
      if (avcodec_open2(c, codec, NULL) < 0) {
 -        fprintf(stderr, "could not open codec\n");
 +        fprintf(stderr, "Could not open codec\n");
          exit(1);
      }
  
index ee5073a,0000000..ca0266e
mode 100644,000000..100644
--- /dev/null
@@@ -1,247 -1,0 +1,247 @@@
-     enum PixelFormat pix_fmts[] = { PIX_FMT_GRAY8, PIX_FMT_NONE };
 +/*
 + * Copyright (c) 2010 Nicolas George
 + * Copyright (c) 2011 Stefano Sabatini
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * API example for decoding and filtering
 + */
 +
 +#define _XOPEN_SOURCE 600 /* for usleep */
 +#include <unistd.h>
 +
 +#include <libavcodec/avcodec.h>
 +#include <libavformat/avformat.h>
 +#include <libavfilter/avfiltergraph.h>
 +#include <libavfilter/avcodec.h>
 +#include <libavfilter/buffersink.h>
 +#include <libavfilter/buffersrc.h>
 +
 +const char *filter_descr = "scale=78:24";
 +
 +static AVFormatContext *fmt_ctx;
 +static AVCodecContext *dec_ctx;
 +AVFilterContext *buffersink_ctx;
 +AVFilterContext *buffersrc_ctx;
 +AVFilterGraph *filter_graph;
 +static int video_stream_index = -1;
 +static int64_t last_pts = AV_NOPTS_VALUE;
 +
 +static int open_input_file(const char *filename)
 +{
 +    int ret;
 +    AVCodec *dec;
 +
 +    if ((ret = avformat_open_input(&fmt_ctx, filename, NULL, NULL)) < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
 +        return ret;
 +    }
 +
 +    if ((ret = avformat_find_stream_info(fmt_ctx, NULL)) < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
 +        return ret;
 +    }
 +
 +    /* select the video stream */
 +    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, &dec, 0);
 +    if (ret < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot find a video stream in the input file\n");
 +        return ret;
 +    }
 +    video_stream_index = ret;
 +    dec_ctx = fmt_ctx->streams[video_stream_index]->codec;
 +
 +    /* init the video decoder */
 +    if ((ret = avcodec_open2(dec_ctx, dec, NULL)) < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot open video decoder\n");
 +        return ret;
 +    }
 +
 +    return 0;
 +}
 +
 +static int init_filters(const char *filters_descr)
 +{
 +    char args[512];
 +    int ret;
 +    AVFilter *buffersrc  = avfilter_get_by_name("buffer");
 +    AVFilter *buffersink = avfilter_get_by_name("ffbuffersink");
 +    AVFilterInOut *outputs = avfilter_inout_alloc();
 +    AVFilterInOut *inputs  = avfilter_inout_alloc();
++    enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE };
 +    AVBufferSinkParams *buffersink_params;
 +
 +    filter_graph = avfilter_graph_alloc();
 +
 +    /* buffer video source: the decoded frames from the decoder will be inserted here. */
 +    snprintf(args, sizeof(args),
 +            "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
 +            dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
 +            dec_ctx->time_base.num, dec_ctx->time_base.den,
 +            dec_ctx->sample_aspect_ratio.num, dec_ctx->sample_aspect_ratio.den);
 +
 +    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
 +                                       args, NULL, filter_graph);
 +    if (ret < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
 +        return ret;
 +    }
 +
 +    /* buffer video sink: to terminate the filter chain. */
 +    buffersink_params = av_buffersink_params_alloc();
 +    buffersink_params->pixel_fmts = pix_fmts;
 +    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
 +                                       NULL, buffersink_params, filter_graph);
 +    av_free(buffersink_params);
 +    if (ret < 0) {
 +        av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
 +        return ret;
 +    }
 +
 +    /* Endpoints for the filter graph. */
 +    outputs->name       = av_strdup("in");
 +    outputs->filter_ctx = buffersrc_ctx;
 +    outputs->pad_idx    = 0;
 +    outputs->next       = NULL;
 +
 +    inputs->name       = av_strdup("out");
 +    inputs->filter_ctx = buffersink_ctx;
 +    inputs->pad_idx    = 0;
 +    inputs->next       = NULL;
 +
 +    if ((ret = avfilter_graph_parse(filter_graph, filters_descr,
 +                                    &inputs, &outputs, NULL)) < 0)
 +        return ret;
 +
 +    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
 +        return ret;
 +    return 0;
 +}
 +
 +static void display_picref(AVFilterBufferRef *picref, AVRational time_base)
 +{
 +    int x, y;
 +    uint8_t *p0, *p;
 +    int64_t delay;
 +
 +    if (picref->pts != AV_NOPTS_VALUE) {
 +        if (last_pts != AV_NOPTS_VALUE) {
 +            /* sleep roughly the right amount of time;
 +             * usleep is in microseconds, just like AV_TIME_BASE. */
 +            delay = av_rescale_q(picref->pts - last_pts,
 +                                 time_base, AV_TIME_BASE_Q);
 +            if (delay > 0 && delay < 1000000)
 +                usleep(delay);
 +        }
 +        last_pts = picref->pts;
 +    }
 +
 +    /* Trivial ASCII grayscale display. */
 +    p0 = picref->data[0];
 +    puts("\033c");
 +    for (y = 0; y < picref->video->h; y++) {
 +        p = p0;
 +        for (x = 0; x < picref->video->w; x++)
 +            putchar(" .-+#"[*(p++) / 52]);
 +        putchar('\n');
 +        p0 += picref->linesize[0];
 +    }
 +    fflush(stdout);
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    int ret;
 +    AVPacket packet;
 +    AVFrame frame;
 +    int got_frame;
 +
 +    if (argc != 2) {
 +        fprintf(stderr, "Usage: %s file\n", argv[0]);
 +        exit(1);
 +    }
 +
 +    avcodec_register_all();
 +    av_register_all();
 +    avfilter_register_all();
 +
 +    if ((ret = open_input_file(argv[1])) < 0)
 +        goto end;
 +    if ((ret = init_filters(filter_descr)) < 0)
 +        goto end;
 +
 +    /* read all packets */
 +    while (1) {
 +        AVFilterBufferRef *picref;
 +        if ((ret = av_read_frame(fmt_ctx, &packet)) < 0)
 +            break;
 +
 +        if (packet.stream_index == video_stream_index) {
 +            avcodec_get_frame_defaults(&frame);
 +            got_frame = 0;
 +            ret = avcodec_decode_video2(dec_ctx, &frame, &got_frame, &packet);
 +            if (ret < 0) {
 +                av_log(NULL, AV_LOG_ERROR, "Error decoding video\n");
 +                break;
 +            }
 +
 +            if (got_frame) {
 +                frame.pts = av_frame_get_best_effort_timestamp(&frame);
 +
 +                /* push the decoded frame into the filtergraph */
 +                if (av_buffersrc_add_frame(buffersrc_ctx, &frame, 0) < 0) {
 +                    av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
 +                    break;
 +                }
 +
 +                /* pull filtered pictures from the filtergraph */
 +                while (1) {
 +                    ret = av_buffersink_get_buffer_ref(buffersink_ctx, &picref, 0);
 +                    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 +                        break;
 +                    if (ret < 0)
 +                        goto end;
 +
 +                    if (picref) {
 +                        display_picref(picref, buffersink_ctx->inputs[0]->time_base);
 +                        avfilter_unref_bufferp(&picref);
 +                    }
 +                }
 +            }
 +        }
 +        av_free_packet(&packet);
 +    }
 +end:
 +    avfilter_graph_free(&filter_graph);
 +    if (dec_ctx)
 +        avcodec_close(dec_ctx);
 +    avformat_close_input(&fmt_ctx);
 +
 +    if (ret < 0 && ret != AVERROR_EOF) {
 +        char buf[1024];
 +        av_strerror(ret, buf, sizeof(buf));
 +        fprintf(stderr, "Error occurred: %s\n", buf);
 +        exit(1);
 +    }
 +
 +    exit(0);
 +}
  #include <string.h>
  #include <math.h>
  
 -#include "libavutil/mathematics.h"
 -#include "libavformat/avformat.h"
 -#include "libswscale/swscale.h"
 -
 -#undef exit
 +#include <libavutil/mathematics.h>
 +#include <libavformat/avformat.h>
 +#include <libswscale/swscale.h>
  
  /* 5 seconds stream duration */
 -#define STREAM_DURATION   5.0
 +#define STREAM_DURATION   200.0
  #define STREAM_FRAME_RATE 25 /* 25 images/s */
  #define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
- #define STREAM_PIX_FMT    PIX_FMT_YUV420P /* default pix_fmt */
+ #define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
  
  static int sws_flags = SWS_BICUBIC;
  
@@@ -277,9 -288,10 +277,9 @@@ static void open_video(AVFormatContext 
      /* If the output format is not YUV420P, then a temporary YUV420P
       * picture is needed too. It is then converted to the required
       * output format. */
-     if (c->pix_fmt != PIX_FMT_YUV420P) {
-         ret = avpicture_alloc(&src_picture, PIX_FMT_YUV420P, c->width, c->height);
 -    tmp_picture = NULL;
+     if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 -        tmp_picture = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
 -        if (!tmp_picture) {
++        ret = avpicture_alloc(&src_picture, AV_PIX_FMT_YUV420P, c->width, c->height);
 +        if (ret < 0) {
              fprintf(stderr, "Could not allocate temporary picture\n");
              exit(1);
          }
@@@ -322,16 -333,18 +322,16 @@@ static void write_video_frame(AVFormatC
           * frames if using B-frames, so we get the last frames by
           * passing the same picture again. */
      } else {
-         if (c->pix_fmt != PIX_FMT_YUV420P) {
+         if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
              /* as we only generate a YUV420P picture, we must convert it
               * to the codec pixel format if needed */
 -            if (img_convert_ctx == NULL) {
 -                img_convert_ctx = sws_getContext(c->width, c->height,
 -                                                 AV_PIX_FMT_YUV420P,
 -                                                 c->width, c->height,
 -                                                 c->pix_fmt,
 -                                                 sws_flags, NULL, NULL, NULL);
 -                if (img_convert_ctx == NULL) {
 +            if (!sws_ctx) {
-                 sws_ctx = sws_getContext(c->width, c->height, PIX_FMT_YUV420P,
++                sws_ctx = sws_getContext(c->width, c->height, AV_PIX_FMT_YUV420P,
 +                                         c->width, c->height, c->pix_fmt,
 +                                         sws_flags, NULL, NULL, NULL);
 +                if (!sws_ctx) {
                      fprintf(stderr,
 -                            "Cannot initialize the conversion context\n");
 +                            "Could not initialize the conversion context\n");
                      exit(1);
                  }
              }
index 686af0c,0000000..e380131
mode 100644,000000..100644
--- /dev/null
@@@ -1,142 -1,0 +1,142 @@@
-     enum PixelFormat src_pix_fmt = PIX_FMT_YUV420P, dst_pix_fmt = PIX_FMT_RGB24;
 +/*
 + * Copyright (c) 2012 Stefano Sabatini
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * libswscale API use example.
 + */
 +
 +#include <libavutil/imgutils.h>
 +#include <libavutil/parseutils.h>
 +#include <libswscale/swscale.h>
 +
 +static void fill_yuv_image(uint8_t *data[4], int linesize[4],
 +                           int width, int height, int frame_index)
 +{
 +    int x, y, i;
 +
 +    i = frame_index;
 +
 +    /* Y */
 +    for (y = 0; y < height; y++)
 +        for (x = 0; x < width; x++)
 +            data[0][y * linesize[0] + x] = x + y + i * 3;
 +
 +    /* Cb and Cr */
 +    for (y = 0; y < height / 2; y++) {
 +        for (x = 0; x < width / 2; x++) {
 +            data[1][y * linesize[1] + x] = 128 + y + i * 2;
 +            data[2][y * linesize[2] + x] = 64 + x + i * 5;
 +        }
 +    }
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    uint8_t *src_data[4], *dst_data[4];
 +    int src_linesize[4], dst_linesize[4];
 +    int src_w = 320, src_h = 240, dst_w, dst_h;
++    enum AVPixelFormat src_pix_fmt = AV_PIX_FMT_YUV420P, dst_pix_fmt = AV_PIX_FMT_RGB24;
 +    const char *dst_size = NULL;
 +    const char *dst_filename = NULL;
 +    FILE *dst_file;
 +    int dst_bufsize;
 +    struct SwsContext *sws_ctx;
 +    int i, ret;
 +
 +    if (argc != 3) {
 +        fprintf(stderr, "Usage: %s output_file output_size\n"
 +                "API example program to show how to scale an image with libswscale.\n"
 +                "This program generates a series of pictures, rescales them to the given "
 +                "output_size and saves them to an output file named output_file\n."
 +                "\n", argv[0]);
 +        exit(1);
 +    }
 +    dst_filename = argv[1];
 +    dst_size     = argv[2];
 +
 +    if (av_parse_video_size(&dst_w, &dst_h, dst_size) < 0) {
 +        fprintf(stderr,
 +                "Invalid size '%s', must be in the form WxH or a valid size abbreviation\n",
 +                dst_size);
 +        exit(1);
 +    }
 +
 +    dst_file = fopen(dst_filename, "wb");
 +    if (!dst_file) {
 +        fprintf(stderr, "Could not open destination file %s\n", dst_filename);
 +        exit(1);
 +    }
 +
 +    /* create scaling context */
 +    sws_ctx = sws_getContext(src_w, src_h, src_pix_fmt,
 +                             dst_w, dst_h, dst_pix_fmt,
 +                             SWS_BILINEAR, NULL, NULL, NULL);
 +    if (!sws_ctx) {
 +        fprintf(stderr,
 +                "Impossible to create scale context for the conversion "
 +                "fmt:%s s:%dx%d -> fmt:%s s:%dx%d\n",
 +                av_get_pix_fmt_name(src_pix_fmt), src_w, src_h,
 +                av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h);
 +        ret = AVERROR(EINVAL);
 +        goto end;
 +    }
 +
 +    /* allocate source and destination image buffers */
 +    if ((ret = av_image_alloc(src_data, src_linesize,
 +                              src_w, src_h, src_pix_fmt, 16)) < 0) {
 +        fprintf(stderr, "Could not allocate source image\n");
 +        goto end;
 +    }
 +
 +    /* buffer is going to be written to rawvideo file, no alignmnet */
 +    if ((ret = av_image_alloc(dst_data, dst_linesize,
 +                              dst_w, dst_h, dst_pix_fmt, 1)) < 0) {
 +        fprintf(stderr, "Could not allocate destination image\n");
 +        goto end;
 +    }
 +    dst_bufsize = ret;
 +
 +    for (i = 0; i < 100; i++) {
 +        /* generate synthetic video */
 +        fill_yuv_image(src_data, src_linesize, src_w, src_h, i);
 +
 +        /* convert to destination format */
 +        sws_scale(sws_ctx, (const uint8_t * const*)src_data,
 +                  src_linesize, 0, src_h, dst_data, dst_linesize);
 +
 +        /* write scaled image to file */
 +        fwrite(dst_data[0], 1, dst_bufsize, dst_file);
 +    }
 +
 +    fprintf(stderr, "Scaling succeeded. Play the output file with the command:\n"
 +           "ffplay -f rawvideo -pix_fmt %s -video_size %dx%d %s\n",
 +           av_get_pix_fmt_name(dst_pix_fmt), dst_w, dst_h, dst_filename);
 +
 +end:
 +    if (dst_file)
 +        fclose(dst_file);
 +    av_freep(&src_data[0]);
 +    av_freep(&dst_data[0]);
 +    sws_freeContext(sws_ctx);
 +    return ret < 0;
 +}
@@@ -3738,213 -2132,165 +3738,213 @@@ will instruct the source to accept vide
  with format "yuv410p", assuming 1/24 as the timestamps timebase and
  square pixels (1:1 sample aspect ratio).
  Since the pixel format with name "yuv410p" corresponds to the number 6
- (check the enum PixelFormat definition in @file{libavutil/pixfmt.h}),
+ (check the enum AVPixelFormat definition in @file{libavutil/pixfmt.h}),
  this example corresponds to:
  @example
 -buffer=320:240:6:1:24
 +buffer=size=320x240:pixfmt=6:time_base=1/24:pixel_aspect=1/1
  @end example
  
 -@section color
 +Alternatively, the options can be specified as a flat string, but this
 +syntax is deprecated:
  
 -Provide an uniformly colored input.
 +@var{width}:@var{height}:@var{pix_fmt}:@var{time_base.num}:@var{time_base.den}:@var{pixel_aspect.num}:@var{pixel_aspect.den}[:@var{sws_param}]
  
 -It accepts the following parameters:
 -@var{color}:@var{frame_size}:@var{frame_rate}
 +@section cellauto
  
 -Follows the description of the accepted parameters.
 +Create a pattern generated by an elementary cellular automaton.
  
 -@table @option
 +The initial state of the cellular automaton can be defined through the
 +@option{filename}, and @option{pattern} options. If such options are
 +not specified an initial state is created randomly.
  
 -@item color
 -Specify the color of the source. It can be the name of a color (case
 -insensitive match) or a 0xRRGGBB[AA] sequence, possibly followed by an
 -alpha specifier. The default value is "black".
 +At each new frame a new row in the video is filled with the result of
 +the cellular automaton next generation. The behavior when the whole
 +frame is filled is defined by the @option{scroll} option.
  
 -@item frame_size
 -Specify the size of the sourced video, it may be a string of the form
 -@var{width}x@var{height}, or the name of a size abbreviation. The
 -default value is "320x240".
 +This source accepts a list of options in the form of
 +@var{key}=@var{value} pairs separated by ":". A description of the
 +accepted options follows.
  
 -@item frame_rate
 -Specify the frame rate of the sourced video, as the number of frames
 -generated per second. It has to be a string in the format
 -@var{frame_rate_num}/@var{frame_rate_den}, an integer number, a float
 -number or a valid video frame rate abbreviation. The default value is
 -"25".
 +@table @option
 +@item filename, f
 +Read the initial cellular automaton state, i.e. the starting row, from
 +the specified file.
 +In the file, each non-whitespace character is considered an alive
 +cell, a newline will terminate the row, and further characters in the
 +file will be ignored.
  
 -@end table
 +@item pattern, p
 +Read the initial cellular automaton state, i.e. the starting row, from
 +the specified string.
  
 -For example the following graph description will generate a red source
 -with an opacity of 0.2, with size "qcif" and a frame rate of 10
 -frames per second, which will be overlayed over the source connected
 -to the pad with identifier "in".
 +Each non-whitespace character in the string is considered an alive
 +cell, a newline will terminate the row, and further characters in the
 +string will be ignored.
  
 -@example
 -"color=red@@0.2:qcif:10 [color]; [in][color] overlay [out]"
 -@end example
 +@item rate, r
 +Set the video rate, that is the number of frames generated per second.
 +Default is 25.
  
 -@section movie
 +@item random_fill_ratio, ratio
 +Set the random fill ratio for the initial cellular automaton row. It
 +is a floating point number value ranging from 0 to 1, defaults to
 +1/PHI.
  
 -Read a video stream from a movie container.
 +This option is ignored when a file or a pattern is specified.
  
 -Note that this source is a hack that bypasses the standard input path. It can be
 -useful in applications that do not support arbitrary filter graphs, but its use
 -is discouraged in those that do. Specifically in @command{avconv} this filter
 -should never be used, the @option{-filter_complex} option fully replaces it.
 +@item random_seed, seed
 +Set the seed for filling randomly the initial row, must be an integer
 +included between 0 and UINT32_MAX. If not specified, or if explicitly
 +set to -1, the filter will try to use a good random seed on a best
 +effort basis.
  
 -It accepts the syntax: @var{movie_name}[:@var{options}] where
 -@var{movie_name} is the name of the resource to read (not necessarily
 -a file but also a device or a stream accessed through some protocol),
 -and @var{options} is an optional sequence of @var{key}=@var{value}
 -pairs, separated by ":".
 +@item rule
 +Set the cellular automaton rule, it is a number ranging from 0 to 255.
 +Default value is 110.
  
 -The description of the accepted options follows.
 +@item size, s
 +Set the size of the output video.
  
 -@table @option
 +If @option{filename} or @option{pattern} is specified, the size is set
 +by default to the width of the specified initial state row, and the
 +height is set to @var{width} * PHI.
  
 -@item format_name, f
 -Specifies the format assumed for the movie to read, and can be either
 -the name of a container or an input device. If not specified the
 -format is guessed from @var{movie_name} or by probing.
 +If @option{size} is set, it must contain the width of the specified
 +pattern string, and the specified pattern will be centered in the
 +larger row.
  
 -@item seek_point, sp
 -Specifies the seek point in seconds, the frames will be output
 -starting from this seek point, the parameter is evaluated with
 -@code{av_strtod} so the numerical value may be suffixed by an IS
 -postfix. Default value is "0".
 +If a filename or a pattern string is not specified, the size value
 +defaults to "320x518" (used for a randomly generated initial state).
  
 -@item stream_index, si
 -Specifies the index of the video stream to read. If the value is -1,
 -the best suited video stream will be automatically selected. Default
 -value is "-1".
 +@item scroll
 +If set to 1, scroll the output upward when all the rows in the output
 +have been already filled. If set to 0, the new generated row will be
 +written over the top row just after the bottom row is filled.
 +Defaults to 1.
  
 +@item start_full, full
 +If set to 1, completely fill the output with generated rows before
 +outputting the first frame.
 +This is the default behavior, for disabling set the value to 0.
 +
 +@item stitch
 +If set to 1, stitch the left and right row edges together.
 +This is the default behavior, for disabling set the value to 0.
  @end table
  
 -This filter allows to overlay a second video on top of main input of
 -a filtergraph as shown in this graph:
 +@subsection Examples
 +
 +@itemize
 +@item
 +Read the initial state from @file{pattern}, and specify an output of
 +size 200x400.
  @example
 -input -----------> deltapts0 --> overlay --> output
 -                                    ^
 -                                    |
 -movie --> scale--> deltapts1 -------+
 +cellauto=f=pattern:s=200x400
  @end example
  
 -Some examples follow:
 +@item
 +Generate a random initial row with a width of 200 cells, with a fill
 +ratio of 2/3:
  @example
 -# skip 3.2 seconds from the start of the avi file in.avi, and overlay it
 -# on top of the input labelled as "in".
 -movie=in.avi:seek_point=3.2, scale=180:-1, setpts=PTS-STARTPTS [movie];
 -[in] setpts=PTS-STARTPTS, [movie] overlay=16:16 [out]
 +cellauto=ratio=2/3:s=200x200
 +@end example
  
 -# read from a video4linux2 device, and overlay it on top of the input
 -# labelled as "in"
 -movie=/dev/video0:f=video4linux2, scale=180:-1, setpts=PTS-STARTPTS [movie];
 -[in] setpts=PTS-STARTPTS, [movie] overlay=16:16 [out]
 +@item
 +Create a pattern generated by rule 18 starting by a single alive cell
 +centered on an initial row with width 100:
 +@example
 +cellauto=p=@@:s=100x400:full=0:rule=18
 +@end example
  
 +@item
 +Specify a more elaborated initial pattern:
 +@example
 +cellauto=p='@@@@ @@ @@@@':s=100x400:full=0:rule=18
  @end example
  
 -@section nullsrc
 +@end itemize
  
 -Null video source, never return images. It is mainly useful as a
 -template and to be employed in analysis / debugging tools.
 +@section mandelbrot
  
 -It accepts as optional parameter a string of the form
 -@var{width}:@var{height}:@var{timebase}.
 +Generate a Mandelbrot set fractal, and progressively zoom towards the
 +point specified with @var{start_x} and @var{start_y}.
  
 -@var{width} and @var{height} specify the size of the configured
 -source. The default values of @var{width} and @var{height} are
 -respectively 352 and 288 (corresponding to the CIF size format).
 +This source accepts a list of options in the form of
 +@var{key}=@var{value} pairs separated by ":". A description of the
 +accepted options follows.
  
 -@var{timebase} specifies an arithmetic expression representing a
 -timebase. The expression can contain the constants "PI", "E", "PHI",
 -"AVTB" (the default timebase), and defaults to the value "AVTB".
 +@table @option
  
 -@section frei0r_src
 +@item end_pts
 +Set the terminal pts value. Default value is 400.
  
 -Provide a frei0r source.
 +@item end_scale
 +Set the terminal scale value.
 +Must be a floating point value. Default value is 0.3.
  
 -To enable compilation of this filter you need to install the frei0r
 -header and configure Libav with --enable-frei0r.
 +@item inner
 +Set the inner coloring mode, that is the algorithm used to draw the
 +Mandelbrot fractal internal region.
  
 -The source supports the syntax:
 -@example
 -@var{size}:@var{rate}:@var{src_name}[@{=|:@}@var{param1}:@var{param2}:...:@var{paramN}]
 -@end example
 +It shall assume one of the following values:
 +@table @option
 +@item black
 +Set black mode.
 +@item convergence
 +Show time until convergence.
 +@item mincol
 +Set color based on point closest to the origin of the iterations.
 +@item period
 +Set period mode.
 +@end table
  
 -@var{size} is the size of the video to generate, may be a string of the
 -form @var{width}x@var{height} or a frame size abbreviation.
 -@var{rate} is the rate of the video to generate, may be a string of
 -the form @var{num}/@var{den} or a frame rate abbreviation.
 -@var{src_name} is the name to the frei0r source to load. For more
 -information regarding frei0r and how to set the parameters read the
 -section @ref{frei0r} in the description of the video filters.
 +Default value is @var{mincol}.
  
 -Some examples follow:
 -@example
 -# generate a frei0r partik0l source with size 200x200 and framerate 10
 -# which is overlayed on the overlay filter main input
 -frei0r_src=200x200:10:partik0l=1234 [overlay]; [in][overlay] overlay
 -@end example
 +@item bailout
 +Set the bailout value. Default value is 10.0.
  
 -@section rgbtestsrc, testsrc
 +@item maxiter
 +Set the maximum of iterations performed by the rendering
 +algorithm. Default value is 7189.
  
 -The @code{rgbtestsrc} source generates an RGB test pattern useful for
 -detecting RGB vs BGR issues. You should see a red, green and blue
 -stripe from top to bottom.
 +@item outer
 +Set outer coloring mode.
 +It shall assume one of following values:
 +@table @option
 +@item iteration_count
 +Set iteration cound mode.
 +@item normalized_iteration_count
 +set normalized iteration count mode.
 +@end table
 +Default value is @var{normalized_iteration_count}.
  
 -The @code{testsrc} source generates a test video pattern, showing a
 -color pattern, a scrolling gradient and a timestamp. This is mainly
 -intended for testing purposes.
 +@item rate, r
 +Set frame rate, expressed as number of frames per second. Default
 +value is "25".
 +
 +@item size, s
 +Set frame size. Default value is "640x480".
 +
 +@item start_scale
 +Set the initial scale value. Default value is 3.0.
 +
 +@item start_x
 +Set the initial x position. Must be a floating point value between
 +-100 and 100. Default value is -0.743643887037158704752191506114774.
 +
 +@item start_y
 +Set the initial y position. Must be a floating point value between
 +-100 and 100. Default value is -0.131825904205311970493132056385139.
 +@end table
 +
 +@section mptestsrc
  
 -Both sources accept an optional sequence of @var{key}=@var{value} pairs,
 +Generate various test patterns, as generated by the MPlayer test filter.
 +
 +The size of the generated video is fixed, and is 256x256.
 +This source is useful in particular for testing encoding features.
 +
 +This source accepts an optional sequence of @var{key}=@var{value} pairs,
  separated by ":". The description of the accepted options follows.
  
  @table @option
diff --cc ffmpeg.h
+++ b/ffmpeg.h
@@@ -398,9 -360,6 +398,9 @@@ void assert_avoptions(AVDictionary *m)
  
  int guess_input_channel_layout(InputStream *ist);
  
- enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target);
++enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum AVPixelFormat target);
 +void choose_sample_fmt(AVStream *st, AVCodec *codec);
 +
  int configure_filtergraph(FilterGraph *fg);
  int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out);
  int ist_in_filtergraph(FilterGraph *fg, InputStream *ist);
diff --cc ffmpeg_filter.c
  
  #include "libavutil/audioconvert.h"
  #include "libavutil/avassert.h"
 +#include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
  #include "libavutil/pixdesc.h"
  #include "libavutil/pixfmt.h"
 +#include "libavutil/imgutils.h"
  #include "libavutil/samplefmt.h"
  
- enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
++enum AVPixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum AVPixelFormat target)
 +{
 +    if (codec && codec->pix_fmts) {
-         const enum PixelFormat *p = codec->pix_fmts;
++        const enum AVPixelFormat *p = codec->pix_fmts;
 +        int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
-         enum PixelFormat best= PIX_FMT_NONE;
++        enum AVPixelFormat best= AV_PIX_FMT_NONE;
 +        if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 +            if (st->codec->codec_id == AV_CODEC_ID_MJPEG) {
-                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
++                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_NONE };
 +            } else if (st->codec->codec_id == AV_CODEC_ID_LJPEG) {
-                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
-                                                  PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
++                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUV420P,
++                                                 AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };
 +            }
 +        }
-         for (; *p != PIX_FMT_NONE; p++) {
++        for (; *p != AV_PIX_FMT_NONE; p++) {
 +            best= avcodec_find_best_pix_fmt_of_2(best, *p, target, has_alpha, NULL);
 +            if (*p == target)
 +                break;
 +        }
-         if (*p == PIX_FMT_NONE) {
-             if (target != PIX_FMT_NONE)
++        if (*p == AV_PIX_FMT_NONE) {
++            if (target != AV_PIX_FMT_NONE)
 +                av_log(NULL, AV_LOG_WARNING,
 +                       "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 +                       av_pix_fmt_descriptors[target].name,
 +                       codec->name,
 +                       av_pix_fmt_descriptors[best].name);
 +            return best;
 +        }
 +    }
 +    return target;
 +}
 +
 +void choose_sample_fmt(AVStream *st, AVCodec *codec)
 +{
 +    if (codec && codec->sample_fmts) {
 +        const enum AVSampleFormat *p = codec->sample_fmts;
 +        for (; *p != -1; p++) {
 +            if (*p == st->codec->sample_fmt)
 +                break;
 +        }
 +        if (*p == -1) {
 +            if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
 +                av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
 +            if(av_get_sample_fmt_name(st->codec->sample_fmt))
 +            av_log(NULL, AV_LOG_WARNING,
 +                   "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 +                   av_get_sample_fmt_name(st->codec->sample_fmt),
 +                   codec->name,
 +                   av_get_sample_fmt_name(codec->sample_fmts[0]));
 +            st->codec->sample_fmt = codec->sample_fmts[0];
 +        }
 +    }
 +}
 +
 +static char *choose_pix_fmts(OutputStream *ost)
 +{
 +     if (ost->keep_pix_fmt) {
 +        if (ost->filter)
 +            avfilter_graph_set_auto_convert(ost->filter->graph->graph,
 +                                            AVFILTER_AUTO_CONVERT_NONE);
-         if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
++        if (ost->st->codec->pix_fmt == AV_PIX_FMT_NONE)
 +            return NULL;
 +        return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
 +    }
-     if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
++    if (ost->st->codec->pix_fmt != AV_PIX_FMT_NONE) {
 +        return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
 +    } else if (ost->enc && ost->enc->pix_fmts) {
-         const enum PixelFormat *p;
++        const enum AVPixelFormat *p;
 +        AVIOContext *s = NULL;
 +        uint8_t *ret;
 +        int len;
 +
 +        if (avio_open_dyn_buf(&s) < 0)
 +            exit(1);
 +
 +        p = ost->enc->pix_fmts;
 +        if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
 +            if (ost->st->codec->codec_id == AV_CODEC_ID_MJPEG) {
-                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
++                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_NONE };
 +            } else if (ost->st->codec->codec_id == AV_CODEC_ID_LJPEG) {
-                 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
-                                                     PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
++                p = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUV420P,
++                                                    AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_BGRA, AV_PIX_FMT_NONE };
 +            }
 +        }
 +
-         for (; *p != PIX_FMT_NONE; p++) {
++        for (; *p != AV_PIX_FMT_NONE; p++) {
 +            const char *name = av_get_pix_fmt_name(*p);
 +            avio_printf(s, "%s:", name);
 +        }
 +        len = avio_close_dyn_buf(s, &ret);
 +        ret[len - 1] = 0;
 +        return ret;
 +    } else
 +        return NULL;
 +}
 +
  /**
   * Define a function for building a string containing a list of
   * allowed formats,
@@@ -159,8 -59,8 +159,8 @@@ static char *choose_ ## var ## s(Output
          return NULL;                                                           \
  }
  
- // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
 -DEF_CHOOSE_FORMAT(enum AVPixelFormat, pix_fmt, pix_fmts, AV_PIX_FMT_NONE,
 -                  GET_PIX_FMT_NAME, ":")
++// DEF_CHOOSE_FORMAT(enum AVPixelFormat, pix_fmt, pix_fmts, AV_PIX_FMT_NONE,
 +//                   GET_PIX_FMT_NAME, ":")
  
  DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
                    AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
@@@ -498,52 -353,6 +498,52 @@@ int configure_output_filter(FilterGrap
      }
  }
  
-     /* rectangles are PIX_FMT_PAL8, but we have no guarantee that the
 +static int sub2video_prepare(InputStream *ist)
 +{
 +    AVFormatContext *avf = input_files[ist->file_index]->ctx;
 +    int i, ret, w, h;
 +    uint8_t *image[4];
 +    int linesize[4];
 +
 +    /* Compute the size of the canvas for the subtitles stream.
 +       If the subtitles codec has set a size, use it. Otherwise use the
 +       maximum dimensions of the video streams in the same file. */
 +    w = ist->st->codec->width;
 +    h = ist->st->codec->height;
 +    if (!(w && h)) {
 +        for (i = 0; i < avf->nb_streams; i++) {
 +            if (avf->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
 +                w = FFMAX(w, avf->streams[i]->codec->width);
 +                h = FFMAX(h, avf->streams[i]->codec->height);
 +            }
 +        }
 +        if (!(w && h)) {
 +            w = FFMAX(w, 720);
 +            h = FFMAX(h, 576);
 +        }
 +        av_log(avf, AV_LOG_INFO, "sub2video: using %dx%d canvas\n", w, h);
 +    }
 +    ist->sub2video.w = ist->st->codec->width  = w;
 +    ist->sub2video.h = ist->st->codec->height = h;
 +
-     ist->st->codec->pix_fmt = PIX_FMT_RGB32;
++    /* rectangles are AV_PIX_FMT_PAL8, but we have no guarantee that the
 +       palettes for all rectangles are identical or compatible */
-     ret = av_image_alloc(image, linesize, w, h, PIX_FMT_RGB32, 32);
++    ist->st->codec->pix_fmt = AV_PIX_FMT_RGB32;
 +
-             w, h, PIX_FMT_RGB32);
++    ret = av_image_alloc(image, linesize, w, h, AV_PIX_FMT_RGB32, 32);
 +    if (ret < 0)
 +        return ret;
 +    memset(image[0], 0, h * linesize[0]);
 +    ist->sub2video.ref = avfilter_get_video_buffer_ref_from_arrays(
 +            image, linesize, AV_PERM_READ | AV_PERM_PRESERVE,
++            w, h, AV_PIX_FMT_RGB32);
 +    if (!ist->sub2video.ref) {
 +        av_free(image[0]);
 +        return AVERROR(ENOMEM);
 +    }
 +    return 0;
 +}
 +
  static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
                                          AVFilterInOut *in)
  {
diff --cc ffmpeg_opt.c
@@@ -1061,24 -900,11 +1061,24 @@@ static OutputStream *new_video_stream(O
          }
  
          MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
 -        if (frame_aspect_ratio)
 -            ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
 +        if (frame_aspect_ratio) {
 +            AVRational q;
 +            if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
 +                q.num <= 0 || q.den <= 0) {
 +                av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
 +                exit(1);
 +            }
 +            ost->frame_aspect_ratio = av_q2d(q);
 +        }
  
 +        video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
          MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
-         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
 +        if (frame_pix_fmt && *frame_pix_fmt == '+') {
 +            ost->keep_pix_fmt = 1;
 +            if (!*++frame_pix_fmt)
 +                frame_pix_fmt = NULL;
 +        }
+         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
              av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
              exit(1);
          }
diff --cc ffplay.c
+++ b/ffplay.c
@@@ -1462,8 -1400,8 +1462,8 @@@ static int queue_picture(VideoState *is
  #else
          sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
          is->img_convert_ctx = sws_getCachedContext(is->img_convert_ctx,
 -            vp->width, vp->height, vp->pix_fmt, vp->width, vp->height,
 -            dst_pix_fmt, sws_flags, NULL, NULL, NULL);
 +            vp->width, vp->height, src_frame->format, vp->width, vp->height,
-             PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
++            AV_PIX_FMT_YUV420P, sws_flags, NULL, NULL, NULL);
          if (is->img_convert_ctx == NULL) {
              fprintf(stderr, "Cannot initialize the conversion context\n");
              exit(1);
@@@ -1559,47 -1509,8 +1559,47 @@@ static int get_video_frame(VideoState *
  }
  
  #if CONFIG_AVFILTER
 +static int configure_filtergraph(AVFilterGraph *graph, const char *filtergraph,
 +                                 AVFilterContext *source_ctx, AVFilterContext *sink_ctx)
 +{
 +    int ret;
 +    AVFilterInOut *outputs = NULL, *inputs = NULL;
 +
 +    if (filtergraph) {
 +        outputs = avfilter_inout_alloc();
 +        inputs  = avfilter_inout_alloc();
 +        if (!outputs || !inputs) {
 +            ret = AVERROR(ENOMEM);
 +            goto fail;
 +        }
 +
 +        outputs->name       = av_strdup("in");
 +        outputs->filter_ctx = source_ctx;
 +        outputs->pad_idx    = 0;
 +        outputs->next       = NULL;
 +
 +        inputs->name        = av_strdup("out");
 +        inputs->filter_ctx  = sink_ctx;
 +        inputs->pad_idx     = 0;
 +        inputs->next        = NULL;
 +
 +        if ((ret = avfilter_graph_parse(graph, filtergraph, &inputs, &outputs, NULL)) < 0)
 +            goto fail;
 +    } else {
 +        if ((ret = avfilter_link(source_ctx, 0, sink_ctx, 0)) < 0)
 +            goto fail;
 +    }
 +
 +    return avfilter_graph_config(graph, NULL);
 +fail:
 +    avfilter_inout_free(&outputs);
 +    avfilter_inout_free(&inputs);
 +    return ret;
 +}
 +
  static int configure_video_filters(AVFilterGraph *graph, VideoState *is, const char *vfilters)
  {
-     static const enum PixelFormat pix_fmts[] = { PIX_FMT_YUV420P, PIX_FMT_NONE };
++    static const enum AVPixelFormat pix_fmts[] = { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE };
      char sws_flags_str[128];
      char buffersrc_args[256];
      int ret;
@@@ -1666,19 -1593,16 +1666,19 @@@ static int video_thread(void *arg
      int ret;
  
  #if CONFIG_AVFILTER
 +    AVCodecContext *codec = is->video_st->codec;
      AVFilterGraph *graph = avfilter_graph_alloc();
      AVFilterContext *filt_out = NULL, *filt_in = NULL;
 -    int64_t pos;
 -    int last_w = is->video_st->codec->width;
 -    int last_h = is->video_st->codec->height;
 -
 -    if ((ret = configure_video_filters(graph, is, vfilters)) < 0)
 -        goto the_end;
 -    filt_in  = is->in_video_filter;
 -    filt_out = is->out_video_filter;
 +    int last_w = 0;
 +    int last_h = 0;
-     enum PixelFormat last_format = -2;
++    enum AVPixelFormat last_format = -2;
 +
 +    if (codec->codec->capabilities & CODEC_CAP_DR1) {
 +        is->use_dr1 = 1;
 +        codec->get_buffer     = codec_get_buffer;
 +        codec->release_buffer = codec_release_buffer;
 +        codec->opaque         = &is->buffer_pool;
 +    }
  #endif
  
      for (;;) {
Simple merge
@@@ -161,10 -168,9 +161,10 @@@ static av_cold int decode_init(AVCodecC
      c->avctx       = avctx;
      c->pic.data[0] = NULL;
  
 +    avcodec_get_frame_defaults(&c->pic);
      switch (avctx->bits_per_coded_sample) {
      case 8:
-         avctx->pix_fmt = PIX_FMT_PAL8;
+         avctx->pix_fmt = AV_PIX_FMT_PAL8;
          c->planes      = 1;
          c->planemap[0] = 0; // 1st plane is palette indexes
          break;
Simple merge
@@@ -44,32 -41,10 +44,32 @@@ typedef struct AascContext 
  static av_cold int aasc_decode_init(AVCodecContext *avctx)
  {
      AascContext *s = avctx->priv_data;
 +    uint8_t *ptr;
 +    int i;
  
      s->avctx = avctx;
 -
 -    avctx->pix_fmt = AV_PIX_FMT_BGR24;
 +    switch (avctx->bits_per_coded_sample) {
 +    case 8:
-         avctx->pix_fmt = PIX_FMT_PAL8;
++        avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +
 +        ptr = avctx->extradata;
 +        s->palette_size = FFMIN(avctx->extradata_size, AVPALETTE_SIZE);
 +        for (i = 0; i < s->palette_size / 4; i++) {
 +            s->palette[i] = 0xFFU << 24 | AV_RL32(ptr);
 +            ptr += 4;
 +        }
 +        break;
 +    case 16:
-         avctx->pix_fmt = PIX_FMT_RGB555;
++        avctx->pix_fmt = AV_PIX_FMT_RGB555;
 +        break;
 +    case 24:
-         avctx->pix_fmt = PIX_FMT_BGR24;
++        avctx->pix_fmt = AV_PIX_FMT_BGR24;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Unsupported bit depth: %d\n", avctx->bits_per_coded_sample);
 +        return -1;
 +    }
 +    avcodec_get_frame_defaults(&s->frame);
  
      return 0;
  }
@@@ -121,14 -84,6 +121,14 @@@ static int aasc_decode_frame(AVCodecCon
          av_log(avctx, AV_LOG_ERROR, "Unknown compression type %d\n", compr);
          return -1;
      }
-     if (avctx->pix_fmt == PIX_FMT_PAL8)
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Unknown FourCC: %X\n", avctx->codec_tag);
 +        return -1;
 +    }
 +
++    if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
 +        memcpy(s->frame.data[1], s->palette, s->palette_size);
  
      *data_size = sizeof(AVFrame);
      *(AVFrame*)data = s->frame;
@@@ -39,10 -39,9 +39,10 @@@ static av_cold int decode_init(AVCodecC
      AnmContext *s = avctx->priv_data;
      int i;
  
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
 -    s->frame.reference = 1;
 +    avcodec_get_frame_defaults(&s->frame);
 +    s->frame.reference = 3;
      bytestream2_init(&s->gb, avctx->extradata, avctx->extradata_size);
      if (bytestream2_get_bytes_left(&s->gb) < 16 * 8 + 4 * 256)
          return -1;
@@@ -76,10 -74,10 +76,10 @@@ typedef struct 
  static av_cold int decode_init(AVCodecContext *avctx)
  {
      AnsiContext *s = avctx->priv_data;
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
      /* defaults */
 -    s->font        = ff_vga16_font;
 +    s->font        = avpriv_vga16_font;
      s->font_height = 16;
      s->fg          = DEFAULT_FG_COLOR;
      s->bg          = DEFAULT_BG_COLOR;
@@@ -548,9 -553,10 +548,9 @@@ static av_cold int decode_init(AVCodecC
      common_init(avctx);
      init_vlcs(a);
      ff_init_scantable(a->dsp.idct_permutation, &a->scantable, scantab);
-     avctx->pix_fmt= PIX_FMT_YUV420P;
+     avctx->pix_fmt= AV_PIX_FMT_YUV420P;
  
 -    a->inv_qscale= avctx->extradata[0];
 -    if(a->inv_qscale == 0){
 +    if(avctx->extradata_size < 1 || (a->inv_qscale= avctx->extradata[0]) == 0){
          av_log(avctx, AV_LOG_ERROR, "illegal qscale 0\n");
          if(avctx->codec_id == AV_CODEC_ID_ASV1)
              a->inv_qscale= 6;
@@@ -39,8 -39,7 +39,8 @@@ static av_cold int aura_decode_init(AVC
      /* width needs to be divisible by 4 for this codec to work */
      if (avctx->width & 0x3)
          return -1;
-     avctx->pix_fmt = PIX_FMT_YUV422P;
+     avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 +    avcodec_get_frame_defaults(&s->frame);
  
      return 0;
  }
@@@ -1653,9 -1492,9 +1653,9 @@@ typedef struct AVCodecContext 
      int gop_size;
  
      /**
-      * Pixel format, see PIX_FMT_xxx.
+      * Pixel format, see AV_PIX_FMT_xxx.
       * May be set by the demuxer if known from headers.
 -     * May be overriden by the decoder if it knows better.
 +     * May be overridden by the decoder if it knows better.
       * - encoding: Set by user.
       * - decoding: Set by user if known, overridden by libavcodec if known
       */
@@@ -4449,42 -4147,71 +4449,43 @@@ int avpicture_alloc(AVPicture *picture
  void avpicture_free(AVPicture *picture);
  
  /**
 - * Fill in the AVPicture fields.
 - * The fields of the given AVPicture are filled in by using the 'ptr' address
 - * which points to the image data buffer. Depending on the specified picture
 - * format, one or multiple image data pointers and line sizes will be set.
 - * If a planar format is specified, several pointers will be set pointing to
 - * the different picture planes and the line sizes of the different planes
 - * will be stored in the lines_sizes array.
 - * Call with ptr == NULL to get the required size for the ptr buffer.
 - *
 - * To allocate the buffer and fill in the AVPicture fields in one call,
 - * use avpicture_alloc().
 + * Fill in the AVPicture fields, always assume a linesize alignment of
 + * 1.
   *
 - * @param picture AVPicture whose fields are to be filled in
 - * @param ptr Buffer which will contain or contains the actual image data
 - * @param pix_fmt The format in which the picture data is stored.
 - * @param width the width of the image in pixels
 - * @param height the height of the image in pixels
 - * @return size of the image data in bytes
 + * @see av_image_fill_arrays()
   */
  int avpicture_fill(AVPicture *picture, uint8_t *ptr,
-                    enum PixelFormat pix_fmt, int width, int height);
+                    enum AVPixelFormat pix_fmt, int width, int height);
  
  /**
 - * Copy pixel data from an AVPicture into a buffer.
 - * The data is stored compactly, without any gaps for alignment or padding
 - * which may be applied by avpicture_fill().
 - *
 - * @see avpicture_get_size()
 + * Copy pixel data from an AVPicture into a buffer, always assume a
 + * linesize alignment of 1.
   *
 - * @param[in] src AVPicture containing image data
 - * @param[in] pix_fmt The format in which the picture data is stored.
 - * @param[in] width the width of the image in pixels.
 - * @param[in] height the height of the image in pixels.
 - * @param[out] dest A buffer into which picture data will be copied.
 - * @param[in] dest_size The size of 'dest'.
 - * @return The number of bytes written to dest, or a negative value (error code) on error.
 + * @see av_image_copy_to_buffer()
   */
- int avpicture_layout(const AVPicture* src, enum PixelFormat pix_fmt, int width, int height,
+ int avpicture_layout(const AVPicture* src, enum AVPixelFormat pix_fmt,
+                      int width, int height,
                       unsigned char *dest, int dest_size);
  
  /**
   * Calculate the size in bytes that a picture of the given width and height
   * would occupy if stored in the given picture format.
 - * Note that this returns the size of a compact representation as generated
 - * by avpicture_layout(), which can be smaller than the size required for e.g.
 - * avpicture_fill().
 + * Always assume a linesize alignment of 1.
   *
 - * @param pix_fmt the given picture format
 - * @param width the width of the image
 - * @param height the height of the image
 - * @return Image data size in bytes or -1 on error (e.g. too large dimensions).
 + * @see av_image_get_buffer_size().
   */
- int avpicture_get_size(enum PixelFormat pix_fmt, int width, int height);
+ int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height);
  
  /**
   *  deinterlace - if not supported return -1
   */
  int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
-                           enum PixelFormat pix_fmt, int width, int height);
+                           enum AVPixelFormat pix_fmt, int width, int height);
  /**
 - * Copy image src to dst. Wraps av_picture_data_copy() above.
 + * Copy image src to dst. Wraps av_image_copy().
   */
  void av_picture_copy(AVPicture *dst, const AVPicture *src,
-                      enum PixelFormat pix_fmt, int width, int height);
+                      enum AVPixelFormat pix_fmt, int width, int height);
  
  /**
   * Crop image top and left side.
@@@ -4549,10 -4276,9 +4550,10 @@@ unsigned int avcodec_pix_fmt_to_codec_t
   * @param[in] dst_pix_fmt destination pixel format
   * @param[in] src_pix_fmt source pixel format
   * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 - * @return Combination of flags informing you what kind of losses will occur.
 + * @return Combination of flags informing you what kind of losses will occur
 + * (maximum loss for an invalid dst_pix_fmt).
   */
- int avcodec_get_pix_fmt_loss(enum PixelFormat dst_pix_fmt, enum PixelFormat src_pix_fmt,
+ int avcodec_get_pix_fmt_loss(enum AVPixelFormat dst_pix_fmt, enum AVPixelFormat src_pix_fmt,
                               int has_alpha);
  
  #if FF_API_FIND_BEST_PIX_FMT
   * The pixel formats from which it chooses one, are determined by the
   * pix_fmt_mask parameter.
   *
 + * Note, only the first 64 pixel formats will fit in pix_fmt_mask.
 + *
   * @code
-  * src_pix_fmt = PIX_FMT_YUV420P;
-  * pix_fmt_mask = (1 << PIX_FMT_YUV422P) | (1 << PIX_FMT_RGB24);
+  * src_pix_fmt = AV_PIX_FMT_YUV420P;
 - * pix_fmt_mask = (1 << AV_PIX_FMT_YUV422P) || (1 << AV_PIX_FMT_RGB24);
++ * pix_fmt_mask = (1 << AV_PIX_FMT_YUV422P) | (1 << AV_PIX_FMT_RGB24);
   * dst_pix_fmt = avcodec_find_best_pix_fmt(pix_fmt_mask, src_pix_fmt, alpha, &loss);
   * @endcode
   *
@@@ -4604,55 -4328,11 +4605,55 @@@ enum AVPixelFormat avcodec_find_best_pi
   * @param[out] loss_ptr Combination of flags informing you what kind of losses will occur.
   * @return The best pixel format to convert to or -1 if none was found.
   */
- enum PixelFormat avcodec_find_best_pix_fmt_of_list(enum PixelFormat *pix_fmt_list,
-                                             enum PixelFormat src_pix_fmt,
++enum AVPixelFormat avcodec_find_best_pix_fmt_of_list(enum AVPixelFormat *pix_fmt_list,
++                                            enum AVPixelFormat src_pix_fmt,
 +                                            int has_alpha, int *loss_ptr);
 +
 +/**
 + * Find the best pixel format to convert to given a certain source pixel
 + * format and a selection of two destination pixel formats. When converting from
 + * one pixel format to another, information loss may occur.  For example, when converting
 + * from RGB24 to GRAY, the color information will be lost. Similarly, other losses occur when
 + * converting from some formats to other formats. avcodec_find_best_pix_fmt_of_2() selects which of
 + * the given pixel formats should be used to suffer the least amount of loss.
 + *
-  * If one of the destination formats is PIX_FMT_NONE the other pixel format (if valid) will be
++ * If one of the destination formats is AV_PIX_FMT_NONE the other pixel format (if valid) will be
 + * returned.
 + *
 + * @code
-  * src_pix_fmt = PIX_FMT_YUV420P;
-  * dst_pix_fmt1= PIX_FMT_RGB24;
-  * dst_pix_fmt2= PIX_FMT_GRAY8;
-  * dst_pix_fmt3= PIX_FMT_RGB8;
++ * src_pix_fmt = AV_PIX_FMT_YUV420P;
++ * dst_pix_fmt1= AV_PIX_FMT_RGB24;
++ * dst_pix_fmt2= AV_PIX_FMT_GRAY8;
++ * dst_pix_fmt3= AV_PIX_FMT_RGB8;
 + * loss= FF_LOSS_CHROMA; // don't care about chroma loss, so chroma loss will be ignored.
 + * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt1, dst_pix_fmt2, src_pix_fmt, alpha, &loss);
 + * dst_pix_fmt = avcodec_find_best_pix_fmt_of_2(dst_pix_fmt, dst_pix_fmt3, src_pix_fmt, alpha, &loss);
 + * @endcode
 + *
 + * @param[in] dst_pix_fmt1 One of the two destination pixel formats to choose from
 + * @param[in] dst_pix_fmt2 The other of the two destination pixel formats to choose from
 + * @param[in] src_pix_fmt Source pixel format
 + * @param[in] has_alpha Whether the source pixel format alpha channel is used.
 + * @param[in, out] loss_ptr Combination of loss flags. In: selects which of the losses to ignore, i.e.
 + *                               NULL or value of zero means we care about all losses. Out: the loss
 + *                               that occurs when converting from src to selected dst pixel format.
 + * @return The best pixel format to convert to or -1 if none was found.
 + */
- enum PixelFormat avcodec_find_best_pix_fmt_of_2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,
-                                             enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
++enum AVPixelFormat avcodec_find_best_pix_fmt_of_2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
++                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +
 +attribute_deprecated
 +#if AV_HAVE_INCOMPATIBLE_FORK_ABI
- enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat *pix_fmt_list,
-                                             enum PixelFormat src_pix_fmt,
-                                             int has_alpha, int *loss_ptr);
+ enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat *pix_fmt_list,
+                                               enum AVPixelFormat src_pix_fmt,
+                                               int has_alpha, int *loss_ptr);
 +#else
- enum PixelFormat avcodec_find_best_pix_fmt2(enum PixelFormat dst_pix_fmt1, enum PixelFormat dst_pix_fmt2,
-                                             enum PixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
++enum AVPixelFormat avcodec_find_best_pix_fmt2(enum AVPixelFormat dst_pix_fmt1, enum AVPixelFormat dst_pix_fmt2,
++                                            enum AVPixelFormat src_pix_fmt, int has_alpha, int *loss_ptr);
 +#endif
 +
  
- enum PixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum PixelFormat * fmt);
+ enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat * fmt);
  
  /**
   * @}
index cda360d,0000000..207b797
mode 100644,000000..100644
--- /dev/null
@@@ -1,133 -1,0 +1,133 @@@
-     avctx->pix_fmt = PIX_FMT_UYVY422;
 +/*
 + * 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 "mjpeg.h"
 +#include "mjpegdec.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;
 +
 +    // 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)
 +        return ff_mjpeg_decode_init(avctx);
 +
 +    if(avctx->width <= 0 || avctx->height <= 0)
 +        return -1;
 +
 +    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 true_height    = buf_size / (2*avctx->width);
 +    int y;
 +
 +    if(a->is_mjpeg)
 +        return ff_mjpeg_decode_frame(avctx, data, data_size, avpkt);
 +
 +    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(avctx->get_buffer(avctx, p) < 0){
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return -1;
 +    }
 +    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,
 +};
 +
@@@ -159,9 -157,7 +159,9 @@@ avs_decode_frame(AVCodecContext * avctx
  
  static av_cold int avs_decode_init(AVCodecContext * avctx)
  {
-     avctx->pix_fmt = PIX_FMT_PAL8;
 +    AvsContext *const avs = avctx->priv_data;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +    avcodec_get_frame_defaults(&avs->picture);
      avcodec_set_dimensions(avctx, 318, 198);
      return 0;
  }
index ba07a58,0000000..27f0b4c
mode 100644,000000..100644
--- /dev/null
@@@ -1,155 -1,0 +1,155 @@@
-     avctx->pix_fmt = PIX_FMT_YUVA422P;
 +/*
 + * 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 "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 (avctx->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"),
 +};
index 686e52c,0000000..4428232
mode 100644,000000..100644
--- /dev/null
@@@ -1,113 -1,0 +1,113 @@@
-     .pix_fmts     = (const enum PixelFormat[]){ PIX_FMT_UYVY422, PIX_FMT_NONE },
 +/*
 + * AVID Meridien encoder
 + *
 + * 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"
 +
 +static av_cold int avui_encode_init(AVCodecContext *avctx)
 +{
 +    avctx->coded_frame = avcodec_alloc_frame();
 +
 +    if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {
 +        av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");
 +        return AVERROR(EINVAL);
 +    }
 +    if (!avctx->coded_frame) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
 +        return AVERROR(ENOMEM);
 +    }
 +    if (!(avctx->extradata = av_mallocz(24 + FF_INPUT_BUFFER_PADDING_SIZE)))
 +        return AVERROR(ENOMEM);
 +    avctx->extradata_size = 24;
 +    memcpy(avctx->extradata, "\0\0\0\x18""APRGAPRG0001", 16);
 +    if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
 +        avctx->extradata[19] = 2;
 +    } else {
 +        avctx->extradata[19] = 1;
 +    }
 +
 +
 +    return 0;
 +}
 +
 +static int avui_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 +                             const AVFrame *pic, int *got_packet)
 +{
 +    uint8_t *dst, *src = pic->data[0];
 +    int i, j, skip, ret, size, interlaced;
 +
 +    interlaced = avctx->field_order > AV_FIELD_PROGRESSIVE;
 +
 +    if (avctx->height == 486) {
 +        skip = 10;
 +    } else {
 +        skip = 16;
 +    }
 +    size = 2 * avctx->width * (avctx->height + skip) + 8 * interlaced;
 +    if ((ret = ff_alloc_packet2(avctx, pkt, size)) < 0)
 +        return ret;
 +    dst = pkt->data;
 +    if (!interlaced) {
 +        dst += avctx->width * skip;
 +    }
 +
 +    avctx->coded_frame->reference = 0;
 +    avctx->coded_frame->key_frame = 1;
 +    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 +
 +    for (i = 0; i <= interlaced; i++) {
 +        if (interlaced && avctx->height == 486) {
 +            src = pic->data[0] + (1 - i) * pic->linesize[0];
 +        } else {
 +            src = pic->data[0] + i * pic->linesize[0];
 +        }
 +        dst += avctx->width * skip + 4 * i;
 +        for (j = 0; j < avctx->height; j += interlaced + 1) {
 +            memcpy(dst, src, avctx->width * 2);
 +            src += (interlaced + 1) * pic->linesize[0];
 +            dst += avctx->width * 2;
 +        }
 +    }
 +
 +    pkt->flags |= AV_PKT_FLAG_KEY;
 +    *got_packet = 1;
 +    return 0;
 +}
 +
 +static av_cold int avui_encode_close(AVCodecContext *avctx)
 +{
 +    av_freep(&avctx->coded_frame);
 +
 +    return 0;
 +}
 +
 +AVCodec ff_avui_encoder = {
 +    .name         = "avui",
 +    .type         = AVMEDIA_TYPE_VIDEO,
 +    .id           = AV_CODEC_ID_AVUI,
 +    .init         = avui_encode_init,
 +    .encode2      = avui_encode_frame,
 +    .close        = avui_encode_close,
 +    .capabilities = CODEC_CAP_EXPERIMENTAL,
++    .pix_fmts     = (const enum AVPixelFormat[]){ AV_PIX_FMT_UYVY422, AV_PIX_FMT_NONE },
 +    .long_name    = NULL_IF_CONFIG_SMALL("Avid Meridien Uncompressed"),
 +};
@@@ -40,11 -40,10 +40,11 @@@ typedef struct BethsoftvidContext 
  static av_cold int bethsoftvid_decode_init(AVCodecContext *avctx)
  {
      BethsoftvidContext *vid = avctx->priv_data;
 -    vid->frame.reference = 1;
 +    avcodec_get_frame_defaults(&vid->frame);
 +    vid->frame.reference = 3;
      vid->frame.buffer_hints = FF_BUFFER_HINTS_VALID |
          FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
      return 0;
  }
  
@@@ -40,8 -39,7 +40,8 @@@ typedef struct BFIContext 
  static av_cold int bfi_decode_init(AVCodecContext *avctx)
  {
      BFIContext *bfi = avctx->priv_data;
-     avctx->pix_fmt  = PIX_FMT_PAL8;
+     avctx->pix_fmt  = AV_PIX_FMT_PAL8;
 +    avcodec_get_frame_defaults(&bfi->frame);
      bfi->dst        = av_mallocz(avctx->width * avctx->height);
      return 0;
  }
Simple merge
index ecc090b,0000000..9c36b6b
mode 100644,000000..100644
--- /dev/null
@@@ -1,257 -1,0 +1,257 @@@
-     avctx->pix_fmt = PIX_FMT_PAL8;
 +/*
 + * Binary text decoder
 + * eXtended BINary text (XBIN) decoder
 + * iCEDraw File decoder
 + * Copyright (c) 2010 Peter Ross (pross@xvid.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
 + */
 +
 +/**
 + * @file
 + * Binary text decoder
 + * eXtended BINary text (XBIN) decoder
 + * iCEDraw File decoder
 + */
 +
 +#include "libavutil/intreadwrite.h"
 +#include "libavutil/xga_font_data.h"
 +#include "avcodec.h"
 +#include "cga_data.h"
 +#include "bintext.h"
 +
 +typedef struct XbinContext {
 +    AVFrame frame;
 +    int palette[16];
 +    int flags;
 +    int font_height;
 +    const uint8_t *font;
 +    int x, y;
 +} XbinContext;
 +
 +static av_cold int decode_init(AVCodecContext *avctx)
 +{
 +    XbinContext *s = avctx->priv_data;
 +    uint8_t *p;
 +    int i;
 +
++    avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +    p = avctx->extradata;
 +    if (p) {
 +        s->font_height = p[0];
 +        s->flags = p[1];
 +        p += 2;
 +        if(avctx->extradata_size < 2 + (!!(s->flags & BINTEXT_PALETTE))*3*16
 +                                     + (!!(s->flags & BINTEXT_FONT))*s->font_height*256) {
 +            av_log(avctx, AV_LOG_ERROR, "not enough extradata\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +    } else {
 +        s->font_height = 8;
 +        s->flags = 0;
 +    }
 +
 +    if ((s->flags & BINTEXT_PALETTE)) {
 +        for (i = 0; i < 16; i++) {
 +            s->palette[i] = 0xFF000000 | (AV_RB24(p) << 2) | ((AV_RB24(p) >> 4) & 0x30303);
 +            p += 3;
 +        }
 +    } else {
 +        for (i = 0; i < 16; i++)
 +            s->palette[i] = 0xFF000000 | ff_cga_palette[i];
 +    }
 +
 +    if ((s->flags & BINTEXT_FONT)) {
 +        s->font = p;
 +    } else {
 +        switch(s->font_height) {
 +        default:
 +            av_log(avctx, AV_LOG_WARNING, "font height %i not supported\n", s->font_height);
 +            s->font_height = 8;
 +        case 8:
 +            s->font = avpriv_cga_font;
 +            break;
 +        case 16:
 +            s->font = avpriv_vga16_font;
 +            break;
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +#define DEFAULT_BG_COLOR 0
 +av_unused static void hscroll(AVCodecContext *avctx)
 +{
 +    XbinContext *s = avctx->priv_data;
 +    if (s->y < avctx->height - s->font_height) {
 +        s->y += s->font_height;
 +    } else {
 +        memmove(s->frame.data[0], s->frame.data[0] + s->font_height*s->frame.linesize[0],
 +            (avctx->height - s->font_height)*s->frame.linesize[0]);
 +        memset(s->frame.data[0] + (avctx->height - s->font_height)*s->frame.linesize[0],
 +            DEFAULT_BG_COLOR, s->font_height * s->frame.linesize[0]);
 +    }
 +}
 +
 +#define FONT_WIDTH 8
 +
 +/**
 + * Draw character to screen
 + */
 +static void draw_char(AVCodecContext *avctx, int c, int a)
 +{
 +    XbinContext *s = avctx->priv_data;
 +    if (s->y > avctx->height - s->font_height)
 +        return;
 +    ff_draw_pc_font(s->frame.data[0] + s->y * s->frame.linesize[0] + s->x,
 +                    s->frame.linesize[0], s->font, s->font_height, c,
 +                    a & 0x0F, a >> 4);
 +    s->x += FONT_WIDTH;
 +    if (s->x > avctx->width - FONT_WIDTH) {
 +        s->x = 0;
 +        s->y += s->font_height;
 +    }
 +}
 +
 +static int decode_frame(AVCodecContext *avctx,
 +                            void *data, int *data_size,
 +                            AVPacket *avpkt)
 +{
 +    XbinContext *s = avctx->priv_data;
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size = avpkt->size;
 +    const uint8_t *buf_end = buf+buf_size;
 +
 +    s->x = s->y = 0;
 +    s->frame.buffer_hints = FF_BUFFER_HINTS_VALID |
 +                            FF_BUFFER_HINTS_PRESERVE |
 +                            FF_BUFFER_HINTS_REUSABLE;
 +    if (avctx->reget_buffer(avctx, &s->frame)) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return -1;
 +    }
 +    s->frame.pict_type           = AV_PICTURE_TYPE_I;
 +    s->frame.palette_has_changed = 1;
 +    memcpy(s->frame.data[1], s->palette, 16 * 4);
 +
 +    if (avctx->codec_id == AV_CODEC_ID_XBIN) {
 +        while (buf + 2 < buf_end) {
 +            int i,c,a;
 +            int type  = *buf >> 6;
 +            int count = (*buf & 0x3F) + 1;
 +            buf++;
 +            switch (type) {
 +            case 0: //no compression
 +                for (i = 0; i < count && buf + 1 < buf_end; i++) {
 +                    draw_char(avctx, buf[0], buf[1]);
 +                    buf += 2;
 +                }
 +                break;
 +            case 1: //character compression
 +                c = *buf++;
 +                for (i = 0; i < count && buf < buf_end; i++)
 +                    draw_char(avctx, c, *buf++);
 +                break;
 +            case 2: //attribute compression
 +                a = *buf++;
 +                for (i = 0; i < count && buf < buf_end; i++)
 +                    draw_char(avctx, *buf++, a);
 +                break;
 +            case 3: //character/attribute compression
 +                c = *buf++;
 +                a = *buf++;
 +                for (i = 0; i < count && buf < buf_end; i++)
 +                    draw_char(avctx, c, a);
 +                break;
 +            }
 +        }
 +    } else if (avctx->codec_id == AV_CODEC_ID_IDF) {
 +        while (buf + 2 < buf_end) {
 +            if (AV_RL16(buf) == 1) {
 +               int i;
 +               if (buf + 6 > buf_end)
 +                   break;
 +               for (i = 0; i < buf[2]; i++)
 +                   draw_char(avctx, buf[4], buf[5]);
 +               buf += 6;
 +            } else {
 +               draw_char(avctx, buf[0], buf[1]);
 +               buf += 2;
 +            }
 +        }
 +    } else {
 +        while (buf + 1 < buf_end) {
 +            draw_char(avctx, buf[0], buf[1]);
 +            buf += 2;
 +        }
 +    }
 +
 +    *data_size = sizeof(AVFrame);
 +    *(AVFrame*)data = s->frame;
 +    return buf_size;
 +}
 +
 +static av_cold int decode_end(AVCodecContext *avctx)
 +{
 +    XbinContext *s = avctx->priv_data;
 +
 +    if (s->frame.data[0])
 +        avctx->release_buffer(avctx, &s->frame);
 +
 +    return 0;
 +}
 +
 +#if CONFIG_BINTEXT_DECODER
 +AVCodec ff_bintext_decoder = {
 +    .name           = "bintext",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_BINTEXT,
 +    .priv_data_size = sizeof(XbinContext),
 +    .init           = decode_init,
 +    .close          = decode_end,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("Binary text"),
 +};
 +#endif
 +#if CONFIG_XBIN_DECODER
 +AVCodec ff_xbin_decoder = {
 +    .name           = "xbin",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_XBIN,
 +    .priv_data_size = sizeof(XbinContext),
 +    .init           = decode_init,
 +    .close          = decode_end,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("eXtended BINary text"),
 +};
 +#endif
 +#if CONFIG_IDF_DECODER
 +AVCodec ff_idf_decoder = {
 +    .name           = "idf",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_IDF,
 +    .priv_data_size = sizeof(XbinContext),
 +    .init           = decode_init,
 +    .close          = decode_end,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("iCEDraw text"),
 +};
 +#endif
@@@ -145,24 -141,24 +145,24 @@@ static int bmp_decode_frame(AVCodecCont
      switch(depth){
      case 32:
          if(comp == BMP_BITFIELDS){
 -            rgb[0] = (rgb[0] >> 15) & 3;
 -            rgb[1] = (rgb[1] >> 15) & 3;
 -            rgb[2] = (rgb[2] >> 15) & 3;
 -
 -            if(rgb[0] + rgb[1] + rgb[2] != 3 ||
 -               rgb[0] == rgb[1] || rgb[0] == rgb[2] || rgb[1] == rgb[2]){
 -                break;
 +            if (rgb[0] == 0xFF000000 && rgb[1] == 0x00FF0000 && rgb[2] == 0x0000FF00)
-                 avctx->pix_fmt = alpha ? PIX_FMT_ABGR : PIX_FMT_0BGR;
++                avctx->pix_fmt = alpha ? AV_PIX_FMT_ABGR : AV_PIX_FMT_0BGR;
 +            else if (rgb[0] == 0x00FF0000 && rgb[1] == 0x0000FF00 && rgb[2] == 0x000000FF)
-                 avctx->pix_fmt = alpha ? PIX_FMT_BGRA : PIX_FMT_BGR0;
++                avctx->pix_fmt = alpha ? AV_PIX_FMT_BGRA : AV_PIX_FMT_BGR0;
 +            else if (rgb[0] == 0x0000FF00 && rgb[1] == 0x00FF0000 && rgb[2] == 0xFF000000)
-                 avctx->pix_fmt = alpha ? PIX_FMT_ARGB : PIX_FMT_0RGB;
++                avctx->pix_fmt = alpha ? AV_PIX_FMT_ARGB : AV_PIX_FMT_0RGB;
 +            else if (rgb[0] == 0x000000FF && rgb[1] == 0x0000FF00 && rgb[2] == 0x00FF0000)
-                 avctx->pix_fmt = alpha ? PIX_FMT_RGBA : PIX_FMT_RGB0;
++                avctx->pix_fmt = alpha ? AV_PIX_FMT_RGBA : AV_PIX_FMT_RGB0;
 +            else {
 +                av_log(avctx, AV_LOG_ERROR, "Unknown bitfields %0X %0X %0X\n", rgb[0], rgb[1], rgb[2]);
 +                return AVERROR(EINVAL);
              }
          } else {
-             avctx->pix_fmt = PIX_FMT_BGRA;
 -            rgb[0] = 2;
 -            rgb[1] = 1;
 -            rgb[2] = 0;
++            avctx->pix_fmt = AV_PIX_FMT_BGRA;
          }
 -
 -        avctx->pix_fmt = AV_PIX_FMT_BGR24;
          break;
      case 24:
-         avctx->pix_fmt = PIX_FMT_BGR24;
+         avctx->pix_fmt = AV_PIX_FMT_BGR24;
          break;
      case 16:
          if(comp == BMP_RGB)
@@@ -38,26 -37,23 +38,26 @@@ static av_cold int bmp_encode_init(AVCo
      avctx->coded_frame = &s->picture;
  
      switch (avctx->pix_fmt) {
-     case PIX_FMT_BGRA:
++    case AV_PIX_FMT_BGRA:
 +        avctx->bits_per_coded_sample = 32;
 +        break;
-     case PIX_FMT_BGR24:
+     case AV_PIX_FMT_BGR24:
          avctx->bits_per_coded_sample = 24;
          break;
-     case PIX_FMT_RGB555:
-     case PIX_FMT_RGB565:
-     case PIX_FMT_RGB444:
+     case AV_PIX_FMT_RGB555:
+     case AV_PIX_FMT_RGB565:
+     case AV_PIX_FMT_RGB444:
          avctx->bits_per_coded_sample = 16;
          break;
-     case PIX_FMT_RGB8:
-     case PIX_FMT_BGR8:
-     case PIX_FMT_RGB4_BYTE:
-     case PIX_FMT_BGR4_BYTE:
-     case PIX_FMT_GRAY8:
-     case PIX_FMT_PAL8:
+     case AV_PIX_FMT_RGB8:
+     case AV_PIX_FMT_BGR8:
+     case AV_PIX_FMT_RGB4_BYTE:
+     case AV_PIX_FMT_BGR4_BYTE:
+     case AV_PIX_FMT_GRAY8:
+     case AV_PIX_FMT_PAL8:
          avctx->bits_per_coded_sample = 8;
          break;
-     case PIX_FMT_MONOBLACK:
+     case AV_PIX_FMT_MONOBLACK:
          avctx->bits_per_coded_sample = 1;
          break;
      default:
@@@ -93,19 -88,16 +93,19 @@@ static int bmp_encode_frame(AVCodecCont
          pal = rgb565_masks; // abuse pal to hold color masks
          pal_entries = 3;
          break;
-     case PIX_FMT_RGB8:
-     case PIX_FMT_BGR8:
-     case PIX_FMT_RGB4_BYTE:
-     case PIX_FMT_BGR4_BYTE:
-     case PIX_FMT_GRAY8:
+     case AV_PIX_FMT_RGB8:
+     case AV_PIX_FMT_BGR8:
+     case AV_PIX_FMT_RGB4_BYTE:
+     case AV_PIX_FMT_BGR4_BYTE:
+     case AV_PIX_FMT_GRAY8:
 -        ff_set_systematic_pal2((uint32_t*)p->data[1], avctx->pix_fmt);
 +        av_assert1(bit_count == 8);
 +        ff_set_systematic_pal2(palette256, avctx->pix_fmt);
 +        pal = palette256;
 +        break;
-     case PIX_FMT_PAL8:
+     case AV_PIX_FMT_PAL8:
          pal = (uint32_t *)p->data[1];
          break;
-     case PIX_FMT_MONOBLACK:
+     case AV_PIX_FMT_MONOBLACK:
          pal = monoblack_pal;
          break;
      }
@@@ -172,12 -166,12 +172,12 @@@ AVCodec ff_bmp_encoder = 
      .priv_data_size = sizeof(BMPContext),
      .init           = bmp_encode_init,
      .encode2        = bmp_encode_frame,
-     .pix_fmts       = (const enum PixelFormat[]){
-         PIX_FMT_BGRA, PIX_FMT_BGR24,
-         PIX_FMT_RGB565, PIX_FMT_RGB555, PIX_FMT_RGB444,
-         PIX_FMT_RGB8, PIX_FMT_BGR8, PIX_FMT_RGB4_BYTE, PIX_FMT_BGR4_BYTE, PIX_FMT_GRAY8, PIX_FMT_PAL8,
-         PIX_FMT_MONOBLACK,
-         PIX_FMT_NONE
+     .pix_fmts       = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_BGR24,
 -        AV_PIX_FMT_RGB555, AV_PIX_FMT_RGB444, AV_PIX_FMT_RGB565,
++        AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR24,
++        AV_PIX_FMT_RGB565, AV_PIX_FMT_RGB555, AV_PIX_FMT_RGB444,
+         AV_PIX_FMT_RGB8, AV_PIX_FMT_BGR8, AV_PIX_FMT_RGB4_BYTE, AV_PIX_FMT_BGR4_BYTE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_PAL8,
+         AV_PIX_FMT_MONOBLACK,
+         AV_PIX_FMT_NONE
      },
      .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
  };
@@@ -270,13 -266,8 +270,13 @@@ static av_cold int decode_init(AVCodecC
      BMVDecContext * const c = avctx->priv_data;
  
      c->avctx = avctx;
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
 +    if (avctx->width != SCREEN_WIDE || avctx->height != SCREEN_HIGH) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid dimension %dx%d\n", avctx->width, avctx->height);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
      c->pic.reference = 1;
      if (avctx->get_buffer(avctx, &c->pic) < 0) {
          av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
@@@ -47,11 -47,7 +47,11 @@@ typedef enum 
  
  static av_cold int decode_init(AVCodecContext *avctx)
  {
-     avctx->pix_fmt = PIX_FMT_PAL8;
 +    C93DecoderContext * const c93 = avctx->priv_data;
 +
 +    avcodec_get_frame_defaults(&c93->pictures[0]);
 +    avcodec_get_frame_defaults(&c93->pictures[1]);
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
      return 0;
  }
  
Simple merge
Simple merge
Simple merge
@@@ -412,13 -407,12 +412,13 @@@ static av_cold int cinepak_decode_init(
      // check for paletted data
      if (avctx->bits_per_coded_sample != 8) {
          s->palette_video = 0;
-         avctx->pix_fmt = PIX_FMT_YUV420P;
+         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
      } else {
          s->palette_video = 1;
-         avctx->pix_fmt = PIX_FMT_PAL8;
+         avctx->pix_fmt = AV_PIX_FMT_PAL8;
      }
  
 +    avcodec_get_frame_defaults(&s->frame);
      s->frame.data[0] = NULL;
  
      return 0;
@@@ -203,9 -175,8 +203,9 @@@ AVCodec ff_cljr_encoder = 
      .priv_data_size = sizeof(CLJRContext),
      .init           = common_init,
      .encode2        = encode_frame,
-     .pix_fmts       = (const enum PixelFormat[]) { PIX_FMT_YUV411P,
-                                                    PIX_FMT_NONE },
+     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,
+                                                    AV_PIX_FMT_NONE },
      .long_name      = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
 +    .priv_class     = &class,
  };
  #endif
Simple merge
index a631a05,0000000..26e067a
mode 100644,000000..100644
--- /dev/null
@@@ -1,218 -1,0 +1,218 @@@
-     avctx->pix_fmt = PIX_FMT_YUV420P;
 +/*
 + * CPiA video decoder.
 + * Copyright (c) 2010 Hans de Goede <hdegoede@redhat.com>
 + *
 + * This decoder is based on the LGPL code available at
 + * https://v4l4j.googlecode.com/svn/v4l4j/trunk/libvideo/libv4lconvert/cpia1.c
 + *
 + * 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 "get_bits.h"
 +
 +
 +#define FRAME_HEADER_SIZE 64
 +#define MAGIC_0         0x19    /**< First header byte */
 +#define MAGIC_1         0x68    /**< Second header byte */
 +#define SUBSAMPLE_420      0
 +#define SUBSAMPLE_422      1
 +#define YUVORDER_YUYV      0
 +#define YUVORDER_UYVY      1
 +#define NOT_COMPRESSED     0
 +#define COMPRESSED         1
 +#define NO_DECIMATION      0
 +#define DECIMATION_ENAB    1
 +#define EOL             0xfd    /**< End Of Line marker */
 +#define EOI             0xff    /**< End Of Image marker */
 +
 +
 +typedef struct {
 +    AVFrame frame;
 +} CpiaContext;
 +
 +
 +static int cpia_decode_frame(AVCodecContext* avctx,
 +        void* data, int* data_size, AVPacket* avpkt)
 +{
 +    CpiaContext* const cpia = avctx->priv_data;
 +    int i,j,ret;
 +
 +    uint8_t* const header = avpkt->data;
 +    uint8_t* src;
 +    int src_size;
 +    uint16_t linelength;
 +    uint8_t skip;
 +
 +    AVFrame* const frame = &cpia->frame;
 +    uint8_t *y, *u, *v, *y_end, *u_end, *v_end;
 +
 +    // Check header
 +    if ( avpkt->size < FRAME_HEADER_SIZE
 +      || header[0] != MAGIC_0 || header[1] != MAGIC_1
 +      || (header[17] != SUBSAMPLE_420 && header[17] != SUBSAMPLE_422)
 +      || (header[18] != YUVORDER_YUYV && header[18] != YUVORDER_UYVY)
 +      || (header[28] != NOT_COMPRESSED && header[28] != COMPRESSED)
 +      || (header[29] != NO_DECIMATION && header[29] != DECIMATION_ENAB)
 +    ) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid header!\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    // currently unsupported properties
 +    if (header[17] == SUBSAMPLE_422) {
 +        av_log(avctx, AV_LOG_ERROR, "Unsupported subsample!\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +    if (header[18] == YUVORDER_UYVY) {
 +        av_log(avctx, AV_LOG_ERROR, "Unsupported YUV byte order!\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +    if (header[29] == DECIMATION_ENAB) {
 +        av_log(avctx, AV_LOG_ERROR, "Decimation unsupported!\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    src = header + FRAME_HEADER_SIZE;
 +    src_size = avpkt->size - FRAME_HEADER_SIZE;
 +
 +    if (header[28] == NOT_COMPRESSED) {
 +        frame->pict_type = AV_PICTURE_TYPE_I;
 +        frame->key_frame = 1;
 +    } else {
 +        frame->pict_type = AV_PICTURE_TYPE_P;
 +        frame->key_frame = 0;
 +    }
 +
 +    // Get buffer filled with previous frame
 +    if ((ret = avctx->reget_buffer(avctx, frame)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed!\n");
 +        return ret;
 +    }
 +
 +
 +    for ( i = 0;
 +          i < frame->height;
 +          i++, src += linelength, src_size -= linelength
 +    ) {
 +        // Read line length, two byte little endian
 +        linelength = AV_RL16(src);
 +        src += 2;
 +
 +        if (src_size < linelength) {
 +            frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
 +            av_log(avctx, AV_LOG_WARNING, "Frame ended enexpectedly!\n");
 +            break;
 +        }
 +        if (src[linelength - 1] != EOL) {
 +            frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
 +            av_log(avctx, AV_LOG_WARNING, "Wrong line length %d or line not terminated properly (found 0x%02x)!\n", linelength, src[linelength - 1]);
 +            break;
 +        }
 +
 +        /* Update the data pointers. Y data is on every line.
 +         * U and V data on every second line
 +         */
 +        y = &frame->data[0][i * frame->linesize[0]];
 +        u = &frame->data[1][(i >> 1) * frame->linesize[1]];
 +        v = &frame->data[2][(i >> 1) * frame->linesize[2]];
 +        y_end = y + frame->linesize[0] - 1;
 +        u_end = u + frame->linesize[1] - 1;
 +        v_end = v + frame->linesize[2] - 1;
 +
 +        if ((i & 1) && header[17] == SUBSAMPLE_420) {
 +            /* We are on a odd line and 420 subsample is used.
 +             * On this line only Y values are specified, one per pixel.
 +             */
 +            for (j = 0; j < linelength - 1; j++) {
 +                if (y > y_end) {
 +                    frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
 +                    av_log(avctx, AV_LOG_WARNING, "Decoded data exceeded linesize!\n");
 +                    break;
 +                }
 +                if ((src[j] & 1) && header[28] == COMPRESSED) {
 +                    /* It seems that odd lines are always uncompressed, but
 +                     * we do it according to specification anyways.
 +                     */
 +                    skip = src[j] >> 1;
 +                    y += skip;
 +                } else {
 +                    *(y++) = src[j];
 +                }
 +            }
 +        } else if (header[17] == SUBSAMPLE_420) {
 +            /* We are on an even line and 420 subsample is used.
 +             * On this line each pair of pixels is described by four bytes.
 +             */
 +            for (j = 0; j < linelength - 4; ) {
 +                if (y + 1 > y_end || u > u_end || v > v_end) {
 +                    frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
 +                    av_log(avctx, AV_LOG_WARNING, "Decoded data exceeded linesize!\n");
 +                    break;
 +                }
 +                if ((src[j] & 1) && header[28] == COMPRESSED) {
 +                    // Skip amount of pixels and move forward one byte
 +                    skip = src[j] >> 1;
 +                    y += skip;
 +                    u += skip >> 1;
 +                    v += skip >> 1;
 +                    j++;
 +                } else {
 +                    // Set image data as specified and move forward 4 bytes
 +                    *(y++) = src[j];
 +                    *(u++) = src[j+1];
 +                    *(y++) = src[j+2];
 +                    *(v++) = src[j+3];
 +                    j += 4;
 +                }
 +            }
 +        }
 +    }
 +
 +    *data_size = sizeof(AVFrame);
 +    *(AVFrame*) data = *frame;
 +
 +    return avpkt->size;
 +}
 +
 +static av_cold int cpia_decode_init(AVCodecContext *avctx)
 +{
 +    // output pixel format
++    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 +
 +    /* The default timebase set by the v4l2 demuxer leads to probing which is buggy.
 +     * Set some reasonable time_base to skip this.
 +     */
 +    if (avctx->time_base.num == 1 && avctx->time_base.den == 1000000) {
 +        avctx->time_base.num = 1;
 +        avctx->time_base.den = 60;
 +    }
 +
 +    return 0;
 +}
 +
 +
 +AVCodec ff_cpia_decoder = {
 +    .name           = "cpia",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_CPIA,
 +    .priv_data_size = sizeof(CpiaContext),
 +    .init           = cpia_decode_init,
 +    .decode         = cpia_decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name      = NULL_IF_CONFIG_SMALL("CPiA video format"),
 +};
index 503baaa,0000000..334337e
mode 100644,000000..100644
--- /dev/null
@@@ -1,1225 -1,0 +1,1225 @@@
-     avctx->pix_fmt = PIX_FMT_YUYV422;
 +/*
 + * - 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 "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, 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);
 +
-     .pix_fmts       = (const enum PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    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 (avctx->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 PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    .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 PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    .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 PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    .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 PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    .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 PixelFormat[]){PIX_FMT_YUYV422, PIX_FMT_NONE},
++    .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
@@@ -127,9 -222,9 +127,9 @@@ static av_cold int decode_init(AVCodecC
      CamStudioContext *c = avctx->priv_data;
      int stride;
      switch (avctx->bits_per_coded_sample) {
-         case 16: avctx->pix_fmt = PIX_FMT_RGB555LE; break;
-         case 24: avctx->pix_fmt = PIX_FMT_BGR24; break;
-         case 32: avctx->pix_fmt = PIX_FMT_BGRA; break;
 -        case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555; break;
++        case 16: avctx->pix_fmt = AV_PIX_FMT_RGB555LE; break;
+         case 24: avctx->pix_fmt = AV_PIX_FMT_BGR24; break;
 -        case 32: avctx->pix_fmt = AV_PIX_FMT_RGB32; break;
++        case 32: avctx->pix_fmt = AV_PIX_FMT_BGRA; break;
          default:
              av_log(avctx, AV_LOG_ERROR,
                     "CamStudio codec error: invalid depth %i bpp\n",
@@@ -92,11 -91,7 +92,11 @@@ static int cyuv_decode_frame(AVCodecCon
       * followed by (height) lines each with 3 bytes to represent groups
       * of 4 pixels. Thus, the total size of the buffer ought to be:
       *    (3 * 16) + height * (width * 3 / 4) */
 -    if (buf_size != 48 + s->height * (s->width * 3 / 4)) {
 +    if (buf_size == 48 + s->height * (s->width * 3 / 4)) {
-         avctx->pix_fmt = PIX_FMT_YUV411P;
++        avctx->pix_fmt = AV_PIX_FMT_YUV411P;
 +    } else if(buf_size == rawsize ) {
-         avctx->pix_fmt = PIX_FMT_UYVY422;
++        avctx->pix_fmt = AV_PIX_FMT_UYVY422;
 +    } else {
          av_log(avctx, AV_LOG_ERROR, "got a buffer with %d bytes when %d were expected\n",
                 buf_size, 48 + s->height * (s->width * 3 / 4));
          return -1;
@@@ -37,13 -36,12 +37,13 @@@ typedef struct DfaContext 
  static av_cold int dfa_decode_init(AVCodecContext *avctx)
  {
      DfaContext *s = avctx->priv_data;
 -    int ret;
  
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
 -    if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
 -        return ret;
 +    if (!avctx->width || !avctx->height)
 +        return AVERROR_INVALIDDATA;
 +
 +    av_assert0(av_image_check_size(avctx->width, avctx->height, 0, avctx) >= 0);
  
      s->frame_buf = av_mallocz(avctx->width * avctx->height + AV_LZO_OUTPUT_PADDING);
      if (!s->frame_buf)
Simple merge
Simple merge
@@@ -1021,10 -1005,9 +1021,10 @@@ AVCodec ff_dnxhd_encoder = 
      .encode2        = dnxhd_encode_picture,
      .close          = dnxhd_encode_end,
      .capabilities   = CODEC_CAP_SLICE_THREADS,
-     .pix_fmts       = (const enum PixelFormat[]){ PIX_FMT_YUV422P,
-                                                   PIX_FMT_YUV422P10,
-                                                   PIX_FMT_NONE },
+     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P,
+                                                   AV_PIX_FMT_YUV422P10,
+                                                   AV_PIX_FMT_NONE },
      .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
      .priv_class     = &class,
 +    .defaults       = dnxhd_defaults,
  };
@@@ -131,33 -132,21 +131,33 @@@ static int decode_frame(AVCodecContext 
              }
              source_packet_size = elements;
              target_packet_size = elements;
 +            planar = 0;
              break;
          case 10:
-             avctx->pix_fmt = PIX_FMT_GBRP10;
 -            avctx->pix_fmt = AV_PIX_FMT_RGB48;
++            avctx->pix_fmt = AV_PIX_FMT_GBRP10;
              target_packet_size = 6;
              source_packet_size = 4;
 +            planar = 1;
              break;
          case 12:
 -        case 16:
              if (endian) {
-                 avctx->pix_fmt = elements == 4 ? PIX_FMT_GBRP12BE : PIX_FMT_GBRP12BE;
 -                avctx->pix_fmt = AV_PIX_FMT_RGB48BE;
++                avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_GBRP12BE : AV_PIX_FMT_GBRP12BE;
              } else {
-                 avctx->pix_fmt = elements == 4 ? PIX_FMT_GBRP12LE : PIX_FMT_GBRP12LE;
 -                avctx->pix_fmt = AV_PIX_FMT_RGB48LE;
++                avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_GBRP12LE : AV_PIX_FMT_GBRP12LE;
              }
              target_packet_size = 6;
-                 avctx->pix_fmt = elements == 4 ? PIX_FMT_RGBA64BE : PIX_FMT_RGB48BE;
 +            source_packet_size = 6;
 +            planar = 1;
 +            break;
 +        case 16:
 +            if (endian) {
-                 avctx->pix_fmt = elements == 4 ? PIX_FMT_RGBA64LE : PIX_FMT_RGB48LE;
++                avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_RGBA64BE : AV_PIX_FMT_RGB48BE;
 +            } else {
++                avctx->pix_fmt = elements == 4 ? AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_RGB48LE;
 +            }
 +            target_packet_size =
              source_packet_size = elements * 2;
 +            planar = 0;
              break;
          default:
              av_log(avctx, AV_LOG_ERROR, "Unsupported color depth : %d\n", bits_per_color);
@@@ -44,37 -43,18 +44,37 @@@ static av_cold int encode_init(AVCodecC
      s->big_endian         = 1;
      s->bits_per_component = 8;
      s->descriptor         = 50; /* RGB */
 +    s->planar             = 0;
  
      switch (avctx->pix_fmt) {
-     case PIX_FMT_RGB24:
+     case AV_PIX_FMT_RGB24:
          break;
-     case PIX_FMT_RGBA:
+     case AV_PIX_FMT_RGBA:
          s->descriptor = 51; /* RGBA */
          break;
-     case PIX_FMT_RGB48LE:
+     case AV_PIX_FMT_RGB48LE:
          s->big_endian = 0;
-     case PIX_FMT_RGB48BE:
+     case AV_PIX_FMT_RGB48BE:
          s->bits_per_component = avctx->bits_per_raw_sample ? avctx->bits_per_raw_sample : 16;
          break;
-     case PIX_FMT_RGBA64LE:
++    case AV_PIX_FMT_RGBA64LE:
 +        s->big_endian = 0;
-     case PIX_FMT_RGBA64BE:
++    case AV_PIX_FMT_RGBA64BE:
 +        s->descriptor = 51;
 +        s->bits_per_component = 16;
 +        break;
-     case PIX_FMT_GBRP10LE:
++    case AV_PIX_FMT_GBRP10LE:
 +        s->big_endian = 0;
-     case PIX_FMT_GBRP10BE:
++    case AV_PIX_FMT_GBRP10BE:
 +        s->bits_per_component = 10;
 +        s->planar = 1;
 +        break;
-     case PIX_FMT_GBRP12LE:
++    case AV_PIX_FMT_GBRP12LE:
 +        s->big_endian = 0;
-     case PIX_FMT_GBRP12BE:
++    case AV_PIX_FMT_GBRP12BE:
 +        s->bits_per_component = 12;
 +        s->planar = 1;
 +        break;
      default:
          av_log(avctx, AV_LOG_INFO, "unsupported pixel format\n");
          return -1;
@@@ -246,17 -180,11 +246,17 @@@ AVCodec ff_dpx_encoder = 
      .priv_data_size = sizeof(DPXContext),
      .init   = encode_init,
      .encode2 = encode_frame,
-     .pix_fmts = (const enum PixelFormat[]){
-         PIX_FMT_RGB24,
-         PIX_FMT_RGBA,
-         PIX_FMT_RGB48LE,
-         PIX_FMT_RGB48BE,
-         PIX_FMT_RGBA64LE,
-         PIX_FMT_RGBA64BE,
-         PIX_FMT_GBRP10LE,
-         PIX_FMT_GBRP10BE,
-         PIX_FMT_GBRP12LE,
-         PIX_FMT_GBRP12BE,
-         PIX_FMT_NONE},
+     .pix_fmts = (const enum AVPixelFormat[]){
+         AV_PIX_FMT_RGB24,
+         AV_PIX_FMT_RGBA,
+         AV_PIX_FMT_RGB48LE,
+         AV_PIX_FMT_RGB48BE,
++        AV_PIX_FMT_RGBA64LE,
++        AV_PIX_FMT_RGBA64BE,
++        AV_PIX_FMT_GBRP10LE,
++        AV_PIX_FMT_GBRP10BE,
++        AV_PIX_FMT_GBRP12LE,
++        AV_PIX_FMT_GBRP12BE,
+         AV_PIX_FMT_NONE},
      .long_name = NULL_IF_CONFIG_SMALL("DPX image"),
  };
@@@ -93,9 -93,8 +93,9 @@@ static av_cold int cinvideo_decode_init
      unsigned int i;
  
      cin->avctx = avctx;
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
 +    avcodec_get_frame_defaults(&cin->frame);
      cin->frame.data[0] = NULL;
  
      cin->bitmap_size = avctx->width * avctx->height;
diff --cc libavcodec/dv.c
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -292,11 -292,8 +292,11 @@@ static av_cold int decode_init(AVCodecC
  {
      DxaDecContext * const c = avctx->priv_data;
  
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  
 +    avcodec_get_frame_defaults(&c->pic);
 +    avcodec_get_frame_defaults(&c->prev);
 +
      c->dsize = avctx->width * avctx->height * 2;
      if((c->decomp_buf = av_malloc(c->dsize)) == NULL) {
          av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
Simple merge
Simple merge
Simple merge
@@@ -44,12 -44,8 +44,12 @@@ typedef struct CmvContext 
  
  static av_cold int cmv_decode_init(AVCodecContext *avctx){
      CmvContext *s = avctx->priv_data;
 +    avcodec_get_frame_defaults(&s->frame);
 +    avcodec_get_frame_defaults(&s->last_frame);
 +    avcodec_get_frame_defaults(&s->last2_frame);
 +
      s->avctx = avctx;
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
      return 0;
  }
  
Simple merge
Simple merge
@@@ -54,9 -54,7 +54,9 @@@ static av_cold int tgv_decode_init(AVCo
      TgvContext *s = avctx->priv_data;
      s->avctx = avctx;
      avctx->time_base = (AVRational){1, 15};
-     avctx->pix_fmt = PIX_FMT_PAL8;
+     avctx->pix_fmt = AV_PIX_FMT_PAL8;
 +    avcodec_get_frame_defaults(&s->frame);
 +    avcodec_get_frame_defaults(&s->last_frame);
      return 0;
  }
  
Simple merge
@@@ -61,8 -61,7 +61,8 @@@ static av_cold int escape124_decode_ini
  {
      Escape124Context *s = avctx->priv_data;
  
-     avctx->pix_fmt = PIX_FMT_RGB555;
 +    avcodec_get_frame_defaults(&s->frame);
+     avctx->pix_fmt = AV_PIX_FMT_RGB555;
  
      s->num_superblocks = ((unsigned)avctx->width / 8) *
                           ((unsigned)avctx->height / 8);
index 47e7f11,0000000..97547bb
mode 100644,000000..100644
--- /dev/null
@@@ -1,319 -1,0 +1,319 @@@
-     avctx->pix_fmt = PIX_FMT_YUV420P;
 +/*
 + * 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"
 +
 +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 (avctx->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"),
 +};
index 7caacd9,0000000..5b4c26d
mode 100644,000000..100644
--- /dev/null
@@@ -1,674 -1,0 +1,674 @@@
-             avctx->pix_fmt = PIX_FMT_RGBA64;
 +/*
 + * OpenEXR (.exr) image decoder
 + * Copyright (c) 2009 Jimmy Christensen
 + *
 + * 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
 + * OpenEXR decoder
 + * @author Jimmy Christensen
 + *
 + * For more information on the OpenEXR format, visit:
 + *  http://openexr.com/
 + *
 + * exr_flt2uint() and exr_halflt2uint() is credited to  Reimar Döffinger
 + */
 +
 +#include <zlib.h>
 +
 +#include "avcodec.h"
 +#include "bytestream.h"
 +#include "mathops.h"
 +#include "thread.h"
 +#include "libavutil/imgutils.h"
 +
 +enum ExrCompr {
 +    EXR_RAW   = 0,
 +    EXR_RLE   = 1,
 +    EXR_ZIP1  = 2,
 +    EXR_ZIP16 = 3,
 +    EXR_PIZ   = 4,
 +    EXR_B44   = 6,
 +    EXR_B44A  = 7,
 +};
 +
 +typedef struct EXRContext {
 +    AVFrame picture;
 +    int compr;
 +    int bits_per_color_id;
 +    int channel_offsets[4]; // 0 = red, 1 = green, 2 = blue and 3 = alpha
 +
 +    uint8_t *uncompressed_data;
 +    int uncompressed_size;
 +
 +    uint8_t *tmp;
 +    int tmp_size;
 +} EXRContext;
 +
 +/**
 + * Converts from 32-bit float as uint32_t to uint16_t
 + *
 + * @param v 32-bit float
 + * @return normalized 16-bit unsigned int
 + */
 +static inline uint16_t exr_flt2uint(uint32_t v)
 +{
 +    unsigned int exp = v >> 23;
 +    // "HACK": negative values result in exp<  0, so clipping them to 0
 +    // is also handled by this condition, avoids explicit check for sign bit.
 +    if (exp<= 127 + 7 - 24) // we would shift out all bits anyway
 +        return 0;
 +    if (exp >= 127)
 +        return 0xffff;
 +    v &= 0x007fffff;
 +    return (v + (1 << 23)) >> (127 + 7 - exp);
 +}
 +
 +/**
 + * Converts from 16-bit float as uint16_t to uint16_t
 + *
 + * @param v 16-bit float
 + * @return normalized 16-bit unsigned int
 + */
 +static inline uint16_t exr_halflt2uint(uint16_t v)
 +{
 +    unsigned exp = 14 - (v >> 10);
 +    if (exp >= 14) {
 +        if (exp == 14) return (v >> 9) & 1;
 +        else           return (v & 0x8000) ? 0 : 0xffff;
 +    }
 +    v <<= 6;
 +    return (v + (1 << 16)) >> (exp + 1);
 +}
 +
 +/**
 + * Gets the size of the header variable
 + *
 + * @param **buf the current pointer location in the header where
 + * the variable data starts
 + * @param *buf_end pointer location of the end of the buffer
 + * @return size of variable data
 + */
 +static unsigned int get_header_variable_length(const uint8_t **buf,
 +                                               const uint8_t *buf_end)
 +{
 +    unsigned int variable_buffer_data_size = bytestream_get_le32(buf);
 +    if (variable_buffer_data_size >= buf_end - *buf)
 +        return 0;
 +    return variable_buffer_data_size;
 +}
 +
 +/**
 + * Checks if the variable name corresponds with it's data type
 + *
 + * @param *avctx the AVCodecContext
 + * @param **buf the current pointer location in the header where
 + * the variable name starts
 + * @param *buf_end pointer location of the end of the buffer
 + * @param *value_name name of the varible to check
 + * @param *value_type type of the varible to check
 + * @param minimum_length minimum length of the variable data
 + * @param variable_buffer_data_size variable length read from the header
 + * after it's checked
 + * @return negative if variable is invalid
 + */
 +static int check_header_variable(AVCodecContext *avctx,
 +                                              const uint8_t **buf,
 +                                              const uint8_t *buf_end,
 +                                              const char *value_name,
 +                                              const char *value_type,
 +                                              unsigned int minimum_length,
 +                                              unsigned int *variable_buffer_data_size)
 +{
 +    if (buf_end - *buf >= minimum_length && !strcmp(*buf, value_name)) {
 +        *buf += strlen(value_name)+1;
 +        if (!strcmp(*buf, value_type)) {
 +            *buf += strlen(value_type)+1;
 +            *variable_buffer_data_size = get_header_variable_length(buf, buf_end);
 +            if (!*variable_buffer_data_size)
 +                av_log(avctx, AV_LOG_ERROR, "Incomplete header\n");
 +            if (*variable_buffer_data_size > buf_end - *buf)
 +                return -1;
 +            return 1;
 +        }
 +        *buf -= strlen(value_name)+1;
 +        av_log(avctx, AV_LOG_WARNING, "Unknown data type for header variable %s\n", value_name);
 +    }
 +    return -1;
 +}
 +
 +static void predictor(uint8_t *src, int size)
 +{
 +    uint8_t *t = src + 1;
 +    uint8_t *stop = src + size;
 +
 +    while (t < stop) {
 +        int d = (int)t[-1] + (int)t[0] - 128;
 +        t[0] = d;
 +        ++t;
 +    }
 +}
 +
 +static void reorder_pixels(uint8_t *src, uint8_t *dst, int size)
 +{
 +    const int8_t *t1 = src;
 +    const int8_t *t2 = src + (size + 1) / 2;
 +    int8_t *s = dst;
 +    int8_t *stop = s + size;
 +
 +    while (1) {
 +        if (s < stop)
 +            *(s++) = *(t1++);
 +        else
 +            break;
 +
 +        if (s < stop)
 +            *(s++) = *(t2++);
 +        else
 +            break;
 +    }
 +}
 +
 +static int rle_uncompress(const uint8_t *src, int ssize, uint8_t *dst, int dsize)
 +{
 +    int8_t *d = (int8_t *)dst;
 +    int8_t *s = (int8_t *)src;
 +    int8_t *dend = d + dsize;
 +    int count;
 +
 +    while (ssize > 0) {
 +        count = *s++;
 +
 +        if (count < 0) {
 +            count = -count;
 +
 +            if ((dsize -= count    ) < 0 ||
 +                (ssize -= count + 1) < 0)
 +                return -1;
 +
 +            while (count--)
 +                *d++ = *s++;
 +        } else {
 +            count++;
 +
 +            if ((dsize -= count) < 0 ||
 +                (ssize -= 2    ) < 0)
 +                return -1;
 +
 +            while (count--)
 +                *d++ = *s;
 +
 +            s++;
 +        }
 +    }
 +
 +    return dend != d;
 +}
 +
 +static int decode_frame(AVCodecContext *avctx,
 +                        void *data,
 +                        int *data_size,
 +                        AVPacket *avpkt)
 +{
 +    const uint8_t *buf      = avpkt->data;
 +    unsigned int   buf_size = avpkt->size;
 +    const uint8_t *buf_end  = buf + buf_size;
 +
 +    EXRContext *const s = avctx->priv_data;
 +    AVFrame *picture  = data;
 +    AVFrame *const p = &s->picture;
 +    uint8_t *ptr;
 +
 +    int i, x, y, stride, magic_number, version_flag, ret;
 +    int w = 0;
 +    int h = 0;
 +    unsigned int xmin   = ~0;
 +    unsigned int xmax   = ~0;
 +    unsigned int ymin   = ~0;
 +    unsigned int ymax   = ~0;
 +    unsigned int xdelta = ~0;
 +
 +    int out_line_size;
 +    int bxmin, axmax;
 +    int scan_lines_per_block;
 +    unsigned long scan_line_size;
 +    unsigned long uncompressed_size;
 +
 +    unsigned int current_channel_offset = 0;
 +
 +    s->channel_offsets[0] = -1;
 +    s->channel_offsets[1] = -1;
 +    s->channel_offsets[2] = -1;
 +    s->channel_offsets[3] = -1;
 +    s->bits_per_color_id = -1;
 +
 +    if (buf_size < 10) {
 +        av_log(avctx, AV_LOG_ERROR, "Too short header to parse\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    magic_number = bytestream_get_le32(&buf);
 +    if (magic_number != 20000630) { // As per documentation of OpenEXR it's supposed to be int 20000630 little-endian
 +        av_log(avctx, AV_LOG_ERROR, "Wrong magic number %d\n", magic_number);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    version_flag = bytestream_get_le32(&buf);
 +    if ((version_flag & 0x200) == 0x200) {
 +        av_log(avctx, AV_LOG_ERROR, "Tile based images are not supported\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    // Parse the header
 +    while (buf < buf_end && buf[0]) {
 +        unsigned int variable_buffer_data_size;
 +        // Process the channel list
 +        if (check_header_variable(avctx, &buf, buf_end, "channels", "chlist", 38, &variable_buffer_data_size) >= 0) {
 +            const uint8_t *channel_list_end;
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            channel_list_end = buf + variable_buffer_data_size;
 +            while (channel_list_end - buf >= 19) {
 +                int current_bits_per_color_id = -1;
 +                int channel_index = -1;
 +
 +                if (!strcmp(buf, "R"))
 +                    channel_index = 0;
 +                else if (!strcmp(buf, "G"))
 +                    channel_index = 1;
 +                else if (!strcmp(buf, "B"))
 +                    channel_index = 2;
 +                else if (!strcmp(buf, "A"))
 +                    channel_index = 3;
 +                else
 +                    av_log(avctx, AV_LOG_WARNING, "Unsupported channel %.256s\n", buf);
 +
 +                while (bytestream_get_byte(&buf) && buf < channel_list_end)
 +                    continue; /* skip */
 +
 +                if (channel_list_end - * &buf < 4) {
 +                    av_log(avctx, AV_LOG_ERROR, "Incomplete header\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
 +
 +                current_bits_per_color_id = bytestream_get_le32(&buf);
 +                if (current_bits_per_color_id > 2) {
 +                    av_log(avctx, AV_LOG_ERROR, "Unknown color format\n");
 +                    return AVERROR_INVALIDDATA;
 +                }
 +
 +                if (channel_index >= 0) {
 +                    if (s->bits_per_color_id != -1 && s->bits_per_color_id != current_bits_per_color_id) {
 +                        av_log(avctx, AV_LOG_ERROR, "RGB channels not of the same depth\n");
 +                        return AVERROR_INVALIDDATA;
 +                    }
 +                    s->bits_per_color_id  = current_bits_per_color_id;
 +                    s->channel_offsets[channel_index] = current_channel_offset;
 +                }
 +
 +                current_channel_offset += 1 << current_bits_per_color_id;
 +                buf += 12;
 +            }
 +
 +            /* Check if all channels are set with an offset or if the channels
 +             * are causing an overflow  */
 +
 +            if (FFMIN3(s->channel_offsets[0],
 +                       s->channel_offsets[1],
 +                       s->channel_offsets[2]) < 0) {
 +                if (s->channel_offsets[0] < 0)
 +                    av_log(avctx, AV_LOG_ERROR, "Missing red channel\n");
 +                if (s->channel_offsets[1] < 0)
 +                    av_log(avctx, AV_LOG_ERROR, "Missing green channel\n");
 +                if (s->channel_offsets[2] < 0)
 +                    av_log(avctx, AV_LOG_ERROR, "Missing blue channel\n");
 +                return AVERROR_INVALIDDATA;
 +            }
 +
 +            buf = channel_list_end;
 +            continue;
 +        }
 +
 +        // Process the dataWindow variable
 +        if (check_header_variable(avctx, &buf, buf_end, "dataWindow", "box2i", 31, &variable_buffer_data_size) >= 0) {
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            xmin = AV_RL32(buf);
 +            ymin = AV_RL32(buf + 4);
 +            xmax = AV_RL32(buf + 8);
 +            ymax = AV_RL32(buf + 12);
 +            xdelta = (xmax-xmin) + 1;
 +
 +            buf += variable_buffer_data_size;
 +            continue;
 +        }
 +
 +        // Process the displayWindow variable
 +        if (check_header_variable(avctx, &buf, buf_end, "displayWindow", "box2i", 34, &variable_buffer_data_size) >= 0) {
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            w = AV_RL32(buf + 8) + 1;
 +            h = AV_RL32(buf + 12) + 1;
 +
 +            buf += variable_buffer_data_size;
 +            continue;
 +        }
 +
 +        // Process the lineOrder variable
 +        if (check_header_variable(avctx, &buf, buf_end, "lineOrder", "lineOrder", 25, &variable_buffer_data_size) >= 0) {
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            if (*buf) {
 +                av_log(avctx, AV_LOG_ERROR, "Doesn't support this line order : %d\n", *buf);
 +                return AVERROR_PATCHWELCOME;
 +            }
 +
 +            buf += variable_buffer_data_size;
 +            continue;
 +        }
 +
 +        // Process the pixelAspectRatio variable
 +        if (check_header_variable(avctx, &buf, buf_end, "pixelAspectRatio", "float", 31, &variable_buffer_data_size) >= 0) {
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            avctx->sample_aspect_ratio = av_d2q(av_int2float(AV_RL32(buf)), 255);
 +
 +            buf += variable_buffer_data_size;
 +            continue;
 +        }
 +
 +        // Process the compression variable
 +        if (check_header_variable(avctx, &buf, buf_end, "compression", "compression", 29, &variable_buffer_data_size) >= 0) {
 +            if (!variable_buffer_data_size)
 +                return AVERROR_INVALIDDATA;
 +
 +            if (s->compr == -1)
 +                s->compr = *buf;
 +            else
 +                av_log(avctx, AV_LOG_WARNING, "Found more than one compression attribute\n");
 +
 +            buf += variable_buffer_data_size;
 +            continue;
 +        }
 +
 +        // Check if there is enough bytes for a header
 +        if (buf_end - buf <= 9) {
 +            av_log(avctx, AV_LOG_ERROR, "Incomplete header\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        // Process unknown variables
 +        for (i = 0; i < 2; i++) {
 +            // Skip variable name/type
 +            while (++buf < buf_end)
 +                if (buf[0] == 0x0)
 +                    break;
 +        }
 +        buf++;
 +        // Skip variable length
 +        if (buf_end - buf >= 5) {
 +            variable_buffer_data_size = get_header_variable_length(&buf, buf_end);
 +            if (!variable_buffer_data_size) {
 +                av_log(avctx, AV_LOG_ERROR, "Incomplete header\n");
 +                return AVERROR_INVALIDDATA;
 +            }
 +            buf += variable_buffer_data_size;
 +        }
 +    }
 +
 +    if (s->compr == -1) {
 +        av_log(avctx, AV_LOG_ERROR, "Missing compression attribute\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    if (buf >= buf_end) {
 +        av_log(avctx, AV_LOG_ERROR, "Incomplete frame\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    buf++;
 +
 +    switch (s->bits_per_color_id) {
 +    case 2: // 32-bit
 +    case 1: // 16-bit
 +        if (s->channel_offsets[3] >= 0)
-             avctx->pix_fmt = PIX_FMT_RGB48;
++            avctx->pix_fmt = AV_PIX_FMT_RGBA64;
 +        else
++            avctx->pix_fmt = AV_PIX_FMT_RGB48;
 +        break;
 +    // 8-bit
 +    case 0:
 +        av_log_missing_feature(avctx, "8-bit OpenEXR", 1);
 +        return AVERROR_PATCHWELCOME;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Unknown color format : %d\n", s->bits_per_color_id);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    switch (s->compr) {
 +    case EXR_RAW:
 +    case EXR_RLE:
 +    case EXR_ZIP1:
 +        scan_lines_per_block = 1;
 +        break;
 +    case EXR_ZIP16:
 +        scan_lines_per_block = 16;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "Compression type %d is not supported\n", s->compr);
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    if (s->picture.data[0])
 +        ff_thread_release_buffer(avctx, &s->picture);
 +    if (av_image_check_size(w, h, 0, avctx))
 +        return AVERROR_INVALIDDATA;
 +
 +    // Verify the xmin, xmax, ymin, ymax and xdelta before setting the actual image size
 +    if (xmin > xmax || ymin > ymax || xdelta != xmax - xmin + 1 || xmax >= w || ymax >= h) {
 +        av_log(avctx, AV_LOG_ERROR, "Wrong sizing or missing size information\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    if (w != avctx->width || h != avctx->height) {
 +        avcodec_set_dimensions(avctx, w, h);
 +    }
 +
 +    bxmin = xmin * 2 * av_pix_fmt_descriptors[avctx->pix_fmt].nb_components;
 +    axmax = (avctx->width - (xmax + 1)) * 2 * av_pix_fmt_descriptors[avctx->pix_fmt].nb_components;
 +    out_line_size = avctx->width * 2 * av_pix_fmt_descriptors[avctx->pix_fmt].nb_components;
 +    scan_line_size = xdelta * current_channel_offset;
 +    uncompressed_size = scan_line_size * scan_lines_per_block;
 +
 +    if (s->compr != EXR_RAW) {
 +        av_fast_padded_malloc(&s->uncompressed_data, &s->uncompressed_size, uncompressed_size);
 +        av_fast_padded_malloc(&s->tmp, &s->tmp_size, uncompressed_size);
 +        if (!s->uncompressed_data || !s->tmp)
 +            return AVERROR(ENOMEM);
 +    }
 +
 +    if ((ret = ff_thread_get_buffer(avctx, p)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 +        return ret;
 +    }
 +
 +    ptr    = p->data[0];
 +    stride = p->linesize[0];
 +
 +    // Zero out the start if ymin is not 0
 +    for (y = 0; y < ymin; y++) {
 +        memset(ptr, 0, out_line_size);
 +        ptr += stride;
 +    }
 +
 +    // Process the actual scan line blocks
 +    for (y = ymin; y <= ymax; y += scan_lines_per_block) {
 +        uint16_t *ptr_x = (uint16_t *)ptr;
 +        if (buf_end - buf > 8) {
 +            /* Read the lineoffset from the line offset table and add 8 bytes
 +               to skip the coordinates and data size fields */
 +            const uint64_t line_offset = bytestream_get_le64(&buf) + 8;
 +            int32_t data_size;
 +
 +            // Check if the buffer has the required bytes needed from the offset
 +            if ((line_offset > buf_size) ||
 +                (s->compr == EXR_RAW && line_offset > avpkt->size - xdelta * current_channel_offset) ||
 +                (s->compr != EXR_RAW && line_offset > buf_size - (data_size = AV_RL32(avpkt->data + line_offset - 4)))) {
 +                // Line offset is probably wrong and not inside the buffer
 +                av_log(avctx, AV_LOG_WARNING, "Line offset for line %d is out of reach setting it to black\n", y);
 +                for (i = 0; i < scan_lines_per_block && y + i <= ymax; i++, ptr += stride) {
 +                    ptr_x = (uint16_t *)ptr;
 +                    memset(ptr_x, 0, out_line_size);
 +                }
 +            } else {
 +                const uint8_t *red_channel_buffer, *green_channel_buffer, *blue_channel_buffer, *alpha_channel_buffer = 0;
 +
 +                if (scan_lines_per_block > 1)
 +                    uncompressed_size = scan_line_size * FFMIN(scan_lines_per_block, ymax - y + 1);
 +                if ((s->compr == EXR_ZIP1 || s->compr == EXR_ZIP16) && data_size < uncompressed_size) {
 +                    unsigned long dest_len = uncompressed_size;
 +
 +                    if (uncompress(s->tmp, &dest_len, avpkt->data + line_offset, data_size) != Z_OK ||
 +                        dest_len != uncompressed_size) {
 +                        av_log(avctx, AV_LOG_ERROR, "error during zlib decompression\n");
 +                        return AVERROR(EINVAL);
 +                    }
 +                } else if (s->compr == EXR_RLE && data_size < uncompressed_size) {
 +                    if (rle_uncompress(avpkt->data + line_offset, data_size, s->tmp, uncompressed_size)) {
 +                        av_log(avctx, AV_LOG_ERROR, "error during rle decompression\n");
 +                        return AVERROR(EINVAL);
 +                    }
 +                }
 +
 +                if (s->compr != EXR_RAW && data_size < uncompressed_size) {
 +                    predictor(s->tmp, uncompressed_size);
 +                    reorder_pixels(s->tmp, s->uncompressed_data, uncompressed_size);
 +
 +                    red_channel_buffer   = s->uncompressed_data + xdelta * s->channel_offsets[0];
 +                    green_channel_buffer = s->uncompressed_data + xdelta * s->channel_offsets[1];
 +                    blue_channel_buffer  = s->uncompressed_data + xdelta * s->channel_offsets[2];
 +                    if (s->channel_offsets[3] >= 0)
 +                        alpha_channel_buffer = s->uncompressed_data + xdelta * s->channel_offsets[3];
 +                } else {
 +                    red_channel_buffer   = avpkt->data + line_offset + xdelta * s->channel_offsets[0];
 +                    green_channel_buffer = avpkt->data + line_offset + xdelta * s->channel_offsets[1];
 +                    blue_channel_buffer  = avpkt->data + line_offset + xdelta * s->channel_offsets[2];
 +                    if (s->channel_offsets[3] >= 0)
 +                        alpha_channel_buffer = avpkt->data + line_offset + xdelta * s->channel_offsets[3];
 +                }
 +
 +                for (i = 0; i < scan_lines_per_block && y + i <= ymax; i++, ptr += stride) {
 +                    const uint8_t *r, *g, *b, *a;
 +
 +                    r = red_channel_buffer;
 +                    g = green_channel_buffer;
 +                    b = blue_channel_buffer;
 +                    if (alpha_channel_buffer)
 +                        a = alpha_channel_buffer;
 +
 +                    ptr_x = (uint16_t *)ptr;
 +
 +                    // Zero out the start if xmin is not 0
 +                    memset(ptr_x, 0, bxmin);
 +                    ptr_x += xmin * av_pix_fmt_descriptors[avctx->pix_fmt].nb_components;
 +                    if (s->bits_per_color_id == 2) {
 +                        // 32-bit
 +                        for (x = 0; x < xdelta; x++) {
 +                            *ptr_x++ = exr_flt2uint(bytestream_get_le32(&r));
 +                            *ptr_x++ = exr_flt2uint(bytestream_get_le32(&g));
 +                            *ptr_x++ = exr_flt2uint(bytestream_get_le32(&b));
 +                            if (alpha_channel_buffer)
 +                                *ptr_x++ = exr_flt2uint(bytestream_get_le32(&a));
 +                        }
 +                    } else {
 +                        // 16-bit
 +                        for (x = 0; x < xdelta; x++) {
 +                            *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&r));
 +                            *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&g));
 +                            *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&b));
 +                            if (alpha_channel_buffer)
 +                                *ptr_x++ = exr_halflt2uint(bytestream_get_le16(&a));
 +                        }
 +                    }
 +
 +                    // Zero out the end if xmax+1 is not w
 +                    memset(ptr_x, 0, axmax);
 +
 +                    red_channel_buffer   += scan_line_size;
 +                    green_channel_buffer += scan_line_size;
 +                    blue_channel_buffer  += scan_line_size;
 +                    if (alpha_channel_buffer)
 +                        alpha_channel_buffer += scan_line_size;
 +                }
 +            }
 +        }
 +    }
 +
 +    // Zero out the end if ymax+1 is not h
 +    for (y = ymax + 1; y < avctx->height; y++) {
 +        memset(ptr, 0, out_line_size);
 +        ptr += stride;
 +    }
 +
 +    *picture   = s->picture;
 +    *data_size = sizeof(AVPicture);
 +
 +    return buf_size;
 +}
 +
 +static av_cold int decode_init(AVCodecContext *avctx)
 +{
 +    EXRContext *s = avctx->priv_data;
 +
 +    avcodec_get_frame_defaults(&s->picture);
 +    avctx->coded_frame = &s->picture;
 +
 +    s->compr = -1;
 +
 +    return 0;
 +}
 +
 +static av_cold int decode_end(AVCodecContext *avctx)
 +{
 +    EXRContext *s = avctx->priv_data;
 +
 +    if (s->picture.data[0])
 +        avctx->release_buffer(avctx, &s->picture);
 +
 +    av_freep(&s->uncompressed_data);
 +    av_freep(&s->tmp);
 +
 +    return 0;
 +}
 +
 +AVCodec ff_exr_decoder = {
 +    .name               = "exr",
 +    .type               = AVMEDIA_TYPE_VIDEO,
 +    .id                 = AV_CODEC_ID_EXR,
 +    .priv_data_size     = sizeof(EXRContext),
 +    .init               = decode_init,
 +    .close              = decode_end,
 +    .decode             = decode_frame,
 +    .capabilities       = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 +    .long_name          = NULL_IF_CONFIG_SMALL("OpenEXR image"),
 +};
@@@ -922,113 -855,7 +922,113 @@@ static av_cold int encode_init(AVCodecC
      common_init(avctx);
  
      s->version=0;
 -    s->ac= avctx->coder_type ? 2:0;
 +
 +    if((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)
 +        s->version = FFMAX(s->version, 2);
 +
 +    if(avctx->level == 3){
 +        s->version = 3;
 +    }
 +
 +    if(s->ec < 0){
 +        s->ec = (s->version >= 3);
 +    }
 +
 +    if(s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 +        av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    s->ac= avctx->coder_type > 0 ? 2 : 0;
 +
 +    s->plane_count=3;
 +    switch(avctx->pix_fmt){
-     case PIX_FMT_YUV444P9:
-     case PIX_FMT_YUV422P9:
-     case PIX_FMT_YUV420P9:
++    case AV_PIX_FMT_YUV444P9:
++    case AV_PIX_FMT_YUV422P9:
++    case AV_PIX_FMT_YUV420P9:
 +        if (!avctx->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 9;
-     case PIX_FMT_YUV444P10:
-     case PIX_FMT_YUV420P10:
-     case PIX_FMT_YUV422P10:
++    case AV_PIX_FMT_YUV444P10:
++    case AV_PIX_FMT_YUV420P10:
++    case AV_PIX_FMT_YUV422P10:
 +        s->packed_at_lsb = 1;
 +        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 10;
-     case PIX_FMT_GRAY16:
-     case PIX_FMT_YUV444P16:
-     case PIX_FMT_YUV422P16:
-     case PIX_FMT_YUV420P16:
++    case AV_PIX_FMT_GRAY16:
++    case AV_PIX_FMT_YUV444P16:
++    case AV_PIX_FMT_YUV422P16:
++    case AV_PIX_FMT_YUV420P16:
 +        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {
 +            s->bits_per_raw_sample = 16;
 +        } else if (!s->bits_per_raw_sample){
 +            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 +        }
 +        if(s->bits_per_raw_sample <=8){
 +            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        if(!s->ac && avctx->coder_type == -1) {
 +            av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");
 +            s->ac = 2;
 +        }
 +        if(!s->ac){
 +            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        s->version= FFMAX(s->version, 1);
-     case PIX_FMT_GRAY8:
-     case PIX_FMT_YUV444P:
-     case PIX_FMT_YUV440P:
-     case PIX_FMT_YUV422P:
-     case PIX_FMT_YUV420P:
-     case PIX_FMT_YUV411P:
-     case PIX_FMT_YUV410P:
++    case AV_PIX_FMT_GRAY8:
++    case AV_PIX_FMT_YUV444P:
++    case AV_PIX_FMT_YUV440P:
++    case AV_PIX_FMT_YUV422P:
++    case AV_PIX_FMT_YUV420P:
++    case AV_PIX_FMT_YUV411P:
++    case AV_PIX_FMT_YUV410P:
 +        s->chroma_planes= av_pix_fmt_descriptors[avctx->pix_fmt].nb_components < 3 ? 0 : 1;
 +        s->colorspace= 0;
 +        break;
-     case PIX_FMT_YUVA444P:
-     case PIX_FMT_YUVA422P:
-     case PIX_FMT_YUVA420P:
++    case AV_PIX_FMT_YUVA444P:
++    case AV_PIX_FMT_YUVA422P:
++    case AV_PIX_FMT_YUVA420P:
 +        s->chroma_planes= 1;
 +        s->colorspace= 0;
 +        s->transparency= 1;
 +        break;
-     case PIX_FMT_RGB32:
++    case AV_PIX_FMT_RGB32:
 +        s->colorspace= 1;
 +        s->transparency= 1;
 +        break;
-     case PIX_FMT_0RGB32:
++    case AV_PIX_FMT_0RGB32:
 +        s->colorspace= 1;
 +        break;
-     case PIX_FMT_GBRP9:
++    case AV_PIX_FMT_GBRP9:
 +        if (!avctx->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 9;
-     case PIX_FMT_GBRP10:
++    case AV_PIX_FMT_GBRP10:
 +        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 10;
-     case PIX_FMT_GBRP12:
++    case AV_PIX_FMT_GBRP12:
 +        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 12;
-     case PIX_FMT_GBRP14:
++    case AV_PIX_FMT_GBRP14:
 +        if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)
 +            s->bits_per_raw_sample = 14;
 +        else if (!s->bits_per_raw_sample)
 +            s->bits_per_raw_sample = avctx->bits_per_raw_sample;
 +        s->colorspace= 1;
 +        s->chroma_planes= 1;
 +        s->version= FFMAX(s->version, 1);
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (s->transparency) {
 +        av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");
 +    }
 +    if (avctx->context_model > 1U) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);
 +        return AVERROR(EINVAL);
 +    }
  
      if(s->ac>1)
          for(i=1; i<256; i++)
@@@ -1867,57 -1545,22 +1867,57 @@@ static int read_header(FFV1Context *f)
      }
  
      if(f->colorspace==0){
 -        if(f->avctx->bits_per_raw_sample<=8){
 +        if(!f->transparency && !f->chroma_planes){
 +            if (f->avctx->bits_per_raw_sample<=8)
-                 f->avctx->pix_fmt= PIX_FMT_GRAY8;
++                f->avctx->pix_fmt= AV_PIX_FMT_GRAY8;
 +            else
-                 f->avctx->pix_fmt= PIX_FMT_GRAY16;
++                f->avctx->pix_fmt= AV_PIX_FMT_GRAY16;
 +        }else if(f->avctx->bits_per_raw_sample<=8 && !f->transparency){
              switch(16*f->chroma_h_shift + f->chroma_v_shift){
-             case 0x00: f->avctx->pix_fmt= PIX_FMT_YUV444P; break;
-             case 0x01: f->avctx->pix_fmt= PIX_FMT_YUV440P; break;
-             case 0x10: f->avctx->pix_fmt= PIX_FMT_YUV422P; break;
-             case 0x11: f->avctx->pix_fmt= PIX_FMT_YUV420P; break;
-             case 0x20: f->avctx->pix_fmt= PIX_FMT_YUV411P; break;
-             case 0x22: f->avctx->pix_fmt= PIX_FMT_YUV410P; break;
+             case 0x00: f->avctx->pix_fmt= AV_PIX_FMT_YUV444P; break;
++            case 0x01: f->avctx->pix_fmt= AV_PIX_FMT_YUV440P; break;
+     &n