Merge commit 'b2bed9325dbd6be0da1d91ffed3f513c40274fd2'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 4 Oct 2013 10:34:23 +0000 (12:34 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 4 Oct 2013 10:34:23 +0000 (12:34 +0200)
* commit 'b2bed9325dbd6be0da1d91ffed3f513c40274fd2':
  cosmetics: Group .name and .long_name together in codec/format declarations

Conflicts:
libavcodec/8svx.c
libavcodec/alac.c
libavcodec/cljr.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dpxenc.c
libavcodec/dvdec.c
libavcodec/dvdsubdec.c
libavcodec/dvdsubenc.c
libavcodec/ffv1dec.c
libavcodec/flacdec.c
libavcodec/flvdec.c
libavcodec/fraps.c
libavcodec/frwu.c
libavcodec/g726.c
libavcodec/gif.c
libavcodec/gifdec.c
libavcodec/h261dec.c
libavcodec/h263dec.c
libavcodec/iff.c
libavcodec/imc.c
libavcodec/libopencore-amr.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/libspeexenc.c
libavcodec/libvo-amrwbenc.c
libavcodec/libvorbisenc.c
libavcodec/libvpxenc.c
libavcodec/libx264.c
libavcodec/libxavs.c
libavcodec/libxvid.c
libavcodec/ljpegenc.c
libavcodec/mjpegbdec.c
libavcodec/mjpegdec.c
libavcodec/mpeg12dec.c
libavcodec/mpeg4videodec.c
libavcodec/msmpeg4dec.c
libavcodec/pgssubdec.c
libavcodec/pngdec.c
libavcodec/pngenc.c
libavcodec/proresdec_lgpl.c
libavcodec/proresenc_kostya.c
libavcodec/ra144enc.c
libavcodec/rawdec.c
libavcodec/rv10.c
libavcodec/sp5xdec.c
libavcodec/takdec.c
libavcodec/tta.c
libavcodec/v210dec.c
libavcodec/vp6.c
libavcodec/wavpack.c
libavcodec/xbmenc.c
libavcodec/yop.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
267 files changed:
1  2 
libavcodec/4xm.c
libavcodec/8bps.c
libavcodec/8svx.c
libavcodec/a64multienc.c
libavcodec/aacdec.c
libavcodec/aacenc.c
libavcodec/aasc.c
libavcodec/ac3dec.c
libavcodec/ac3enc_fixed.c
libavcodec/ac3enc_float.c
libavcodec/adpcm.c
libavcodec/adpcmenc.c
libavcodec/adxdec.c
libavcodec/adxenc.c
libavcodec/aic.c
libavcodec/alac.c
libavcodec/alacenc.c
libavcodec/alsdec.c
libavcodec/amrnbdec.c
libavcodec/amrwbdec.c
libavcodec/anm.c
libavcodec/ansi.c
libavcodec/apedec.c
libavcodec/asvdec.c
libavcodec/asvenc.c
libavcodec/aura.c
libavcodec/avs.c
libavcodec/bethsoftvideo.c
libavcodec/bfi.c
libavcodec/bink.c
libavcodec/binkaudio.c
libavcodec/bmp.c
libavcodec/bmpenc.c
libavcodec/bmv.c
libavcodec/c93.c
libavcodec/cavsdec.c
libavcodec/cdgraphics.c
libavcodec/cdxl.c
libavcodec/cinepak.c
libavcodec/cljr.c
libavcodec/cllc.c
libavcodec/cngdec.c
libavcodec/cngenc.c
libavcodec/cook.c
libavcodec/cscd.c
libavcodec/cyuv.c
libavcodec/dcadec.c
libavcodec/dfa.c
libavcodec/dnxhddec.c
libavcodec/dnxhdenc.c
libavcodec/dpcm.c
libavcodec/dpx.c
libavcodec/dpxenc.c
libavcodec/dsicinav.c
libavcodec/dv.c
libavcodec/dvbsub.c
libavcodec/dvbsubdec.c
libavcodec/dvdec.c
libavcodec/dvdsubdec.c
libavcodec/dvdsubenc.c
libavcodec/dxa.c
libavcodec/eac3enc.c
libavcodec/eacmv.c
libavcodec/eamad.c
libavcodec/eatgq.c
libavcodec/eatgv.c
libavcodec/eatqi.c
libavcodec/escape124.c
libavcodec/escape130.c
libavcodec/ffv1dec.c
libavcodec/ffv1enc.c
libavcodec/flacdec.c
libavcodec/flacenc.c
libavcodec/flashsv.c
libavcodec/flashsvenc.c
libavcodec/flicvideo.c
libavcodec/flvdec.c
libavcodec/flvenc.c
libavcodec/fraps.c
libavcodec/frwu.c
libavcodec/g722dec.c
libavcodec/g722enc.c
libavcodec/g723_1.c
libavcodec/g726.c
libavcodec/gif.c
libavcodec/gifdec.c
libavcodec/gsmdec.c
libavcodec/h261dec.c
libavcodec/h261enc.c
libavcodec/h263dec.c
libavcodec/h264.c
libavcodec/huffyuvdec.c
libavcodec/huffyuvenc.c
libavcodec/idcinvideo.c
libavcodec/iff.c
libavcodec/imc.c
libavcodec/indeo2.c
libavcodec/indeo3.c
libavcodec/indeo4.c
libavcodec/indeo5.c
libavcodec/intelh263dec.c
libavcodec/interplayvideo.c
libavcodec/kgv1dec.c
libavcodec/kmvc.c
libavcodec/lagarith.c
libavcodec/lcldec.c
libavcodec/lclenc.c
libavcodec/libfaac.c
libavcodec/libfdk-aacenc.c
libavcodec/libgsm.c
libavcodec/libilbc.c
libavcodec/libmp3lame.c
libavcodec/libopencore-amr.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/libopusdec.c
libavcodec/libopusenc.c
libavcodec/libschroedingerdec.c
libavcodec/libschroedingerenc.c
libavcodec/libspeexdec.c
libavcodec/libspeexenc.c
libavcodec/libtheoraenc.c
libavcodec/libvo-aacenc.c
libavcodec/libvo-amrwbenc.c
libavcodec/libvorbisenc.c
libavcodec/libvpxdec.c
libavcodec/libvpxenc.c
libavcodec/libx264.c
libavcodec/libxavs.c
libavcodec/libxvid.c
libavcodec/ljpegenc.c
libavcodec/loco.c
libavcodec/mace.c
libavcodec/mdec.c
libavcodec/mimic.c
libavcodec/mjpegbdec.c
libavcodec/mjpegdec.c
libavcodec/mjpegenc.c
libavcodec/mlpdec.c
libavcodec/mmvideo.c
libavcodec/motionpixels.c
libavcodec/mpc7.c
libavcodec/mpc8.c
libavcodec/mpeg12dec.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videodec.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegaudiodec.c
libavcodec/mpegaudiodec_float.c
libavcodec/mpegaudioenc.c
libavcodec/mpegvideo_enc.c
libavcodec/msmpeg4dec.c
libavcodec/msrle.c
libavcodec/mss1.c
libavcodec/mss2.c
libavcodec/mss3.c
libavcodec/mss4.c
libavcodec/msvideo1.c
libavcodec/nellymoserdec.c
libavcodec/nellymoserenc.c
libavcodec/nuv.c
libavcodec/pamenc.c
libavcodec/pcm-bluray.c
libavcodec/pcm.c
libavcodec/pcx.c
libavcodec/pcxenc.c
libavcodec/pgssubdec.c
libavcodec/pictordec.c
libavcodec/pngdec.c
libavcodec/pngenc.c
libavcodec/pnmdec.c
libavcodec/pnmenc.c
libavcodec/proresdec_lgpl.c
libavcodec/proresenc_kostya.c
libavcodec/ptx.c
libavcodec/qcelpdec.c
libavcodec/qdm2.c
libavcodec/qdrw.c
libavcodec/qpeg.c
libavcodec/qtrle.c
libavcodec/qtrleenc.c
libavcodec/r210dec.c
libavcodec/ra144dec.c
libavcodec/ra144enc.c
libavcodec/ra288.c
libavcodec/ralf.c
libavcodec/rawdec.c
libavcodec/rawenc.c
libavcodec/rl2.c
libavcodec/roqaudioenc.c
libavcodec/roqvideodec.c
libavcodec/roqvideoenc.c
libavcodec/rpza.c
libavcodec/rv10.c
libavcodec/rv10enc.c
libavcodec/rv20enc.c
libavcodec/rv30.c
libavcodec/rv40.c
libavcodec/s302m.c
libavcodec/sgidec.c
libavcodec/sgienc.c
libavcodec/shorten.c
libavcodec/sipr.c
libavcodec/smacker.c
libavcodec/smc.c
libavcodec/sp5xdec.c
libavcodec/sunrast.c
libavcodec/sunrastenc.c
libavcodec/svq1dec.c
libavcodec/svq1enc.c
libavcodec/svq3.c
libavcodec/takdec.c
libavcodec/targa.c
libavcodec/targaenc.c
libavcodec/tiertexseqv.c
libavcodec/tmv.c
libavcodec/truemotion1.c
libavcodec/truemotion2.c
libavcodec/truespeech.c
libavcodec/tscc.c
libavcodec/tscc2.c
libavcodec/tta.c
libavcodec/twinvqdec.c
libavcodec/txd.c
libavcodec/ulti.c
libavcodec/utvideodec.c
libavcodec/utvideoenc.c
libavcodec/v210dec.c
libavcodec/v210enc.c
libavcodec/v210x.c
libavcodec/v410dec.c
libavcodec/v410enc.c
libavcodec/vb.c
libavcodec/vble.c
libavcodec/vc1dec.c
libavcodec/vcr1.c
libavcodec/vmdav.c
libavcodec/vmnc.c
libavcodec/vorbisdec.c
libavcodec/vorbisenc.c
libavcodec/vp3.c
libavcodec/vp5.c
libavcodec/vp6.c
libavcodec/vp8.c
libavcodec/vqavideo.c
libavcodec/wavpack.c
libavcodec/wmadec.c
libavcodec/wmaenc.c
libavcodec/wmalosslessdec.c
libavcodec/wmaprodec.c
libavcodec/wmavoice.c
libavcodec/wmv2dec.c
libavcodec/wmv2enc.c
libavcodec/wnv1.c
libavcodec/ws-snd1.c
libavcodec/xan.c
libavcodec/xbmenc.c
libavcodec/xl.c
libavcodec/xsubdec.c
libavcodec/xsubenc.c
libavcodec/xwddec.c
libavcodec/xwdenc.c
libavcodec/xxan.c
libavcodec/yop.c
libavcodec/zerocodec.c
libavcodec/zmbv.c
libavcodec/zmbvenc.c

Simple merge
Simple merge
@@@ -184,32 -196,30 +184,32 @@@ static av_cold int eightsvx_decode_clos
      return 0;
  }
  
 +#if CONFIG_EIGHTSVX_FIB_DECODER
  AVCodec ff_eightsvx_fib_decoder = {
    .name           = "8svx_fib",
+   .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_8SVX_FIB,
    .priv_data_size = sizeof (EightSvxContext),
    .init           = eightsvx_decode_init,
 -  .close          = eightsvx_decode_close,
    .decode         = eightsvx_decode_frame,
 -  .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
 +  .close          = eightsvx_decode_close,
 +  .capabilities   = CODEC_CAP_DR1,
-   .long_name      = NULL_IF_CONFIG_SMALL("8SVX fibonacci"),
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
                                                      AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_EIGHTSVX_EXP_DECODER
  AVCodec ff_eightsvx_exp_decoder = {
    .name           = "8svx_exp",
+   .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),
    .type           = AVMEDIA_TYPE_AUDIO,
    .id             = AV_CODEC_ID_8SVX_EXP,
    .priv_data_size = sizeof (EightSvxContext),
    .init           = eightsvx_decode_init,
 -  .close          = eightsvx_decode_close,
    .decode         = eightsvx_decode_frame,
 -  .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_DR1,
 +  .close          = eightsvx_decode_close,
 +  .capabilities   = CODEC_CAP_DR1,
-   .long_name      = NULL_IF_CONFIG_SMALL("8SVX exponential"),
    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_U8P,
                                                      AV_SAMPLE_FMT_NONE },
  };
@@@ -393,9 -371,9 +393,10 @@@ static int a64multi_encode_frame(AVCode
      return 0;
  }
  
 +#if CONFIG_A64MULTI_ENCODER
  AVCodec ff_a64multi_encoder = {
      .name           = "a64multi",
+     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_A64_MULTI,
      .priv_data_size = sizeof(A64Context),
      .encode2        = a64multi_encode_frame,
      .close          = a64multi_close_encoder,
      .pix_fmts       = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},
-     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
      .capabilities   = CODEC_CAP_DELAY,
  };
 -
 +#endif
 +#if CONFIG_A64MULTI5_ENCODER
  AVCodec ff_a64multi5_encoder = {
      .name           = "a64multi5",
+     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_A64_MULTI5,
      .priv_data_size = sizeof(A64Context),
      .encode2        = a64multi_encode_frame,
      .close          = a64multi_close_encoder,
      .pix_fmts       = (const enum AVPixelFormat[]) {AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE},
-     .long_name      = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
      .capabilities   = CODEC_CAP_DELAY,
  };
 +#endif
Simple merge
@@@ -806,15 -802,9 +806,16 @@@ static const AVClass aacenc_class = 
      LIBAVUTIL_VERSION_INT,
  };
  
 +/* duplicated from avpriv_mpeg4audio_sample_rates to avoid shared build
 + * failures */
 +static const int mpeg4audio_sample_rates[16] = {
 +    96000, 88200, 64000, 48000, 44100, 32000,
 +    24000, 22050, 16000, 12000, 11025, 8000, 7350
 +};
 +
  AVCodec ff_aac_encoder = {
      .name           = "aac",
+     .long_name      = NULL_IF_CONFIG_SMALL("AAC (Advanced Audio Coding)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_AAC,
      .priv_data_size = sizeof(AACEncContext),
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -617,22 -569,14 +617,22 @@@ static av_cold int alac_decode_init(AVC
      return 0;
  }
  
 +static int init_thread_copy(AVCodecContext *avctx)
 +{
 +    ALACContext *alac = avctx->priv_data;
 +    alac->avctx = avctx;
 +    return allocate_buffers(alac);
 +}
 +
  AVCodec ff_alac_decoder = {
      .name           = "alac",
+     .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_ALAC,
      .priv_data_size = sizeof(ALACContext),
      .init           = alac_decode_init,
      .close          = alac_decode_close,
      .decode         = alac_decode_frame,
 -    .capabilities   = CODEC_CAP_DR1,
 +    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("ALAC (Apple Lossless Audio Codec)"),
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -307,9 -312,9 +307,10 @@@ static av_cold int decode_end(AVCodecCo
      return 0;
  }
  
 +#if CONFIG_ASV1_DECODER
  AVCodec ff_asv1_decoder = {
      .name           = "asv1",
+     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_ASV1,
      .priv_data_size = sizeof(ASV1Context),
      .close          = decode_end,
      .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V1"),
  };
 +#endif
  
 +#if CONFIG_ASV2_DECODER
  AVCodec ff_asv2_decoder = {
      .name           = "asv2",
+     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_ASV2,
      .priv_data_size = sizeof(ASV1Context),
      .close          = decode_end,
      .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("ASUS V2"),
  };
 +#endif
  
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -161,8 -161,10 +161,9 @@@ static int bmp_encode_frame(AVCodecCont
  
  AVCodec ff_bmp_encoder = {
      .name           = "bmp",
+     .long_name      = NULL_IF_CONFIG_SMALL("BMP (Windows and OS/2 bitmap)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_BMP,
 -    .priv_data_size = sizeof(BMPContext),
      .init           = bmp_encode_init,
      .encode2        = bmp_encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]){
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -161,22 -150,9 +161,23 @@@ static int encode_frame(AVCodecContext 
      return 0;
  }
  
 +#define OFFSET(x) offsetof(CLJRContext, x)
 +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption options[] = {
 +    { "dither_type",   "Dither type",   OFFSET(dither_type),        AV_OPT_TYPE_INT, { .i64=1 }, 0, 2, VE},
 +    { NULL },
 +};
 +
 +static const AVClass cljr_class = {
 +    .class_name = "cljr encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_cljr_encoder = {
      .name           = "cljr",
+     .long_name      = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_CLJR,
      .priv_data_size = sizeof(CLJRContext),
      .encode2        = encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV411P,
                                                     AV_PIX_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("Cirrus Logic AccuPak"),
 +    .priv_class     = &cljr_class,
  };
  #endif
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -419,6 -392,5 +420,5 @@@ AVCodec ff_dnxhd_decoder = 
      .init           = dnxhd_decode_init,
      .close          = dnxhd_decode_close,
      .decode         = dnxhd_decode_frame,
 -    .capabilities   = CODEC_CAP_DR1,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
  };
@@@ -1030,13 -1018,9 +1030,14 @@@ static av_cold int dnxhd_encode_end(AVC
      return 0;
  }
  
 +static const AVCodecDefault dnxhd_defaults[] = {
 +    { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */
 +    { NULL },
 +};
 +
  AVCodec ff_dnxhd_encoder = {
      .name           = "dnxhd",
+     .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_DNXHD,
      .priv_data_size = sizeof(DNXHDEncContext),
      .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,
 +    .priv_class     = &dnxhd_class,
 +    .defaults       = dnxhd_defaults,
  };
Simple merge
Simple merge
@@@ -234,18 -174,17 +234,18 @@@ static int encode_frame(AVCodecContext 
  }
  
  AVCodec ff_dpx_encoder = {
 -    .name = "dpx",
 -    .long_name = NULL_IF_CONFIG_SMALL("DPX image"),
 -    .type = AVMEDIA_TYPE_VIDEO,
 -    .id   = AV_CODEC_ID_DPX,
 +    .name           = "dpx",
++    .long_name      = NULL_IF_CONFIG_SMALL("DPX image"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_DPX,
      .priv_data_size = sizeof(DPXContext),
 -    .init   = encode_init,
 -    .encode2 = encode_frame,
 -    .pix_fmts = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_RGB24,
 -        AV_PIX_FMT_RGBA,
 -        AV_PIX_FMT_RGB48LE,
 -        AV_PIX_FMT_RGB48BE,
 +    .init           = encode_init,
 +    .encode2        = encode_frame,
 +    .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"),
  };
Simple merge
diff --cc libavcodec/dv.c
Simple merge
Simple merge
Simple merge
@@@ -377,6 -378,4 +378,5 @@@ AVCodec ff_dvvideo_decoder = 
      .close          = dvvideo_close,
      .decode         = dvvideo_decode_frame,
      .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 +    .max_lowres     = 3,
  };
@@@ -640,27 -538,12 +640,27 @@@ static av_cold int dvdsub_close(AVCodec
      return 0;
  }
  
 +#define OFFSET(field) offsetof(DVDSubContext, field)
 +#define VD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
 +static const AVOption options[] = {
 +    { "palette", "set the global palette", OFFSET(palette_str), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, VD },
 +    { NULL }
 +};
 +static const AVClass dvdsub_class = {
 +    .class_name = "dvdsubdec",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_dvdsub_decoder = {
      .name           = "dvdsub",
+     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
      .type           = AVMEDIA_TYPE_SUBTITLE,
      .id             = AV_CODEC_ID_DVD_SUBTITLE,
      .priv_data_size = sizeof(DVDSubContext),
      .init           = dvdsub_init,
      .decode         = dvdsub_decode,
-     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
 +    .close          = dvdsub_close,
 +    .priv_class     = &dvdsub_class,
  };
@@@ -434,10 -217,8 +434,10 @@@ static int dvdsub_encode(AVCodecContex
  
  AVCodec ff_dvdsub_encoder = {
      .name           = "dvdsub",
+     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
      .type           = AVMEDIA_TYPE_SUBTITLE,
      .id             = AV_CODEC_ID_DVD_SUBTITLE,
 +    .init           = dvdsub_init,
      .encode_sub     = dvdsub_encode,
-     .long_name      = NULL_IF_CONFIG_SMALL("DVD subtitles"),
 +    .priv_data_size = sizeof(DVDSubtitleContext),
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -967,109 -906,15 +967,109 @@@ static int decode_frame(AVCodecContext 
      return buf_size;
  }
  
 +static int init_thread_copy(AVCodecContext *avctx)
 +{
 +    FFV1Context *f = avctx->priv_data;
 +    int i, ret;
 +
 +    f->picture.f      = NULL;
 +    f->last_picture.f = NULL;
 +    f->sample_buffer  = NULL;
 +    f->slice_count = 0;
 +
 +    for (i = 0; i < f->quant_table_count; i++) {
 +        av_assert0(f->version > 1);
 +        f->initial_states[i] = av_memdup(f->initial_states[i],
 +                                         f->context_count[i] * sizeof(*f->initial_states[i]));
 +    }
 +
 +    f->picture.f      = av_frame_alloc();
 +    f->last_picture.f = av_frame_alloc();
 +
 +    if ((ret = ffv1_init_slice_contexts(f)) < 0)
 +        return ret;
 +
 +    return 0;
 +}
 +
 +static void copy_fields(FFV1Context *fsdst, FFV1Context *fssrc, FFV1Context *fsrc)
 +{
 +    fsdst->version             = fsrc->version;
 +    fsdst->micro_version       = fsrc->micro_version;
 +    fsdst->chroma_planes       = fsrc->chroma_planes;
 +    fsdst->chroma_h_shift      = fsrc->chroma_h_shift;
 +    fsdst->chroma_v_shift      = fsrc->chroma_v_shift;
 +    fsdst->transparency        = fsrc->transparency;
 +    fsdst->plane_count         = fsrc->plane_count;
 +    fsdst->ac                  = fsrc->ac;
 +    fsdst->colorspace          = fsrc->colorspace;
 +
 +    fsdst->ec                  = fsrc->ec;
 +    fsdst->intra               = fsrc->intra;
 +    fsdst->slice_damaged       = fssrc->slice_damaged;
 +    fsdst->key_frame_ok        = fsrc->key_frame_ok;
 +
 +    fsdst->bits_per_raw_sample = fsrc->bits_per_raw_sample;
 +    fsdst->packed_at_lsb       = fsrc->packed_at_lsb;
 +    fsdst->slice_count         = fsrc->slice_count;
 +    if (fsrc->version<3){
 +        fsdst->slice_x             = fssrc->slice_x;
 +        fsdst->slice_y             = fssrc->slice_y;
 +        fsdst->slice_width         = fssrc->slice_width;
 +        fsdst->slice_height        = fssrc->slice_height;
 +    }
 +}
 +
 +static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 +{
 +    FFV1Context *fsrc = src->priv_data;
 +    FFV1Context *fdst = dst->priv_data;
 +    int i, ret;
 +
 +    if (dst == src)
 +        return 0;
 +
 +    {
 +        FFV1Context bak = *fdst;
 +        memcpy(fdst, fsrc, sizeof(*fdst));
 +        memcpy(fdst->initial_states, bak.initial_states, sizeof(fdst->initial_states));
 +        memcpy(fdst->slice_context,  bak.slice_context , sizeof(fdst->slice_context));
 +        fdst->picture      = bak.picture;
 +        fdst->last_picture = bak.last_picture;
 +        for (i = 0; i<fdst->num_h_slices * fdst->num_v_slices; i++) {
 +            FFV1Context *fssrc = fsrc->slice_context[i];
 +            FFV1Context *fsdst = fdst->slice_context[i];
 +            copy_fields(fsdst, fssrc, fsrc);
 +        }
 +        av_assert0(!fdst->plane[0].state);
 +        av_assert0(!fdst->sample_buffer);
 +    }
 +
 +    av_assert1(fdst->slice_count == fsrc->slice_count);
 +
 +
 +    ff_thread_release_buffer(dst, &fdst->picture);
 +    if (fsrc->picture.f->data[0]) {
 +        if ((ret = ff_thread_ref_frame(&fdst->picture, &fsrc->picture)) < 0)
 +            return ret;
 +    }
 +
 +    fdst->fsrc = fsrc;
 +
 +    return 0;
 +}
 +
  AVCodec ff_ffv1_decoder = {
      .name           = "ffv1",
+     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_FFV1,
      .priv_data_size = sizeof(FFV1Context),
 -    .init           = ffv1_decode_init,
 +    .init           = decode_init,
      .close          = ffv1_close,
 -    .decode         = ffv1_decode_frame,
 +    .decode         = decode_frame,
 +    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
 +    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
      .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ |
 -                      CODEC_CAP_SLICE_THREADS,
 +                      CODEC_CAP_FRAME_THREADS | CODEC_CAP_SLICE_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
  };
@@@ -1232,7 -1097,6 +1233,6 @@@ AVCodec ff_ffv1_encoder = 
          AV_PIX_FMT_NONE
  
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
      .defaults       = ffv1_defaults,
 -    .priv_class     = &class,
 +    .priv_class     = &ffv1_class,
  };
@@@ -597,9 -564,7 +598,8 @@@ AVCodec ff_flac_decoder = 
      .init           = flac_decode_init,
      .close          = flac_decode_close,
      .decode         = flac_decode_frame,
 -    .capabilities   = CODEC_CAP_DR1,
 +    .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("FLAC (Free Lossless Audio Codec)"),
      .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16,
                                                        AV_SAMPLE_FMT_S16P,
                                                        AV_SAMPLE_FMT_S32,
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -131,7 -129,5 +132,6 @@@ AVCodec ff_flv_decoder = 
      .close          = ff_h263_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("FLV / Sorenson Spark / Sorenson H.263 (Flash Video)"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
Simple merge
@@@ -319,6 -377,5 +320,5 @@@ AVCodec ff_fraps_decoder = 
      .init           = decode_init,
      .close          = decode_end,
      .decode         = decode_frame,
 -    .capabilities   = CODEC_CAP_DR1,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
-     .long_name      = NULL_IF_CONFIG_SMALL("Fraps"),
  };
@@@ -102,27 -94,12 +102,27 @@@ static int decode_frame(AVCodecContext 
      return avpkt->size;
  }
  
 +static const AVOption frwu_options[] = {
 +    {"change_field_order", "Change field order", offsetof(FRWUContext, change_field_order), FF_OPT_TYPE_INT,
 +     {.i64 = 0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM},
 +    {NULL}
 +};
 +
 +static const AVClass frwu_class = {
 +    .class_name = "frwu Decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = frwu_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_frwu_decoder = {
      .name           = "frwu",
+     .long_name      = NULL_IF_CONFIG_SMALL("Forward Uncompressed"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_FRWU,
 +    .priv_data_size = sizeof(FRWUContext),
      .init           = decode_init,
      .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("Forward Uncompressed"),
 +    .priv_class     = &frwu_class,
  };
Simple merge
Simple merge
Simple merge
@@@ -390,8 -393,7 +391,7 @@@ AVCodec ff_adpcm_g726_encoder = 
      .capabilities   = CODEC_CAP_SMALL_LAST_FRAME,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("G.726 ADPCM"),
 -    .priv_class     = &class,
 +    .priv_class     = &g726_class,
      .defaults       = defaults,
  };
  #endif
@@@ -283,24 -179,9 +283,25 @@@ static int gif_encode_close(AVCodecCont
      return 0;
  }
  
 +#define OFFSET(x) offsetof(GIFContext, x)
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption gif_options[] = {
 +    { "gifflags", "set GIF flags", OFFSET(flags), AV_OPT_TYPE_FLAGS, {.i64 = GF_OFFSETTING|GF_TRANSDIFF}, 0, INT_MAX, FLAGS, "flags" },
 +        { "offsetting", "enable picture offsetting", 0, AV_OPT_TYPE_CONST, {.i64=GF_OFFSETTING}, INT_MIN, INT_MAX, FLAGS, "flags" },
 +        { "transdiff", "enable transparency detection between frames", 0, AV_OPT_TYPE_CONST, {.i64=GF_TRANSDIFF}, INT_MIN, INT_MAX, FLAGS, "flags" },
 +    { NULL }
 +};
 +
 +static const AVClass gif_class = {
 +    .class_name = "GIF encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = gif_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_gif_encoder = {
      .name           = "gif",
+     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_GIF,
      .priv_data_size = sizeof(GIFContext),
          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_NONE
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
 +    .priv_class     = &gif_class,
  };
@@@ -514,24 -317,9 +514,25 @@@ static av_cold int gif_decode_close(AVC
      return 0;
  }
  
 +static const AVOption options[] = {
 +    { "trans_color", "color value (ARGB) that is used instead of transparent color",
 +      offsetof(GifState, trans_color), AV_OPT_TYPE_INT,
 +      {.i64 = GIF_TRANSPARENT_COLOR}, 0, 0xffffffff,
 +      AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_VIDEO_PARAM },
 +    { NULL },
 +};
 +
 +static const AVClass decoder_class = {
 +    .class_name = "gif decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +    .category   = AV_CLASS_CATEGORY_DECODER,
 +};
 +
  AVCodec ff_gif_decoder = {
      .name           = "gif",
+     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_GIF,
      .priv_data_size = sizeof(GifState),
      .close          = gif_decode_close,
      .decode         = gif_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("GIF (Graphics Interchange Format)"),
 +    .priv_class     = &decoder_class,
  };
@@@ -108,9 -101,9 +108,10 @@@ static void gsm_flush(AVCodecContext *a
      memset(s, 0, sizeof(*s));
  }
  
 +#if CONFIG_GSM_DECODER
  AVCodec ff_gsm_decoder = {
      .name           = "gsm",
+     .long_name      = NULL_IF_CONFIG_SMALL("GSM"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM,
      .priv_data_size = sizeof(GSMContext),
      .decode         = gsm_decode_frame,
      .flush          = gsm_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("GSM"),
  };
 -
 +#endif
 +#if CONFIG_GSM_MS_DECODER
  AVCodec ff_gsm_ms_decoder = {
      .name           = "gsm_ms",
+     .long_name      = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM_MS,
      .priv_data_size = sizeof(GSMContext),
      .decode         = gsm_decode_frame,
      .flush          = gsm_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("GSM Microsoft variant"),
  };
 +#endif
@@@ -670,6 -669,4 +671,5 @@@ AVCodec ff_h261_decoder = 
      .close          = h261_decode_end,
      .decode         = h261_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
 +    .max_lowres     = 3,
  };
Simple merge
@@@ -794,23 -740,5 +795,22 @@@ AVCodec ff_h263_decoder = 
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
                        CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
      .flush          = ff_mpeg_flush,
-     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
 +    .max_lowres     = 3,
-     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
 +    .pix_fmts       = ff_h263_hwaccel_pixfmt_list_420,
 +};
 +
 +AVCodec ff_h263p_decoder = {
 +    .name           = "h263p",
++    .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996, H.263+ / H.263-1998 / H.263 version 2"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_H263P,
 +    .priv_data_size = sizeof(MpegEncContext),
 +    .init           = ff_h263_decode_init,
 +    .close          = ff_h263_decode_end,
 +    .decode         = ff_h263_decode_frame,
 +    .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 |
 +                      CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY,
 +    .flush          = ff_mpeg_flush,
 +    .max_lowres     = 3,
      .pix_fmts       = ff_h263_hwaccel_pixfmt_list_420,
  };
@@@ -5162,28 -4877,9 +5162,29 @@@ static const AVProfile profiles[] = 
      { FF_PROFILE_UNKNOWN },
  };
  
 +static const AVOption h264_options[] = {
 +    {"is_avc", "is avc", offsetof(H264Context, is_avc), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 1, 0},
 +    {"nal_length_size", "nal_length_size", offsetof(H264Context, nal_length_size), FF_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0},
 +    {NULL}
 +};
 +
 +static const AVClass h264_class = {
 +    .class_name = "H264 Decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = h264_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +static const AVClass h264_vdpau_class = {
 +    .class_name = "H264 VDPAU Decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = h264_options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_h264_decoder = {
      .name                  = "h264",
+     .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
      .type                  = AVMEDIA_TYPE_VIDEO,
      .id                    = AV_CODEC_ID_H264,
      .priv_data_size        = sizeof(H264Context),
Simple merge
Simple merge
Simple merge
@@@ -868,29 -367,26 +868,29 @@@ static av_cold int decode_end(AVCodecCo
      return 0;
  }
  
 +#if CONFIG_IFF_ILBM_DECODER
  AVCodec ff_iff_ilbm_decoder = {
 -    .name           = "iff_ilbm",
 -    .long_name      = NULL_IF_CONFIG_SMALL("IFF ILBM"),
 +    .name           = "iff",
++    .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_IFF_ILBM,
      .priv_data_size = sizeof(IffContext),
      .init           = decode_init,
      .close          = decode_end,
 -    .decode         = decode_frame_ilbm,
 +    .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
  };
 -
 +#endif
 +#if CONFIG_IFF_BYTERUN1_DECODER
  AVCodec ff_iff_byterun1_decoder = {
 -    .name           = "iff_byterun1",
 -    .long_name      = NULL_IF_CONFIG_SMALL("IFF ByteRun1"),
 +    .name           = "iff",
++    .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_IFF_BYTERUN1,
      .priv_data_size = sizeof(IffContext),
      .init           = decode_init,
      .close          = decode_end,
 -    .decode         = decode_frame_byterun1,
 +    .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("IFF"),
  };
 +#endif
@@@ -1055,42 -1044,31 +1055,42 @@@ static av_cold int imc_decode_close(AVC
      return 0;
  }
  
 +static av_cold void flush(AVCodecContext *avctx)
 +{
 +    IMCContext *q = avctx->priv_data;
 +
 +    q->chctx[0].decoder_reset =
 +    q->chctx[1].decoder_reset = 1;
 +}
  
 +#if CONFIG_IMC_DECODER
  AVCodec ff_imc_decoder = {
      .name           = "imc",
+     .long_name      = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_IMC,
      .priv_data_size = sizeof(IMCContext),
      .init           = imc_decode_init,
      .close          = imc_decode_close,
      .decode         = imc_decode_frame,
 +    .flush          = flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("IMC (Intel Music Coder)"),
      .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                        AV_SAMPLE_FMT_NONE },
  };
 -
 +#endif
 +#if CONFIG_IAC_DECODER
  AVCodec ff_iac_decoder = {
      .name           = "iac",
+     .long_name      = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_IAC,
      .priv_data_size = sizeof(IMCContext),
      .init           = imc_decode_init,
      .close          = imc_decode_close,
      .decode         = imc_decode_frame,
 +    .flush          = flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("IAC (Indeo Audio Coder)"),
      .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
                                                        AV_SAMPLE_FMT_NONE },
  };
Simple merge
Simple merge
Simple merge
@@@ -674,8 -646,10 +674,9 @@@ static av_cold int decode_init(AVCodecC
      return 0;
  }
  
 -
  AVCodec ff_indeo5_decoder = {
      .name           = "indeo5",
+     .long_name      = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 5"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_INDEO5,
      .priv_data_size = sizeof(IVI45DecContext),
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -115,9 -112,9 +115,10 @@@ static int libgsm_encode_frame(AVCodecC
  }
  
  
 +#if CONFIG_LIBGSM_ENCODER
  AVCodec ff_libgsm_encoder = {
      .name           = "libgsm",
+     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM,
      .init           = libgsm_encode_init,
      .close          = libgsm_encode_close,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
  };
 -
 +#endif
 +#if CONFIG_LIBGSM_MS_ENCODER
  AVCodec ff_libgsm_ms_encoder = {
      .name           = "libgsm_ms",
+     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM_MS,
      .init           = libgsm_encode_init,
      .close          = libgsm_encode_close,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
  };
 +#endif
  
  typedef struct LibGSMDecodeContext {
      struct gsm_state *state;
@@@ -224,9 -219,9 +224,10 @@@ static void libgsm_flush(AVCodecContex
          gsm_option(s->state, GSM_OPT_WAV49, &one);
  }
  
 +#if CONFIG_LIBGSM_DECODER
  AVCodec ff_libgsm_decoder = {
      .name           = "libgsm",
+     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM,
      .priv_data_size = sizeof(LibGSMDecodeContext),
      .decode         = libgsm_decode_frame,
      .flush          = libgsm_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM"),
  };
 -
 +#endif
 +#if CONFIG_LIBGSM_MS_DECODER
  AVCodec ff_libgsm_ms_decoder = {
      .name           = "libgsm_ms",
+     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_GSM_MS,
      .priv_data_size = sizeof(LibGSMDecodeContext),
      .decode         = libgsm_decode_frame,
      .flush          = libgsm_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("libgsm GSM Microsoft variant"),
  };
 +#endif
Simple merge
Simple merge
@@@ -290,8 -294,7 +291,7 @@@ AVCodec ff_libopencore_amrnb_encoder = 
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("OpenCORE AMR-NB (Adaptive Multi-Rate Narrow-Band)"),
 -    .priv_class     = &class,
 +    .priv_class     = &amrnb_class,
  };
  #endif /* CONFIG_LIBOPENCORE_AMRNB_ENCODER */
  
@@@ -411,7 -435,5 +412,6 @@@ AVCodec ff_libopenjpeg_decoder = 
      .init             = libopenjpeg_decode_init,
      .decode           = libopenjpeg_decode_frame,
      .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 -    .priv_class       = &class,
 +    .max_lowres       = 31,
-     .long_name        = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
 +    .priv_class       = &openjpeg_class,
  };
@@@ -644,24 -422,15 +645,23 @@@ AVCodec ff_libopenjpeg_encoder = 
      .close          = libopenjpeg_encode_close,
      .capabilities   = 0,
      .pix_fmts       = (const enum AVPixelFormat[]) {
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48,
 -        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16, AV_PIX_FMT_Y400A,
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64,
 +        AV_PIX_FMT_GBR24P,
 +        AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10, AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14, AV_PIX_FMT_GBRP16,
 +        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16,
          AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA420P,
 -        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
 -        AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P,
 +        AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA422P,
 +        AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUVA444P,
          AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9,
 +        AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9,
          AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 +        AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10,
 +        AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12,
 +        AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14,
          AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16,
 +        AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16,
 +        AV_PIX_FMT_XYZ12,
          AV_PIX_FMT_NONE
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
 -    .priv_class     = &class,
 +    .priv_class     = &openjpeg_class,
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -362,7 -364,6 +363,6 @@@ AVCodec ff_libspeex_encoder = 
                                             AV_CH_LAYOUT_STEREO,
                                             0 },
      .supported_samplerates = (const int[]){ 8000, 16000, 32000, 0 },
-     .long_name      = NULL_IF_CONFIG_SMALL("libspeex Speex"),
 -    .priv_class     = &class,
 +    .priv_class     = &speex_class,
      .defaults       = defaults,
  };
Simple merge
@@@ -177,15 -179,9 +177,16 @@@ static int aac_encode_frame(AVCodecCont
      return 0;
  }
  
 +/* duplicated from avpriv_mpeg4audio_sample_rates to avoid shared build
 + * failures */
 +static const int mpeg4audio_sample_rates[16] = {
 +    96000, 88200, 64000, 48000, 44100, 32000,
 +    24000, 22050, 16000, 12000, 11025, 8000, 7350
 +};
 +
  AVCodec ff_libvo_aacenc_encoder = {
      .name           = "libvo_aacenc",
+     .long_name      = NULL_IF_CONFIG_SMALL("Android VisualOn AAC (Advanced Audio Coding)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_AAC,
      .priv_data_size = sizeof(AACContext),
@@@ -146,7 -150,5 +148,5 @@@ AVCodec ff_libvo_amrwbenc_encoder = 
      .close          = amr_wb_encode_close,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("Android VisualOn AMR-WB "
-                                            "(Adaptive Multi-Rate Wide-Band)"),
 -    .priv_class     = &class,
 +    .priv_class     = &amrwb_class,
  };
index d7fded8,0000000..a2faac7
mode 100644,000000..100644
--- /dev/null
@@@ -1,378 -1,0 +1,378 @@@
-     .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
 +/*
 + * Copyright (c) 2002 Mark Hills <mark@pogo.org.uk>
 + *
 + * 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 <vorbis/vorbisenc.h>
 +
 +#include "libavutil/avassert.h"
 +#include "libavutil/fifo.h"
 +#include "libavutil/opt.h"
 +#include "avcodec.h"
 +#include "audio_frame_queue.h"
 +#include "internal.h"
 +#include "vorbis.h"
 +#include "vorbis_parser.h"
 +
 +
 +/* Number of samples the user should send in each call.
 + * This value is used because it is the LCD of all possible frame sizes, so
 + * an output packet will always start at the same point as one of the input
 + * packets.
 + */
 +#define OGGVORBIS_FRAME_SIZE 64
 +
 +#define BUFFER_SIZE (1024 * 64)
 +
 +typedef struct OggVorbisEncContext {
 +    AVClass *av_class;                  /**< class for AVOptions            */
 +    AVFrame frame;
 +    vorbis_info vi;                     /**< vorbis_info used during init   */
 +    vorbis_dsp_state vd;                /**< DSP state used for analysis    */
 +    vorbis_block vb;                    /**< vorbis_block used for analysis */
 +    AVFifoBuffer *pkt_fifo;             /**< output packet buffer           */
 +    int eof;                            /**< end-of-file flag               */
 +    int dsp_initialized;                /**< vd has been initialized        */
 +    vorbis_comment vc;                  /**< VorbisComment info             */
 +    double iblock;                      /**< impulse block bias option      */
 +    VorbisParseContext vp;              /**< parse context to get durations */
 +    AudioFrameQueue afq;                /**< frame queue for timestamps     */
 +} OggVorbisEncContext;
 +
 +static const AVOption options[] = {
 +    { "iblock", "Sets the impulse block bias", offsetof(OggVorbisEncContext, iblock), AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, -15, 0, AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM },
 +    { NULL }
 +};
 +
 +static const AVCodecDefault defaults[] = {
 +    { "b",  "0" },
 +    { NULL },
 +};
 +
 +static const AVClass vorbis_class = {
 +    .class_name = "libvorbis",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +static int vorbis_error_to_averror(int ov_err)
 +{
 +    switch (ov_err) {
 +    case OV_EFAULT: return AVERROR_BUG;
 +    case OV_EINVAL: return AVERROR(EINVAL);
 +    case OV_EIMPL:  return AVERROR(EINVAL);
 +    default:        return AVERROR_UNKNOWN;
 +    }
 +}
 +
 +static av_cold int oggvorbis_init_encoder(vorbis_info *vi,
 +                                          AVCodecContext *avctx)
 +{
 +    OggVorbisEncContext *s = avctx->priv_data;
 +    double cfreq;
 +    int ret;
 +
 +    if (avctx->flags & CODEC_FLAG_QSCALE || !avctx->bit_rate) {
 +        /* variable bitrate
 +         * NOTE: we use the oggenc range of -1 to 10 for global_quality for
 +         *       user convenience, but libvorbis uses -0.1 to 1.0.
 +         */
 +        float q = avctx->global_quality / (float)FF_QP2LAMBDA;
 +        /* default to 3 if the user did not set quality or bitrate */
 +        if (!(avctx->flags & CODEC_FLAG_QSCALE))
 +            q = 3.0;
 +        if ((ret = vorbis_encode_setup_vbr(vi, avctx->channels,
 +                                           avctx->sample_rate,
 +                                           q / 10.0)))
 +            goto error;
 +    } else {
 +        int minrate = avctx->rc_min_rate > 0 ? avctx->rc_min_rate : -1;
 +        int maxrate = avctx->rc_max_rate > 0 ? avctx->rc_max_rate : -1;
 +
 +        /* average bitrate */
 +        if ((ret = vorbis_encode_setup_managed(vi, avctx->channels,
 +                                               avctx->sample_rate, maxrate,
 +                                               avctx->bit_rate, minrate)))
 +            goto error;
 +
 +        /* variable bitrate by estimate, disable slow rate management */
 +        if (minrate == -1 && maxrate == -1)
 +            if ((ret = vorbis_encode_ctl(vi, OV_ECTL_RATEMANAGE2_SET, NULL)))
 +                goto error; /* should not happen */
 +    }
 +
 +    /* cutoff frequency */
 +    if (avctx->cutoff > 0) {
 +        cfreq = avctx->cutoff / 1000.0;
 +        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_LOWPASS_SET, &cfreq)))
 +            goto error; /* should not happen */
 +    }
 +
 +    /* impulse block bias */
 +    if (s->iblock) {
 +        if ((ret = vorbis_encode_ctl(vi, OV_ECTL_IBLOCK_SET, &s->iblock)))
 +            goto error;
 +    }
 +
 +    if (avctx->channels == 3 &&
 +            avctx->channel_layout != (AV_CH_LAYOUT_STEREO|AV_CH_FRONT_CENTER) ||
 +        avctx->channels == 4 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_2_2 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_QUAD ||
 +        avctx->channels == 5 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT0 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT0_BACK ||
 +        avctx->channels == 6 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT1 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_5POINT1_BACK ||
 +        avctx->channels == 7 &&
 +            avctx->channel_layout != (AV_CH_LAYOUT_5POINT1|AV_CH_BACK_CENTER) ||
 +        avctx->channels == 8 &&
 +            avctx->channel_layout != AV_CH_LAYOUT_7POINT1) {
 +        if (avctx->channel_layout) {
 +            char name[32];
 +            av_get_channel_layout_string(name, sizeof(name), avctx->channels,
 +                                         avctx->channel_layout);
 +            av_log(avctx, AV_LOG_ERROR, "%s not supported by Vorbis: "
 +                                             "output stream will have incorrect "
 +                                             "channel layout.\n", name);
 +        } else {
 +            av_log(avctx, AV_LOG_WARNING, "No channel layout specified. The encoder "
 +                                               "will use Vorbis channel layout for "
 +                                               "%d channels.\n", avctx->channels);
 +        }
 +    }
 +
 +    if ((ret = vorbis_encode_setup_init(vi)))
 +        goto error;
 +
 +    return 0;
 +error:
 +    return vorbis_error_to_averror(ret);
 +}
 +
 +/* How many bytes are needed for a buffer of length 'l' */
 +static int xiph_len(int l)
 +{
 +    return 1 + l / 255 + l;
 +}
 +
 +static av_cold int oggvorbis_encode_close(AVCodecContext *avctx)
 +{
 +    OggVorbisEncContext *s = avctx->priv_data;
 +
 +    /* notify vorbisenc this is EOF */
 +    if (s->dsp_initialized)
 +        vorbis_analysis_wrote(&s->vd, 0);
 +
 +    vorbis_block_clear(&s->vb);
 +    vorbis_dsp_clear(&s->vd);
 +    vorbis_info_clear(&s->vi);
 +
 +    av_fifo_free(s->pkt_fifo);
 +    ff_af_queue_close(&s->afq);
 +    av_freep(&avctx->extradata);
 +
 +    return 0;
 +}
 +
 +static av_cold int oggvorbis_encode_init(AVCodecContext *avctx)
 +{
 +    OggVorbisEncContext *s = avctx->priv_data;
 +    ogg_packet header, header_comm, header_code;
 +    uint8_t *p;
 +    unsigned int offset;
 +    int ret;
 +
 +    vorbis_info_init(&s->vi);
 +    if ((ret = oggvorbis_init_encoder(&s->vi, avctx))) {
 +        av_log(avctx, AV_LOG_ERROR, "encoder setup failed\n");
 +        goto error;
 +    }
 +    if ((ret = vorbis_analysis_init(&s->vd, &s->vi))) {
 +        av_log(avctx, AV_LOG_ERROR, "analysis init failed\n");
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +    s->dsp_initialized = 1;
 +    if ((ret = vorbis_block_init(&s->vd, &s->vb))) {
 +        av_log(avctx, AV_LOG_ERROR, "dsp init failed\n");
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +
 +    vorbis_comment_init(&s->vc);
 +    if (!(avctx->flags & CODEC_FLAG_BITEXACT))
 +        vorbis_comment_add_tag(&s->vc, "encoder", LIBAVCODEC_IDENT);
 +
 +    if ((ret = vorbis_analysis_headerout(&s->vd, &s->vc, &header, &header_comm,
 +                                         &header_code))) {
 +        ret = vorbis_error_to_averror(ret);
 +        goto error;
 +    }
 +
 +    avctx->extradata_size = 1 + xiph_len(header.bytes)      +
 +                                xiph_len(header_comm.bytes) +
 +                                header_code.bytes;
 +    p = avctx->extradata = av_malloc(avctx->extradata_size +
 +                                     FF_INPUT_BUFFER_PADDING_SIZE);
 +    if (!p) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +    p[0]    = 2;
 +    offset  = 1;
 +    offset += av_xiphlacing(&p[offset], header.bytes);
 +    offset += av_xiphlacing(&p[offset], header_comm.bytes);
 +    memcpy(&p[offset], header.packet, header.bytes);
 +    offset += header.bytes;
 +    memcpy(&p[offset], header_comm.packet, header_comm.bytes);
 +    offset += header_comm.bytes;
 +    memcpy(&p[offset], header_code.packet, header_code.bytes);
 +    offset += header_code.bytes;
 +    av_assert0(offset == avctx->extradata_size);
 +
 +    if ((ret = avpriv_vorbis_parse_extradata(avctx, &s->vp)) < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid extradata\n");
 +        return ret;
 +    }
 +
 +    vorbis_comment_clear(&s->vc);
 +
 +    avctx->frame_size = OGGVORBIS_FRAME_SIZE;
 +    ff_af_queue_init(avctx, &s->afq);
 +
 +    s->pkt_fifo = av_fifo_alloc(BUFFER_SIZE);
 +    if (!s->pkt_fifo) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +
 +    return 0;
 +error:
 +    oggvorbis_encode_close(avctx);
 +    return ret;
 +}
 +
 +static int oggvorbis_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 +                                  const AVFrame *frame, int *got_packet_ptr)
 +{
 +    OggVorbisEncContext *s = avctx->priv_data;
 +    ogg_packet op;
 +    int ret, duration;
 +
 +    /* send samples to libvorbis */
 +    if (frame) {
 +        const int samples = frame->nb_samples;
 +        float **buffer;
 +        int c, channels = s->vi.channels;
 +
 +        buffer = vorbis_analysis_buffer(&s->vd, samples);
 +        for (c = 0; c < channels; c++) {
 +            int co = (channels > 8) ? c :
 +                     ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
 +            memcpy(buffer[c], frame->extended_data[co],
 +                   samples * sizeof(*buffer[c]));
 +        }
 +        if ((ret = vorbis_analysis_wrote(&s->vd, samples)) < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
 +            return vorbis_error_to_averror(ret);
 +        }
 +        if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
 +            return ret;
 +    } else {
 +        if (!s->eof)
 +            if ((ret = vorbis_analysis_wrote(&s->vd, 0)) < 0) {
 +                av_log(avctx, AV_LOG_ERROR, "error in vorbis_analysis_wrote()\n");
 +                return vorbis_error_to_averror(ret);
 +            }
 +        s->eof = 1;
 +    }
 +
 +    /* retrieve available packets from libvorbis */
 +    while ((ret = vorbis_analysis_blockout(&s->vd, &s->vb)) == 1) {
 +        if ((ret = vorbis_analysis(&s->vb, NULL)) < 0)
 +            break;
 +        if ((ret = vorbis_bitrate_addblock(&s->vb)) < 0)
 +            break;
 +
 +        /* add any available packets to the output packet buffer */
 +        while ((ret = vorbis_bitrate_flushpacket(&s->vd, &op)) == 1) {
 +            if (av_fifo_space(s->pkt_fifo) < sizeof(ogg_packet) + op.bytes) {
 +                av_log(avctx, AV_LOG_ERROR, "packet buffer is too small\n");
 +                return AVERROR_BUG;
 +            }
 +            av_fifo_generic_write(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
 +            av_fifo_generic_write(s->pkt_fifo, op.packet, op.bytes, NULL);
 +        }
 +        if (ret < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
 +            break;
 +        }
 +    }
 +    if (ret < 0) {
 +        av_log(avctx, AV_LOG_ERROR, "error getting available packets\n");
 +        return vorbis_error_to_averror(ret);
 +    }
 +
 +    /* check for available packets */
 +    if (av_fifo_size(s->pkt_fifo) < sizeof(ogg_packet))
 +        return 0;
 +
 +    av_fifo_generic_read(s->pkt_fifo, &op, sizeof(ogg_packet), NULL);
 +
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, op.bytes)) < 0)
 +        return ret;
 +    av_fifo_generic_read(s->pkt_fifo, avpkt->data, op.bytes, NULL);
 +
 +    avpkt->pts = ff_samples_to_time_base(avctx, op.granulepos);
 +
 +    duration = avpriv_vorbis_parse_frame(&s->vp, avpkt->data, avpkt->size);
 +    if (duration > 0) {
 +        /* we do not know encoder delay until we get the first packet from
 +         * libvorbis, so we have to update the AudioFrameQueue counts */
 +        if (!avctx->delay && s->afq.frames) {
 +            avctx->delay              = duration;
 +            av_assert0(!s->afq.remaining_delay);
 +            s->afq.frames->duration  += duration;
 +            s->afq.frames->pts       -= duration;
 +            s->afq.remaining_samples += duration;
 +        }
 +        ff_af_queue_remove(&s->afq, duration, &avpkt->pts, &avpkt->duration);
 +    }
 +
 +    *got_packet_ptr = 1;
 +    return 0;
 +}
 +
 +AVCodec ff_libvorbis_encoder = {
 +    .name           = "libvorbis",
++    .long_name      = NULL_IF_CONFIG_SMALL("libvorbis"),
 +    .type           = AVMEDIA_TYPE_AUDIO,
 +    .id             = AV_CODEC_ID_VORBIS,
 +    .priv_data_size = sizeof(OggVorbisEncContext),
 +    .init           = oggvorbis_encode_init,
 +    .encode2        = oggvorbis_encode_frame,
 +    .close          = oggvorbis_encode_close,
 +    .capabilities   = CODEC_CAP_DELAY,
 +    .sample_fmts    = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,
 +                                                      AV_SAMPLE_FMT_NONE },
 +    .priv_class     = &vorbis_class,
 +    .defaults       = defaults,
 +};
Simple merge
@@@ -786,8 -596,7 +787,7 @@@ AVCodec ff_libvpx_vp8_encoder = 
      .encode2        = vp8_encode,
      .close          = vp8_free,
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
 -    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
 +    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("libvpx VP8"),
      .priv_class     = &class_vp8,
      .defaults       = defaults,
  };
@@@ -752,8 -611,7 +753,7 @@@ AVCodec ff_libx264_encoder = 
      .encode2          = X264_frame,
      .close            = X264_close,
      .capabilities     = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
-     .long_name        = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
 -    .priv_class       = &class,
 +    .priv_class       = &x264_class,
      .defaults         = x264_defaults,
      .init_static_data = X264_init_static,
  };
@@@ -426,7 -429,6 +427,6 @@@ AVCodec ff_libxavs_encoder = 
      .close          = XAVS_close,
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
      .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("libxavs Chinese AVS (Audio Video Standard)"),
 -    .priv_class     = &class,
 +    .priv_class     = &xavs_class,
      .defaults       = xavs_defaults,
  };
@@@ -803,28 -748,9 +803,29 @@@ static av_cold int xvid_encode_close(AV
      return 0;
  }
  
 +#define OFFSET(x) offsetof(struct xvid_context, x)
 +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption options[] = {
 +    { "lumi_aq",     "Luminance masking AQ", OFFSET(lumi_aq),     AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
 +    { "variance_aq", "Variance AQ",          OFFSET(variance_aq), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
 +    { "ssim",        "Show SSIM information to stdout",       OFFSET(ssim),              AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "ssim" },
 +        { "off",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "ssim" },
 +        { "avg",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "ssim" },
 +        { "frame",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "ssim" },
 +    { "ssim_acc",    "SSIM accuracy",                         OFFSET(ssim_acc),          AV_OPT_TYPE_INT, { .i64 = 2 }, 0, 4, VE },
 +    { NULL },
 +};
 +
 +static const AVClass xvid_class = {
 +    .class_name = "libxvid",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_libxvid_encoder = {
      .name           = "libxvid",
+     .long_name      = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_MPEG4,
      .priv_data_size = sizeof(struct xvid_context),
      .encode2        = xvid_encode_frame,
      .close          = xvid_encode_close,
      .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),
 +    .priv_class     = &xvid_class,
  };
@@@ -227,10 -214,4 +228,9 @@@ AVCodec ff_ljpeg_encoder = { //FIXME av
      .init           = ff_MPV_encode_init,
      .encode2        = encode_picture_lossless,
      .close          = ff_MPV_encode_end,
-     .long_name      = NULL_IF_CONFIG_SMALL("Lossless JPEG"),
 +    .pix_fmts       = (const enum AVPixelFormat[]){
 +        AV_PIX_FMT_BGR24, AV_PIX_FMT_BGRA, AV_PIX_FMT_BGR0,
 +        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P,
 +        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUV422P,
 +        AV_PIX_FMT_NONE},
  };
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -162,6 -158,4 +163,5 @@@ AVCodec ff_mjpegb_decoder = 
      .close          = ff_mjpeg_decode_end,
      .decode         = mjpegb_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("Apple MJPEG-B"),
 +    .max_lowres     = 3,
  };
@@@ -2084,25 -1691,18 +2085,24 @@@ AVCodec ff_mjpeg_decoder = 
      .init           = ff_mjpeg_decode_init,
      .close          = ff_mjpeg_decode_end,
      .decode         = ff_mjpeg_decode_frame,
 +    .flush          = decode_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
 +    .max_lowres     = 3,
      .priv_class     = &mjpegdec_class,
  };
 -
 +#endif
 +#if CONFIG_THP_DECODER
  AVCodec ff_thp_decoder = {
      .name           = "thp",
+     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_THP,
      .priv_data_size = sizeof(MJpegDecodeContext),
      .init           = ff_mjpeg_decode_init,
      .close          = ff_mjpeg_decode_end,
      .decode         = ff_mjpeg_decode_frame,
 +    .flush          = decode_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
 +    .max_lowres     = 3,
  };
 +#endif
@@@ -491,53 -442,15 +491,53 @@@ void ff_mjpeg_encode_mb(MpegEncContext 
      s->i_tex_bits += get_bits_diff(s);
  }
  
 +// maximum over s->mjpeg_vsample[i]
 +#define V_MAX 2
 +static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 +                              const AVFrame *pic_arg, int *got_packet)
 +
 +{
 +    MpegEncContext *s = avctx->priv_data;
 +    AVFrame pic = *pic_arg;
 +    int i;
 +
 +    //CODEC_FLAG_EMU_EDGE have to be cleared
 +    if(s->avctx->flags & CODEC_FLAG_EMU_EDGE)
 +        return -1;
 +
 +    //picture should be flipped upside-down
 +    for(i=0; i < 3; i++) {
 +        pic.data[i] += (pic.linesize[i] * (s->mjpeg_vsample[i] * (8 * s->mb_height -((s->height/V_MAX)&7)) - 1 ));
 +        pic.linesize[i] *= -1;
 +    }
 +    return ff_MPV_encode_picture(avctx, pkt, &pic, got_packet);
 +}
 +
 +#if CONFIG_MJPEG_ENCODER
  AVCodec ff_mjpeg_encoder = {
      .name           = "mjpeg",
+     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_MJPEG,
      .priv_data_size = sizeof(MpegEncContext),
      .init           = ff_MPV_encode_init,
      .encode2        = ff_MPV_encode_picture,
      .close          = ff_MPV_encode_end,
-     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
 +    .capabilities   = CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 +    .pix_fmts       = (const enum AVPixelFormat[]){
 +        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
 +    },
 +};
 +#endif
 +#if CONFIG_AMV_ENCODER
 +AVCodec ff_amv_encoder = {
 +    .name           = "amv",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_AMV,
 +    .priv_data_size = sizeof(MpegEncContext),
 +    .init           = ff_MPV_encode_init,
 +    .encode2        = amv_encode_picture,
 +    .close          = ff_MPV_encode_end,
      .pix_fmts       = (const enum AVPixelFormat[]){
          AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE
      },
@@@ -1249,18 -1224,17 +1249,18 @@@ error
      return AVERROR_INVALIDDATA;
  }
  
 +#if CONFIG_MLP_DECODER
  AVCodec ff_mlp_decoder = {
      .name           = "mlp",
+     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
      .type           = AVMEDIA_TYPE_AUDIO,
      .id             = AV_CODEC_ID_MLP,
      .priv_data_size = sizeof(MLPDecodeContext),
      .init           = mlp_decode_init,
      .decode         = read_access_unit,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("MLP (Meridian Lossless Packing)"),
  };
 -
 +#endif
  #if CONFIG_TRUEHD_DECODER
  AVCodec ff_truehd_decoder = {
      .name           = "truehd",
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -2554,8 -2413,6 +2555,7 @@@ AVCodec ff_mpeg1video_decoder = 
                               CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
                               CODEC_CAP_SLICE_THREADS,
      .flush                 = flush,
-     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-1 video"),
 +    .max_lowres            = 3,
      .update_thread_context = ONLY_IF_THREADS_ENABLED(mpeg_decode_update_thread_context)
  };
  
@@@ -2571,8 -2429,6 +2572,7 @@@ AVCodec ff_mpeg2video_decoder = 
                        CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
                        CODEC_CAP_SLICE_THREADS,
      .flush          = flush,
-     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-2 video"),
 +    .max_lowres     = 3,
      .profiles       = NULL_IF_CONFIG_SMALL(mpeg2_video_profiles),
  };
  
Simple merge
@@@ -2378,8 -2280,6 +2379,7 @@@ AVCodec ff_mpeg4_decoder = 
                               CODEC_CAP_TRUNCATED | CODEC_CAP_DELAY |
                               CODEC_CAP_FRAME_THREADS,
      .flush                 = ff_mpeg_flush,
-     .long_name             = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
 +    .max_lowres            = 3,
      .pix_fmts              = ff_h263_hwaccel_pixfmt_list_420,
      .profiles              = NULL_IF_CONFIG_SMALL(mpeg4_video_profiles),
      .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_mpeg_update_thread_context),
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -916,8 -910,6 +917,7 @@@ AVCodec ff_msmpeg4v1_decoder = 
      .close          = ff_h263_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
  
@@@ -930,8 -923,6 +931,7 @@@ AVCodec ff_msmpeg4v2_decoder = 
      .close          = ff_h263_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
  
@@@ -944,8 -936,6 +945,7 @@@ AVCodec ff_msmpeg4v3_decoder = 
      .close          = ff_h263_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
  
@@@ -958,7 -949,5 +959,6 @@@ AVCodec ff_wmv1_decoder = 
      .close          = ff_h263_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -129,9 -120,10 +130,8 @@@ AVCodec ff_pam_encoder = 
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_PAM,
      .priv_data_size = sizeof(PNMContext),
 -    .init           = ff_pnm_init,
      .encode2        = pam_encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_GRAY8, AV_PIX_FMT_MONOWHITE,
 -        AV_PIX_FMT_NONE
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("PAM (Portable AnyMap) image"),
  };
Simple merge
Simple merge
Simple merge
@@@ -198,8 -204,11 +198,9 @@@ static int pcx_encode_frame(AVCodecCont
  
  AVCodec ff_pcx_encoder = {
      .name           = "pcx",
+     .long_name      = NULL_IF_CONFIG_SMALL("PC Paintbrush PCX image"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_PCX,
 -    .priv_data_size = sizeof(PCXContext),
 -    .init           = pcx_encode_init,
      .encode2        = pcx_encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]){
          AV_PIX_FMT_RGB24,
@@@ -522,28 -479,13 +522,28 @@@ static int decode(AVCodecContext *avctx
      return buf_size;
  }
  
 +#define OFFSET(x) offsetof(PGSSubContext, x)
 +#define SD AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_DECODING_PARAM
 +static const AVOption options[] = {
 +    {"forced_subs_only", "Only show forced subtitles", OFFSET(forced_subs_only), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, SD},
 +    { NULL },
 +};
 +
 +static const AVClass pgsdec_class = {
 +    .class_name = "PGS subtitle decoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_pgssub_decoder = {
      .name           = "pgssub",
+     .long_name      = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
      .type           = AVMEDIA_TYPE_SUBTITLE,
      .id             = AV_CODEC_ID_HDMV_PGS_SUBTITLE,
      .priv_data_size = sizeof(PGSSubContext),
      .init           = init_decoder,
      .close          = close_decoder,
      .decode         = decode,
-     .long_name      = NULL_IF_CONFIG_SMALL("HDMV Presentation Graphic Stream subtitles"),
 +    .priv_class     = &pgsdec_class,
  };
Simple merge
@@@ -933,8 -656,5 +934,7 @@@ AVCodec ff_png_decoder = 
      .init           = png_dec_init,
      .close          = png_dec_end,
      .decode         = decode_frame,
 -    .capabilities   = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
 +    .init_thread_copy = ONLY_IF_THREADS_ENABLED(png_dec_init),
 +    .update_thread_context = ONLY_IF_THREADS_ENABLED(update_thread_context),
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
-     .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
  };
@@@ -472,23 -455,9 +472,24 @@@ static av_cold int png_enc_init(AVCodec
      return 0;
  }
  
 +#define OFFSET(x) offsetof(PNGEncContext, x)
 +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption options[] = {
 +    {"dpi", "Set image resolution (in dots per inch)",  OFFSET(dpi), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 0x10000, VE},
 +    {"dpm", "Set image resolution (in dots per meter)", OFFSET(dpm), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 0x10000, VE},
 +    { NULL }
 +};
 +
 +static const AVClass pngenc_class = {
 +    .class_name = "PNG encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
  AVCodec ff_png_encoder = {
      .name           = "png",
+     .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_PNG,
      .priv_data_size = sizeof(PNGEncContext),
          AV_PIX_FMT_GRAY16BE,
          AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
 +    .priv_class     = &pngenc_class,
  };
Simple merge
Simple merge
index 04aeb16,0000000..8abff30
mode 100644,000000..100644
--- /dev/null
@@@ -1,766 -1,0 +1,766 @@@
-     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)")
 +/*
 + * Apple ProRes compatible decoder
 + *
 + * Copyright (c) 2010-2011 Maxim Poliakovski
 + *
 + * 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
 + * This is a decoder for Apple ProRes 422 SD/HQ/LT/Proxy and ProRes 4444.
 + * It is used for storing and editing high definition video data in Apple's Final Cut Pro.
 + *
 + * @see http://wiki.multimedia.cx/index.php?title=Apple_ProRes
 + */
 +
 +#define LONG_BITSTREAM_READER // some ProRes vlc codes require up to 28 bits to be read at once
 +
 +#include <stdint.h>
 +
 +#include "libavutil/intmath.h"
 +#include "avcodec.h"
 +#include "dsputil.h"
 +#include "internal.h"
 +#include "proresdata.h"
 +#include "proresdsp.h"
 +#include "get_bits.h"
 +
 +typedef struct {
 +    const uint8_t *index;            ///< pointers to the data of this slice
 +    int slice_num;
 +    int x_pos, y_pos;
 +    int slice_width;
 +    int prev_slice_sf;               ///< scalefactor of the previous decoded slice
 +    DECLARE_ALIGNED(16, int16_t, blocks)[8 * 4 * 64];
 +    DECLARE_ALIGNED(16, int16_t, qmat_luma_scaled)[64];
 +    DECLARE_ALIGNED(16, int16_t, qmat_chroma_scaled)[64];
 +} ProresThreadData;
 +
 +typedef struct {
 +    ProresDSPContext dsp;
 +    AVFrame    *frame;
 +    ScanTable  scantable;
 +    int        scantable_type;           ///< -1 = uninitialized, 0 = progressive, 1/2 = interlaced
 +
 +    int        frame_type;               ///< 0 = progressive, 1 = top-field first, 2 = bottom-field first
 +    int        pic_format;               ///< 2 = 422, 3 = 444
 +    uint8_t    qmat_luma[64];            ///< dequantization matrix for luma
 +    uint8_t    qmat_chroma[64];          ///< dequantization matrix for chroma
 +    int        qmat_changed;             ///< 1 - global quantization matrices changed
 +    int        total_slices;            ///< total number of slices in a picture
 +    ProresThreadData *slice_data;
 +    int        pic_num;
 +    int        chroma_factor;
 +    int        mb_chroma_factor;
 +    int        num_chroma_blocks;       ///< number of chrominance blocks in a macroblock
 +    int        num_x_slices;
 +    int        num_y_slices;
 +    int        slice_width_factor;
 +    int        slice_height_factor;
 +    int        num_x_mbs;
 +    int        num_y_mbs;
 +    int        alpha_info;
 +} ProresContext;
 +
 +
 +static av_cold int decode_init(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +
 +    ctx->total_slices     = 0;
 +    ctx->slice_data       = NULL;
 +
 +    avctx->bits_per_raw_sample = PRORES_BITS_PER_SAMPLE;
 +    ff_proresdsp_init(&ctx->dsp, avctx);
 +
 +    ctx->scantable_type = -1;   // set scantable type to uninitialized
 +    memset(ctx->qmat_luma, 4, 64);
 +    memset(ctx->qmat_chroma, 4, 64);
 +
 +    return 0;
 +}
 +
 +
 +static int decode_frame_header(ProresContext *ctx, const uint8_t *buf,
 +                               const int data_size, AVCodecContext *avctx)
 +{
 +    int hdr_size, version, width, height, flags;
 +    const uint8_t *ptr;
 +
 +    hdr_size = AV_RB16(buf);
 +    if (hdr_size > data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "frame data too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    version = AV_RB16(buf + 2);
 +    if (version >= 2) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "unsupported header version: %d\n", version);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    width  = AV_RB16(buf + 8);
 +    height = AV_RB16(buf + 10);
 +    if (width != avctx->width || height != avctx->height) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "picture dimension changed: old: %d x %d, new: %d x %d\n",
 +               avctx->width, avctx->height, width, height);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->frame_type = (buf[12] >> 2) & 3;
 +    if (ctx->frame_type > 2) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "unsupported frame type: %d\n", ctx->frame_type);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->chroma_factor     = (buf[12] >> 6) & 3;
 +    ctx->mb_chroma_factor  = ctx->chroma_factor + 2;
 +    ctx->num_chroma_blocks = (1 << ctx->chroma_factor) >> 1;
 +    ctx->alpha_info        = buf[17] & 0xf;
 +
 +    if (ctx->alpha_info > 2) {
 +        av_log(avctx, AV_LOG_ERROR, "Invalid alpha mode %d\n", ctx->alpha_info);
 +        return AVERROR_INVALIDDATA;
 +    }
 +    if (avctx->skip_alpha) ctx->alpha_info = 0;
 +
 +    switch (ctx->chroma_factor) {
 +    case 2:
 +        avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA422P10
 +                                         : AV_PIX_FMT_YUV422P10;
 +        break;
 +    case 3:
 +        avctx->pix_fmt = ctx->alpha_info ? AV_PIX_FMT_YUVA444P10
 +                                         : AV_PIX_FMT_YUV444P10;
 +        break;
 +    default:
 +        av_log(avctx, AV_LOG_ERROR,
 +               "unsupported picture format: %d\n", ctx->pic_format);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    if (ctx->scantable_type != ctx->frame_type) {
 +        if (!ctx->frame_type)
 +            ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,
 +                              ff_prores_progressive_scan);
 +        else
 +            ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable,
 +                              ff_prores_interlaced_scan);
 +        ctx->scantable_type = ctx->frame_type;
 +    }
 +
 +    if (ctx->frame_type) {      /* if interlaced */
 +        ctx->frame->interlaced_frame = 1;
 +        ctx->frame->top_field_first  = ctx->frame_type & 1;
 +    } else {
 +        ctx->frame->interlaced_frame = 0;
 +    }
 +
 +    avctx->color_primaries = buf[14];
 +    avctx->color_trc       = buf[15];
 +    avctx->colorspace      = buf[16];
 +
 +    ctx->qmat_changed = 0;
 +    ptr   = buf + 20;
 +    flags = buf[19];
 +    if (flags & 2) {
 +        if (ptr - buf > hdr_size - 64) {
 +            av_log(avctx, AV_LOG_ERROR, "header data too small\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +        if (memcmp(ctx->qmat_luma, ptr, 64)) {
 +            memcpy(ctx->qmat_luma, ptr, 64);
 +            ctx->qmat_changed = 1;
 +        }
 +        ptr += 64;
 +    } else {
 +        memset(ctx->qmat_luma, 4, 64);
 +        ctx->qmat_changed = 1;
 +    }
 +
 +    if (flags & 1) {
 +        if (ptr - buf > hdr_size - 64) {
 +            av_log(avctx, AV_LOG_ERROR, "header data too small\n");
 +            return -1;
 +        }
 +        if (memcmp(ctx->qmat_chroma, ptr, 64)) {
 +            memcpy(ctx->qmat_chroma, ptr, 64);
 +            ctx->qmat_changed = 1;
 +        }
 +    } else {
 +        memset(ctx->qmat_chroma, 4, 64);
 +        ctx->qmat_changed = 1;
 +    }
 +
 +    return hdr_size;
 +}
 +
 +
 +static int decode_picture_header(ProresContext *ctx, const uint8_t *buf,
 +                                 const int data_size, AVCodecContext *avctx)
 +{
 +    int   i, hdr_size, pic_data_size, num_slices;
 +    int   slice_width_factor, slice_height_factor;
 +    int   remainder, num_x_slices;
 +    const uint8_t *data_ptr, *index_ptr;
 +
 +    hdr_size = data_size > 0 ? buf[0] >> 3 : 0;
 +    if (hdr_size < 8 || hdr_size > data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "picture header too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    pic_data_size = AV_RB32(buf + 1);
 +    if (pic_data_size > data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "picture data too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    slice_width_factor  = buf[7] >> 4;
 +    slice_height_factor = buf[7] & 0xF;
 +    if (slice_width_factor > 3 || slice_height_factor) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "unsupported slice dimension: %d x %d\n",
 +               1 << slice_width_factor, 1 << slice_height_factor);
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->slice_width_factor  = slice_width_factor;
 +    ctx->slice_height_factor = slice_height_factor;
 +
 +    ctx->num_x_mbs = (avctx->width + 15) >> 4;
 +    ctx->num_y_mbs = (avctx->height +
 +                      (1 << (4 + ctx->frame->interlaced_frame)) - 1) >>
 +                     (4 + ctx->frame->interlaced_frame);
 +
 +    remainder    = ctx->num_x_mbs & ((1 << slice_width_factor) - 1);
 +    num_x_slices = (ctx->num_x_mbs >> slice_width_factor) + (remainder & 1) +
 +                   ((remainder >> 1) & 1) + ((remainder >> 2) & 1);
 +
 +    num_slices = num_x_slices * ctx->num_y_mbs;
 +    if (num_slices != AV_RB16(buf + 5)) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid number of slices\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    if (ctx->total_slices != num_slices) {
 +        av_freep(&ctx->slice_data);
 +        ctx->slice_data = av_malloc((num_slices + 1) * sizeof(ctx->slice_data[0]));
 +        if (!ctx->slice_data)
 +            return AVERROR(ENOMEM);
 +        ctx->total_slices = num_slices;
 +    }
 +
 +    if (hdr_size + num_slices * 2 > data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "slice table too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    /* parse slice table allowing quick access to the slice data */
 +    index_ptr = buf + hdr_size;
 +    data_ptr = index_ptr + num_slices * 2;
 +
 +    for (i = 0; i < num_slices; i++) {
 +        ctx->slice_data[i].index = data_ptr;
 +        ctx->slice_data[i].prev_slice_sf = 0;
 +        data_ptr += AV_RB16(index_ptr + i * 2);
 +    }
 +    ctx->slice_data[i].index = data_ptr;
 +    ctx->slice_data[i].prev_slice_sf = 0;
 +
 +    if (data_ptr > buf + data_size) {
 +        av_log(avctx, AV_LOG_ERROR, "out of slice data\n");
 +        return -1;
 +    }
 +
 +    return pic_data_size;
 +}
 +
 +
 +/**
 + * Read an unsigned rice/exp golomb codeword.
 + */
 +static inline int decode_vlc_codeword(GetBitContext *gb, unsigned codebook)
 +{
 +    unsigned int rice_order, exp_order, switch_bits;
 +    unsigned int buf, code;
 +    int log, prefix_len, len;
 +
 +    OPEN_READER(re, gb);
 +    UPDATE_CACHE(re, gb);
 +    buf = GET_CACHE(re, gb);
 +
 +    /* number of prefix bits to switch between Rice and expGolomb */
 +    switch_bits = (codebook & 3) + 1;
 +    rice_order  = codebook >> 5;        /* rice code order */
 +    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 +
 +    log = 31 - av_log2(buf); /* count prefix bits (zeroes) */
 +
 +    if (log < switch_bits) { /* ok, we got a rice code */
 +        if (!rice_order) {
 +            /* shortcut for faster decoding of rice codes without remainder */
 +            code = log;
 +            LAST_SKIP_BITS(re, gb, log + 1);
 +        } else {
 +            prefix_len = log + 1;
 +            code = (log << rice_order) + NEG_USR32(buf << prefix_len, rice_order);
 +            LAST_SKIP_BITS(re, gb, prefix_len + rice_order);
 +        }
 +    } else { /* otherwise we got a exp golomb code */
 +        len  = (log << 1) - switch_bits + exp_order + 1;
 +        code = NEG_USR32(buf, len) - (1 << exp_order) + (switch_bits << rice_order);
 +        LAST_SKIP_BITS(re, gb, len);
 +    }
 +
 +    CLOSE_READER(re, gb);
 +
 +    return code;
 +}
 +
 +#define LSB2SIGN(x) (-((x) & 1))
 +#define TOSIGNED(x) (((x) >> 1) ^ LSB2SIGN(x))
 +
 +/**
 + * Decode DC coefficients for all blocks in a slice.
 + */
 +static inline void decode_dc_coeffs(GetBitContext *gb, int16_t *out,
 +                                    int nblocks)
 +{
 +    int16_t prev_dc;
 +    int     i, sign;
 +    int16_t delta;
 +    unsigned int code;
 +
 +    code   = decode_vlc_codeword(gb, FIRST_DC_CB);
 +    out[0] = prev_dc = TOSIGNED(code);
 +
 +    out   += 64; /* move to the DC coeff of the next block */
 +    delta  = 3;
 +
 +    for (i = 1; i < nblocks; i++, out += 64) {
 +        code = decode_vlc_codeword(gb, ff_prores_dc_codebook[FFMIN(FFABS(delta), 3)]);
 +
 +        sign     = -(((delta >> 15) & 1) ^ (code & 1));
 +        delta    = (((code + 1) >> 1) ^ sign) - sign;
 +        prev_dc += delta;
 +        out[0]   = prev_dc;
 +    }
 +}
 +
 +
 +/**
 + * Decode AC coefficients for all blocks in a slice.
 + */
 +static inline void decode_ac_coeffs(GetBitContext *gb, int16_t *out,
 +                                    int blocks_per_slice,
 +                                    int plane_size_factor,
 +                                    const uint8_t *scan)
 +{
 +    int pos, block_mask, run, level, sign, run_cb_index, lev_cb_index;
 +    int max_coeffs, bits_left;
 +
 +    /* set initial prediction values */
 +    run   = 4;
 +    level = 2;
 +
 +    max_coeffs = blocks_per_slice << 6;
 +    block_mask = blocks_per_slice - 1;
 +
 +    for (pos = blocks_per_slice - 1; pos < max_coeffs;) {
 +        run_cb_index = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 +        lev_cb_index = ff_prores_lev_to_cb_index[FFMIN(level, 9)];
 +
 +        bits_left = get_bits_left(gb);
 +        if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
 +            return;
 +
 +        run = decode_vlc_codeword(gb, ff_prores_ac_codebook[run_cb_index]);
 +
 +        bits_left = get_bits_left(gb);
 +        if (bits_left <= 0 || (bits_left <= 8 && !show_bits(gb, bits_left)))
 +            return;
 +
 +        level = decode_vlc_codeword(gb, ff_prores_ac_codebook[lev_cb_index]) + 1;
 +
 +        pos += run + 1;
 +        if (pos >= max_coeffs)
 +            break;
 +
 +        sign = get_sbits(gb, 1);
 +        out[((pos & block_mask) << 6) + scan[pos >> plane_size_factor]] =
 +            (level ^ sign) - sign;
 +    }
 +}
 +
 +
 +/**
 + * Decode a slice plane (luma or chroma).
 + */
 +static void decode_slice_plane(ProresContext *ctx, ProresThreadData *td,
 +                               const uint8_t *buf,
 +                               int data_size, uint16_t *out_ptr,
 +                               int linesize, int mbs_per_slice,
 +                               int blocks_per_mb, int plane_size_factor,
 +                               const int16_t *qmat, int is_chroma)
 +{
 +    GetBitContext gb;
 +    int16_t *block_ptr;
 +    int mb_num, blocks_per_slice;
 +
 +    blocks_per_slice = mbs_per_slice * blocks_per_mb;
 +
 +    memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
 +
 +    init_get_bits(&gb, buf, data_size << 3);
 +
 +    decode_dc_coeffs(&gb, td->blocks, blocks_per_slice);
 +
 +    decode_ac_coeffs(&gb, td->blocks, blocks_per_slice,
 +                     plane_size_factor, ctx->scantable.permutated);
 +
 +    /* inverse quantization, inverse transform and output */
 +    block_ptr = td->blocks;
 +
 +    if (!is_chroma) {
 +        for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
 +            ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
 +            block_ptr += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
 +                block_ptr += 64;
 +            }
 +            ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
 +            block_ptr += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
 +                block_ptr += 64;
 +            }
 +        }
 +    } else {
 +        for (mb_num = 0; mb_num < mbs_per_slice; mb_num++, out_ptr += blocks_per_mb * 4) {
 +            ctx->dsp.idct_put(out_ptr,                    linesize, block_ptr, qmat);
 +            block_ptr += 64;
 +            ctx->dsp.idct_put(out_ptr + linesize * 4,     linesize, block_ptr, qmat);
 +            block_ptr += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.idct_put(out_ptr + 8,            linesize, block_ptr, qmat);
 +                block_ptr += 64;
 +                ctx->dsp.idct_put(out_ptr + linesize * 4 + 8, linesize, block_ptr, qmat);
 +                block_ptr += 64;
 +            }
 +        }
 +    }
 +}
 +
 +
 +static void unpack_alpha(GetBitContext *gb, uint16_t *dst, int num_coeffs,
 +                         const int num_bits)
 +{
 +    const int mask = (1 << num_bits) - 1;
 +    int i, idx, val, alpha_val;
 +
 +    idx       = 0;
 +    alpha_val = mask;
 +    do {
 +        do {
 +            if (get_bits1(gb))
 +                val = get_bits(gb, num_bits);
 +            else {
 +                int sign;
 +                val  = get_bits(gb, num_bits == 16 ? 7 : 4);
 +                sign = val & 1;
 +                val  = (val + 2) >> 1;
 +                if (sign)
 +                    val = -val;
 +            }
 +            alpha_val = (alpha_val + val) & mask;
 +            if (num_bits == 16)
 +                dst[idx++] = alpha_val >> 6;
 +            else
 +                dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
 +            if (idx >= num_coeffs) {
 +                break;
 +            }
 +        } while (get_bits1(gb));
 +        val = get_bits(gb, 4);
 +        if (!val)
 +            val = get_bits(gb, 11);
 +        if (idx + val > num_coeffs)
 +            val = num_coeffs - idx;
 +        if (num_bits == 16)
 +            for (i = 0; i < val; i++)
 +                dst[idx++] = alpha_val >> 6;
 +        else
 +            for (i = 0; i < val; i++)
 +                dst[idx++] = (alpha_val << 2) | (alpha_val >> 6);
 +    } while (idx < num_coeffs);
 +}
 +
 +/**
 + * Decode alpha slice plane.
 + */
 +static void decode_alpha_plane(ProresContext *ctx, ProresThreadData *td,
 +                               const uint8_t *buf, int data_size,
 +                               uint16_t *out_ptr, int linesize,
 +                               int mbs_per_slice)
 +{
 +    GetBitContext gb;
 +    int i;
 +    uint16_t *block_ptr;
 +
 +    memset(td->blocks, 0, 8 * 4 * 64 * sizeof(*td->blocks));
 +
 +    init_get_bits(&gb, buf, data_size << 3);
 +
 +    if (ctx->alpha_info == 2)
 +        unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 16);
 +    else
 +        unpack_alpha(&gb, td->blocks, mbs_per_slice * 4 * 64, 8);
 +
 +    block_ptr = td->blocks;
 +
 +    for (i = 0; i < 16; i++) {
 +        memcpy(out_ptr, block_ptr, 16 * mbs_per_slice * sizeof(*out_ptr));
 +        out_ptr   += linesize >> 1;
 +        block_ptr += 16 * mbs_per_slice;
 +    }
 +}
 +
 +static int decode_slice(AVCodecContext *avctx, void *tdata)
 +{
 +    ProresThreadData *td = tdata;
 +    ProresContext *ctx = avctx->priv_data;
 +    int mb_x_pos  = td->x_pos;
 +    int mb_y_pos  = td->y_pos;
 +    int pic_num   = ctx->pic_num;
 +    int slice_num = td->slice_num;
 +    int mbs_per_slice = td->slice_width;
 +    const uint8_t *buf;
 +    uint8_t *y_data, *u_data, *v_data, *a_data;
 +    AVFrame *pic = ctx->frame;
 +    int i, sf, slice_width_factor;
 +    int slice_data_size, hdr_size;
 +    int y_data_size, u_data_size, v_data_size, a_data_size;
 +    int y_linesize, u_linesize, v_linesize, a_linesize;
 +    int coff[4];
 +
 +    buf             = ctx->slice_data[slice_num].index;
 +    slice_data_size = ctx->slice_data[slice_num + 1].index - buf;
 +
 +    slice_width_factor = av_log2(mbs_per_slice);
 +
 +    y_data     = pic->data[0];
 +    u_data     = pic->data[1];
 +    v_data     = pic->data[2];
 +    a_data     = pic->data[3];
 +    y_linesize = pic->linesize[0];
 +    u_linesize = pic->linesize[1];
 +    v_linesize = pic->linesize[2];
 +    a_linesize = pic->linesize[3];
 +
 +    if (pic->interlaced_frame) {
 +        if (!(pic_num ^ pic->top_field_first)) {
 +            y_data += y_linesize;
 +            u_data += u_linesize;
 +            v_data += v_linesize;
 +            if (a_data)
 +                a_data += a_linesize;
 +        }
 +        y_linesize <<= 1;
 +        u_linesize <<= 1;
 +        v_linesize <<= 1;
 +        a_linesize <<= 1;
 +    }
 +    y_data += (mb_y_pos << 4) * y_linesize + (mb_x_pos << 5);
 +    u_data += (mb_y_pos << 4) * u_linesize + (mb_x_pos << ctx->mb_chroma_factor);
 +    v_data += (mb_y_pos << 4) * v_linesize + (mb_x_pos << ctx->mb_chroma_factor);
 +    if (a_data)
 +        a_data += (mb_y_pos << 4) * a_linesize + (mb_x_pos << 5);
 +
 +    if (slice_data_size < 6) {
 +        av_log(avctx, AV_LOG_ERROR, "slice data too small\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    /* parse slice header */
 +    hdr_size    = buf[0] >> 3;
 +    coff[0]     = hdr_size;
 +    y_data_size = AV_RB16(buf + 2);
 +    coff[1]     = coff[0] + y_data_size;
 +    u_data_size = AV_RB16(buf + 4);
 +    coff[2]     = coff[1] + u_data_size;
 +    v_data_size = hdr_size > 7 ? AV_RB16(buf + 6) : slice_data_size - coff[2];
 +    coff[3]     = coff[2] + v_data_size;
 +    a_data_size = ctx->alpha_info ? slice_data_size - coff[3] : 0;
 +
 +    /* if V or alpha component size is negative that means that previous
 +       component sizes are too large */
 +    if (v_data_size < 0 || a_data_size < 0 || hdr_size < 6) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid data size\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    sf = av_clip(buf[1], 1, 224);
 +    sf = sf > 128 ? (sf - 96) << 2 : sf;
 +
 +    /* scale quantization matrixes according with slice's scale factor */
 +    /* TODO: this can be SIMD-optimized a lot */
 +    if (ctx->qmat_changed || sf != td->prev_slice_sf) {
 +        td->prev_slice_sf = sf;
 +        for (i = 0; i < 64; i++) {
 +            td->qmat_luma_scaled[ctx->dsp.idct_permutation[i]]   = ctx->qmat_luma[i]   * sf;
 +            td->qmat_chroma_scaled[ctx->dsp.idct_permutation[i]] = ctx->qmat_chroma[i] * sf;
 +        }
 +    }
 +
 +    /* decode luma plane */
 +    decode_slice_plane(ctx, td, buf + coff[0], y_data_size,
 +                       (uint16_t*) y_data, y_linesize,
 +                       mbs_per_slice, 4, slice_width_factor + 2,
 +                       td->qmat_luma_scaled, 0);
 +
 +    /* decode U chroma plane */
 +    decode_slice_plane(ctx, td, buf + coff[1], u_data_size,
 +                       (uint16_t*) u_data, u_linesize,
 +                       mbs_per_slice, ctx->num_chroma_blocks,
 +                       slice_width_factor + ctx->chroma_factor - 1,
 +                       td->qmat_chroma_scaled, 1);
 +
 +    /* decode V chroma plane */
 +    decode_slice_plane(ctx, td, buf + coff[2], v_data_size,
 +                       (uint16_t*) v_data, v_linesize,
 +                       mbs_per_slice, ctx->num_chroma_blocks,
 +                       slice_width_factor + ctx->chroma_factor - 1,
 +                       td->qmat_chroma_scaled, 1);
 +
 +    /* decode alpha plane if available */
 +    if (a_data && a_data_size)
 +        decode_alpha_plane(ctx, td, buf + coff[3], a_data_size,
 +                           (uint16_t*) a_data, a_linesize,
 +                           mbs_per_slice);
 +
 +    return 0;
 +}
 +
 +
 +static int decode_picture(ProresContext *ctx, int pic_num,
 +                          AVCodecContext *avctx)
 +{
 +    int slice_num, slice_width, x_pos, y_pos;
 +
 +    slice_num = 0;
 +
 +    ctx->pic_num = pic_num;
 +    for (y_pos = 0; y_pos < ctx->num_y_mbs; y_pos++) {
 +        slice_width = 1 << ctx->slice_width_factor;
 +
 +        for (x_pos = 0; x_pos < ctx->num_x_mbs && slice_width;
 +             x_pos += slice_width) {
 +            while (ctx->num_x_mbs - x_pos < slice_width)
 +                slice_width >>= 1;
 +
 +            ctx->slice_data[slice_num].slice_num   = slice_num;
 +            ctx->slice_data[slice_num].x_pos       = x_pos;
 +            ctx->slice_data[slice_num].y_pos       = y_pos;
 +            ctx->slice_data[slice_num].slice_width = slice_width;
 +
 +            slice_num++;
 +        }
 +    }
 +
 +    return avctx->execute(avctx, decode_slice,
 +                          ctx->slice_data, NULL, slice_num,
 +                          sizeof(ctx->slice_data[0]));
 +}
 +
 +
 +#define MOVE_DATA_PTR(nbytes) buf += (nbytes); buf_size -= (nbytes)
 +
 +static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 +                        AVPacket *avpkt)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    const uint8_t *buf = avpkt->data;
 +    int buf_size       = avpkt->size;
 +    int frame_hdr_size, pic_num, pic_data_size;
 +
 +    ctx->frame            = data;
 +    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
 +    ctx->frame->key_frame = 1;
 +
 +    /* check frame atom container */
 +    if (buf_size < 28 || buf_size < AV_RB32(buf) ||
 +        AV_RB32(buf + 4) != FRAME_ID) {
 +        av_log(avctx, AV_LOG_ERROR, "invalid frame\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    MOVE_DATA_PTR(8);
 +
 +    frame_hdr_size = decode_frame_header(ctx, buf, buf_size, avctx);
 +    if (frame_hdr_size < 0)
 +        return AVERROR_INVALIDDATA;
 +
 +    MOVE_DATA_PTR(frame_hdr_size);
 +
 +    if (ff_get_buffer(avctx, ctx->frame, 0) < 0)
 +        return -1;
 +
 +    for (pic_num = 0; ctx->frame->interlaced_frame - pic_num + 1; pic_num++) {
 +        pic_data_size = decode_picture_header(ctx, buf, buf_size, avctx);
 +        if (pic_data_size < 0)
 +            return AVERROR_INVALIDDATA;
 +
 +        if (decode_picture(ctx, pic_num, avctx))
 +            return -1;
 +
 +        MOVE_DATA_PTR(pic_data_size);
 +    }
 +
 +    ctx->frame = NULL;
 +    *got_frame = 1;
 +
 +    return avpkt->size;
 +}
 +
 +
 +static av_cold int decode_close(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +
 +    av_freep(&ctx->slice_data);
 +
 +    return 0;
 +}
 +
 +
 +AVCodec ff_prores_lgpl_decoder = {
 +    .name           = "prores_lgpl",
++    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_PRORES,
 +    .priv_data_size = sizeof(ProresContext),
 +    .init           = decode_init,
 +    .close          = decode_close,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
 +};
index d5400b4,0000000..510b408
mode 100644,000000..100644
--- /dev/null
@@@ -1,1276 -1,0 +1,1276 @@@
-     .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
 +/*
 + * Apple ProRes encoder
 + *
 + * Copyright (c) 2012 Konstantin Shishkov
 + *
 + * This encoder appears to be based on Anatoliy Wassermans considering
 + * similarities in the bugs.
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "avcodec.h"
 +#include "dsputil.h"
 +#include "put_bits.h"
 +#include "bytestream.h"
 +#include "internal.h"
 +#include "proresdsp.h"
 +#include "proresdata.h"
 +
 +#define CFACTOR_Y422 2
 +#define CFACTOR_Y444 3
 +
 +#define MAX_MBS_PER_SLICE 8
 +
 +#define MAX_PLANES 4
 +
 +enum {
 +    PRORES_PROFILE_PROXY = 0,
 +    PRORES_PROFILE_LT,
 +    PRORES_PROFILE_STANDARD,
 +    PRORES_PROFILE_HQ,
 +    PRORES_PROFILE_4444,
 +};
 +
 +enum {
 +    QUANT_MAT_PROXY = 0,
 +    QUANT_MAT_LT,
 +    QUANT_MAT_STANDARD,
 +    QUANT_MAT_HQ,
 +    QUANT_MAT_DEFAULT,
 +};
 +
 +static const uint8_t prores_quant_matrices[][64] = {
 +    { // proxy
 +         4,  7,  9, 11, 13, 14, 15, 63,
 +         7,  7, 11, 12, 14, 15, 63, 63,
 +         9, 11, 13, 14, 15, 63, 63, 63,
 +        11, 11, 13, 14, 63, 63, 63, 63,
 +        11, 13, 14, 63, 63, 63, 63, 63,
 +        13, 14, 63, 63, 63, 63, 63, 63,
 +        13, 63, 63, 63, 63, 63, 63, 63,
 +        63, 63, 63, 63, 63, 63, 63, 63,
 +    },
 +    { // LT
 +         4,  5,  6,  7,  9, 11, 13, 15,
 +         5,  5,  7,  8, 11, 13, 15, 17,
 +         6,  7,  9, 11, 13, 15, 15, 17,
 +         7,  7,  9, 11, 13, 15, 17, 19,
 +         7,  9, 11, 13, 14, 16, 19, 23,
 +         9, 11, 13, 14, 16, 19, 23, 29,
 +         9, 11, 13, 15, 17, 21, 28, 35,
 +        11, 13, 16, 17, 21, 28, 35, 41,
 +    },
 +    { // standard
 +         4,  4,  5,  5,  6,  7,  7,  9,
 +         4,  4,  5,  6,  7,  7,  9,  9,
 +         5,  5,  6,  7,  7,  9,  9, 10,
 +         5,  5,  6,  7,  7,  9,  9, 10,
 +         5,  6,  7,  7,  8,  9, 10, 12,
 +         6,  7,  7,  8,  9, 10, 12, 15,
 +         6,  7,  7,  9, 10, 11, 14, 17,
 +         7,  7,  9, 10, 11, 14, 17, 21,
 +    },
 +    { // high quality
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  5,
 +         4,  4,  4,  4,  4,  4,  5,  5,
 +         4,  4,  4,  4,  4,  5,  5,  6,
 +         4,  4,  4,  4,  5,  5,  6,  7,
 +         4,  4,  4,  4,  5,  6,  7,  7,
 +    },
 +    { // codec default
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +         4,  4,  4,  4,  4,  4,  4,  4,
 +    },
 +};
 +
 +#define NUM_MB_LIMITS 4
 +static const int prores_mb_limits[NUM_MB_LIMITS] = {
 +    1620, // up to 720x576
 +    2700, // up to 960x720
 +    6075, // up to 1440x1080
 +    9216, // up to 2048x1152
 +};
 +
 +static const struct prores_profile {
 +    const char *full_name;
 +    uint32_t    tag;
 +    int         min_quant;
 +    int         max_quant;
 +    int         br_tab[NUM_MB_LIMITS];
 +    int         quant;
 +} prores_profile_info[5] = {
 +    {
 +        .full_name = "proxy",
 +        .tag       = MKTAG('a', 'p', 'c', 'o'),
 +        .min_quant = 4,
 +        .max_quant = 8,
 +        .br_tab    = { 300, 242, 220, 194 },
 +        .quant     = QUANT_MAT_PROXY,
 +    },
 +    {
 +        .full_name = "LT",
 +        .tag       = MKTAG('a', 'p', 'c', 's'),
 +        .min_quant = 1,
 +        .max_quant = 9,
 +        .br_tab    = { 720, 560, 490, 440 },
 +        .quant     = QUANT_MAT_LT,
 +    },
 +    {
 +        .full_name = "standard",
 +        .tag       = MKTAG('a', 'p', 'c', 'n'),
 +        .min_quant = 1,
 +        .max_quant = 6,
 +        .br_tab    = { 1050, 808, 710, 632 },
 +        .quant     = QUANT_MAT_STANDARD,
 +    },
 +    {
 +        .full_name = "high quality",
 +        .tag       = MKTAG('a', 'p', 'c', 'h'),
 +        .min_quant = 1,
 +        .max_quant = 6,
 +        .br_tab    = { 1566, 1216, 1070, 950 },
 +        .quant     = QUANT_MAT_HQ,
 +    },
 +    {
 +        .full_name = "4444",
 +        .tag       = MKTAG('a', 'p', '4', 'h'),
 +        .min_quant = 1,
 +        .max_quant = 6,
 +        .br_tab    = { 2350, 1828, 1600, 1425 },
 +        .quant     = QUANT_MAT_HQ,
 +    }
 +};
 +
 +#define TRELLIS_WIDTH 16
 +#define SCORE_LIMIT   INT_MAX / 2
 +
 +struct TrellisNode {
 +    int prev_node;
 +    int quant;
 +    int bits;
 +    int score;
 +};
 +
 +#define MAX_STORED_Q 16
 +
 +typedef struct ProresThreadData {
 +    DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 +    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16 * 16];
 +    int16_t custom_q[64];
 +    struct TrellisNode *nodes;
 +} ProresThreadData;
 +
 +typedef struct ProresContext {
 +    AVClass *class;
 +    DECLARE_ALIGNED(16, int16_t, blocks)[MAX_PLANES][64 * 4 * MAX_MBS_PER_SLICE];
 +    DECLARE_ALIGNED(16, uint16_t, emu_buf)[16*16];
 +    int16_t quants[MAX_STORED_Q][64];
 +    int16_t custom_q[64];
 +    const uint8_t *quant_mat;
 +
 +    ProresDSPContext dsp;
 +    ScanTable  scantable;
 +
 +    int mb_width, mb_height;
 +    int mbs_per_slice;
 +    int num_chroma_blocks, chroma_factor;
 +    int slices_width;
 +    int slices_per_picture;
 +    int pictures_per_frame; // 1 for progressive, 2 for interlaced
 +    int cur_picture_idx;
 +    int num_planes;
 +    int bits_per_mb;
 +    int force_quant;
 +    int alpha_bits;
 +
 +    char *vendor;
 +    int quant_sel;
 +
 +    int frame_size_upper_bound;
 +
 +    int profile;
 +    const struct prores_profile *profile_info;
 +
 +    int *slice_q;
 +
 +    ProresThreadData *tdata;
 +} ProresContext;
 +
 +static void get_slice_data(ProresContext *ctx, const uint16_t *src,
 +                           int linesize, int x, int y, int w, int h,
 +                           int16_t *blocks, uint16_t *emu_buf,
 +                           int mbs_per_slice, int blocks_per_mb, int is_chroma)
 +{
 +    const uint16_t *esrc;
 +    const int mb_width = 4 * blocks_per_mb;
 +    int elinesize;
 +    int i, j, k;
 +
 +    for (i = 0; i < mbs_per_slice; i++, src += mb_width) {
 +        if (x >= w) {
 +            memset(blocks, 0, 64 * (mbs_per_slice - i) * blocks_per_mb
 +                              * sizeof(*blocks));
 +            return;
 +        }
 +        if (x + mb_width <= w && y + 16 <= h) {
 +            esrc      = src;
 +            elinesize = linesize;
 +        } else {
 +            int bw, bh, pix;
 +
 +            esrc      = emu_buf;
 +            elinesize = 16 * sizeof(*emu_buf);
 +
 +            bw = FFMIN(w - x, mb_width);
 +            bh = FFMIN(h - y, 16);
 +
 +            for (j = 0; j < bh; j++) {
 +                memcpy(emu_buf + j * 16,
 +                       (const uint8_t*)src + j * linesize,
 +                       bw * sizeof(*src));
 +                pix = emu_buf[j * 16 + bw - 1];
 +                for (k = bw; k < mb_width; k++)
 +                    emu_buf[j * 16 + k] = pix;
 +            }
 +            for (; j < 16; j++)
 +                memcpy(emu_buf + j * 16,
 +                       emu_buf + (bh - 1) * 16,
 +                       mb_width * sizeof(*emu_buf));
 +        }
 +        if (!is_chroma) {
 +            ctx->dsp.fdct(esrc, elinesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(esrc + 8, elinesize, blocks);
 +                blocks += 64;
 +            }
 +            ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
 +                blocks += 64;
 +            }
 +        } else {
 +            ctx->dsp.fdct(esrc, elinesize, blocks);
 +            blocks += 64;
 +            ctx->dsp.fdct(esrc + elinesize * 4, elinesize, blocks);
 +            blocks += 64;
 +            if (blocks_per_mb > 2) {
 +                ctx->dsp.fdct(esrc + 8, elinesize, blocks);
 +                blocks += 64;
 +                ctx->dsp.fdct(esrc + elinesize * 4 + 8, elinesize, blocks);
 +                blocks += 64;
 +            }
 +        }
 +
 +        x += mb_width;
 +    }
 +}
 +
 +static void get_alpha_data(ProresContext *ctx, const uint16_t *src,
 +                           int linesize, int x, int y, int w, int h,
 +                           int16_t *blocks, int mbs_per_slice, int abits)
 +{
 +    const int slice_width = 16 * mbs_per_slice;
 +    int i, j, copy_w, copy_h;
 +
 +    copy_w = FFMIN(w - x, slice_width);
 +    copy_h = FFMIN(h - y, 16);
 +    for (i = 0; i < copy_h; i++) {
 +        memcpy(blocks, src, copy_w * sizeof(*src));
 +        if (abits == 8)
 +            for (j = 0; j < copy_w; j++)
 +                blocks[j] >>= 2;
 +        else
 +            for (j = 0; j < copy_w; j++)
 +                blocks[j] = (blocks[j] << 6) | (blocks[j] >> 4);
 +        for (j = copy_w; j < slice_width; j++)
 +            blocks[j] = blocks[copy_w - 1];
 +        blocks += slice_width;
 +        src    += linesize >> 1;
 +    }
 +    for (; i < 16; i++) {
 +        memcpy(blocks, blocks - slice_width, slice_width * sizeof(*blocks));
 +        blocks += slice_width;
 +    }
 +}
 +
 +/**
 + * Write an unsigned rice/exp golomb codeword.
 + */
 +static inline void encode_vlc_codeword(PutBitContext *pb, unsigned codebook, int val)
 +{
 +    unsigned int rice_order, exp_order, switch_bits, switch_val;
 +    int exponent;
 +
 +    /* number of prefix bits to switch between Rice and expGolomb */
 +    switch_bits = (codebook & 3) + 1;
 +    rice_order  =  codebook >> 5;       /* rice code order */
 +    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 +
 +    switch_val  = switch_bits << rice_order;
 +
 +    if (val >= switch_val) {
 +        val -= switch_val - (1 << exp_order);
 +        exponent = av_log2(val);
 +
 +        put_bits(pb, exponent - exp_order + switch_bits, 0);
 +        put_bits(pb, exponent + 1, val);
 +    } else {
 +        exponent = val >> rice_order;
 +
 +        if (exponent)
 +            put_bits(pb, exponent, 0);
 +        put_bits(pb, 1, 1);
 +        if (rice_order)
 +            put_sbits(pb, rice_order, val);
 +    }
 +}
 +
 +#define GET_SIGN(x)  ((x) >> 31)
 +#define MAKE_CODE(x) (((x) << 1) ^ GET_SIGN(x))
 +
 +static void encode_dcs(PutBitContext *pb, int16_t *blocks,
 +                       int blocks_per_slice, int scale)
 +{
 +    int i;
 +    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 +
 +    prev_dc = (blocks[0] - 0x4000) / scale;
 +    encode_vlc_codeword(pb, FIRST_DC_CB, MAKE_CODE(prev_dc));
 +    sign     = 0;
 +    codebook = 3;
 +    blocks  += 64;
 +
 +    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 +        dc       = (blocks[0] - 0x4000) / scale;
 +        delta    = dc - prev_dc;
 +        new_sign = GET_SIGN(delta);
 +        delta    = (delta ^ sign) - sign;
 +        code     = MAKE_CODE(delta);
 +        encode_vlc_codeword(pb, ff_prores_dc_codebook[codebook], code);
 +        codebook = (code + (code & 1)) >> 1;
 +        codebook = FFMIN(codebook, 3);
 +        sign     = new_sign;
 +        prev_dc  = dc;
 +    }
 +}
 +
 +static void encode_acs(PutBitContext *pb, int16_t *blocks,
 +                       int blocks_per_slice,
 +                       int plane_size_factor,
 +                       const uint8_t *scan, const int16_t *qmat)
 +{
 +    int idx, i;
 +    int run, level, run_cb, lev_cb;
 +    int max_coeffs, abs_level;
 +
 +    max_coeffs = blocks_per_slice << 6;
 +    run_cb     = ff_prores_run_to_cb_index[4];
 +    lev_cb     = ff_prores_lev_to_cb_index[2];
 +    run        = 0;
 +
 +    for (i = 1; i < 64; i++) {
 +        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 +            level = blocks[idx] / qmat[scan[i]];
 +            if (level) {
 +                abs_level = FFABS(level);
 +                encode_vlc_codeword(pb, ff_prores_ac_codebook[run_cb], run);
 +                encode_vlc_codeword(pb, ff_prores_ac_codebook[lev_cb],
 +                                    abs_level - 1);
 +                put_sbits(pb, 1, GET_SIGN(level));
 +
 +                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 +                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 +                run    = 0;
 +            } else {
 +                run++;
 +            }
 +        }
 +    }
 +}
 +
 +static int encode_slice_plane(ProresContext *ctx, PutBitContext *pb,
 +                              const uint16_t *src, int linesize,
 +                              int mbs_per_slice, int16_t *blocks,
 +                              int blocks_per_mb, int plane_size_factor,
 +                              const int16_t *qmat)
 +{
 +    int blocks_per_slice, saved_pos;
 +
 +    saved_pos = put_bits_count(pb);
 +    blocks_per_slice = mbs_per_slice * blocks_per_mb;
 +
 +    encode_dcs(pb, blocks, blocks_per_slice, qmat[0]);
 +    encode_acs(pb, blocks, blocks_per_slice, plane_size_factor,
 +               ctx->scantable.permutated, qmat);
 +    flush_put_bits(pb);
 +
 +    return (put_bits_count(pb) - saved_pos) >> 3;
 +}
 +
 +static void put_alpha_diff(PutBitContext *pb, int cur, int prev, int abits)
 +{
 +    const int mask  = (1 << abits) - 1;
 +    const int dbits = (abits == 8) ? 4 : 7;
 +    const int dsize = 1 << dbits - 1;
 +    int diff = cur - prev;
 +
 +    diff &= mask;
 +    if (diff >= (1 << abits) - dsize)
 +        diff -= 1 << abits;
 +    if (diff < -dsize || diff > dsize || !diff) {
 +        put_bits(pb, 1, 1);
 +        put_bits(pb, abits, diff);
 +    } else {
 +        put_bits(pb, 1, 0);
 +        put_bits(pb, dbits - 1, FFABS(diff) - 1);
 +        put_bits(pb, 1, diff < 0);
 +    }
 +}
 +
 +static void put_alpha_run(PutBitContext *pb, int run)
 +{
 +    if (run) {
 +        put_bits(pb, 1, 0);
 +        if (run < 0x10)
 +            put_bits(pb, 4, run);
 +        else
 +            put_bits(pb, 15, run);
 +    } else {
 +        put_bits(pb, 1, 1);
 +    }
 +}
 +
 +// todo alpha quantisation for high quants
 +static int encode_alpha_plane(ProresContext *ctx, PutBitContext *pb,
 +                              const uint16_t *src, int linesize,
 +                              int mbs_per_slice, uint16_t *blocks,
 +                              int quant)
 +{
 +    const int abits = ctx->alpha_bits;
 +    const int mask  = (1 << abits) - 1;
 +    const int num_coeffs = mbs_per_slice * 256;
 +    int saved_pos = put_bits_count(pb);
 +    int prev = mask, cur;
 +    int idx = 0;
 +    int run = 0;
 +
 +    cur = blocks[idx++];
 +    put_alpha_diff(pb, cur, prev, abits);
 +    prev = cur;
 +    do {
 +        cur = blocks[idx++];
 +        if (cur != prev) {
 +            put_alpha_run (pb, run);
 +            put_alpha_diff(pb, cur, prev, abits);
 +            prev = cur;
 +            run  = 0;
 +        } else {
 +            run++;
 +        }
 +    } while (idx < num_coeffs);
 +    if (run)
 +        put_alpha_run(pb, run);
 +    flush_put_bits(pb);
 +    return (put_bits_count(pb) - saved_pos) >> 3;
 +}
 +
 +static int encode_slice(AVCodecContext *avctx, const AVFrame *pic,
 +                        PutBitContext *pb,
 +                        int sizes[4], int x, int y, int quant,
 +                        int mbs_per_slice)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i, xp, yp;
 +    int total_size = 0;
 +    const uint16_t *src;
 +    int slice_width_factor = av_log2(mbs_per_slice);
 +    int num_cblocks, pwidth, linesize, line_add;
 +    int plane_factor, is_chroma;
 +    uint16_t *qmat;
 +
 +    if (ctx->pictures_per_frame == 1)
 +        line_add = 0;
 +    else
 +        line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
 +
 +    if (ctx->force_quant) {
 +        qmat = ctx->quants[0];
 +    } else if (quant < MAX_STORED_Q) {
 +        qmat = ctx->quants[quant];
 +    } else {
 +        qmat = ctx->custom_q;
 +        for (i = 0; i < 64; i++)
 +            qmat[i] = ctx->quant_mat[i] * quant;
 +    }
 +
 +    for (i = 0; i < ctx->num_planes; i++) {
 +        is_chroma    = (i == 1 || i == 2);
 +        plane_factor = slice_width_factor + 2;
 +        if (is_chroma)
 +            plane_factor += ctx->chroma_factor - 3;
 +        if (!is_chroma || ctx->chroma_factor == CFACTOR_Y444) {
 +            xp          = x << 4;
 +            yp          = y << 4;
 +            num_cblocks = 4;
 +            pwidth      = avctx->width;
 +        } else {
 +            xp          = x << 3;
 +            yp          = y << 4;
 +            num_cblocks = 2;
 +            pwidth      = avctx->width >> 1;
 +        }
 +
 +        linesize = pic->linesize[i] * ctx->pictures_per_frame;
 +        src = (const uint16_t*)(pic->data[i] + yp * linesize +
 +                                line_add * pic->linesize[i]) + xp;
 +
 +        if (i < 3) {
 +            get_slice_data(ctx, src, linesize, xp, yp,
 +                           pwidth, avctx->height / ctx->pictures_per_frame,
 +                           ctx->blocks[0], ctx->emu_buf,
 +                           mbs_per_slice, num_cblocks, is_chroma);
 +            sizes[i] = encode_slice_plane(ctx, pb, src, linesize,
 +                                          mbs_per_slice, ctx->blocks[0],
 +                                          num_cblocks, plane_factor,
 +                                          qmat);
 +        } else {
 +            get_alpha_data(ctx, src, linesize, xp, yp,
 +                           pwidth, avctx->height / ctx->pictures_per_frame,
 +                           ctx->blocks[0], mbs_per_slice, ctx->alpha_bits);
 +            sizes[i] = encode_alpha_plane(ctx, pb, src, linesize,
 +                                          mbs_per_slice, ctx->blocks[0],
 +                                          quant);
 +        }
 +        total_size += sizes[i];
 +    }
 +    return total_size;
 +}
 +
 +static inline int estimate_vlc(unsigned codebook, int val)
 +{
 +    unsigned int rice_order, exp_order, switch_bits, switch_val;
 +    int exponent;
 +
 +    /* number of prefix bits to switch between Rice and expGolomb */
 +    switch_bits = (codebook & 3) + 1;
 +    rice_order  =  codebook >> 5;       /* rice code order */
 +    exp_order   = (codebook >> 2) & 7;  /* exp golomb code order */
 +
 +    switch_val  = switch_bits << rice_order;
 +
 +    if (val >= switch_val) {
 +        val -= switch_val - (1 << exp_order);
 +        exponent = av_log2(val);
 +
 +        return exponent * 2 - exp_order + switch_bits + 1;
 +    } else {
 +        return (val >> rice_order) + rice_order + 1;
 +    }
 +}
 +
 +static int estimate_dcs(int *error, int16_t *blocks, int blocks_per_slice,
 +                        int scale)
 +{
 +    int i;
 +    int codebook = 3, code, dc, prev_dc, delta, sign, new_sign;
 +    int bits;
 +
 +    prev_dc  = (blocks[0] - 0x4000) / scale;
 +    bits     = estimate_vlc(FIRST_DC_CB, MAKE_CODE(prev_dc));
 +    sign     = 0;
 +    codebook = 3;
 +    blocks  += 64;
 +    *error  += FFABS(blocks[0] - 0x4000) % scale;
 +
 +    for (i = 1; i < blocks_per_slice; i++, blocks += 64) {
 +        dc       = (blocks[0] - 0x4000) / scale;
 +        *error  += FFABS(blocks[0] - 0x4000) % scale;
 +        delta    = dc - prev_dc;
 +        new_sign = GET_SIGN(delta);
 +        delta    = (delta ^ sign) - sign;
 +        code     = MAKE_CODE(delta);
 +        bits    += estimate_vlc(ff_prores_dc_codebook[codebook], code);
 +        codebook = (code + (code & 1)) >> 1;
 +        codebook = FFMIN(codebook, 3);
 +        sign     = new_sign;
 +        prev_dc  = dc;
 +    }
 +
 +    return bits;
 +}
 +
 +static int estimate_acs(int *error, int16_t *blocks, int blocks_per_slice,
 +                        int plane_size_factor,
 +                        const uint8_t *scan, const int16_t *qmat)
 +{
 +    int idx, i;
 +    int run, level, run_cb, lev_cb;
 +    int max_coeffs, abs_level;
 +    int bits = 0;
 +
 +    max_coeffs = blocks_per_slice << 6;
 +    run_cb     = ff_prores_run_to_cb_index[4];
 +    lev_cb     = ff_prores_lev_to_cb_index[2];
 +    run        = 0;
 +
 +    for (i = 1; i < 64; i++) {
 +        for (idx = scan[i]; idx < max_coeffs; idx += 64) {
 +            level   = blocks[idx] / qmat[scan[i]];
 +            *error += FFABS(blocks[idx]) % qmat[scan[i]];
 +            if (level) {
 +                abs_level = FFABS(level);
 +                bits += estimate_vlc(ff_prores_ac_codebook[run_cb], run);
 +                bits += estimate_vlc(ff_prores_ac_codebook[lev_cb],
 +                                     abs_level - 1) + 1;
 +
 +                run_cb = ff_prores_run_to_cb_index[FFMIN(run, 15)];
 +                lev_cb = ff_prores_lev_to_cb_index[FFMIN(abs_level, 9)];
 +                run    = 0;
 +            } else {
 +                run++;
 +            }
 +        }
 +    }
 +
 +    return bits;
 +}
 +
 +static int estimate_slice_plane(ProresContext *ctx, int *error, int plane,
 +                                const uint16_t *src, int linesize,
 +                                int mbs_per_slice,
 +                                int blocks_per_mb, int plane_size_factor,
 +                                const int16_t *qmat, ProresThreadData *td)
 +{
 +    int blocks_per_slice;
 +    int bits;
 +
 +    blocks_per_slice = mbs_per_slice * blocks_per_mb;
 +
 +    bits  = estimate_dcs(error, td->blocks[plane], blocks_per_slice, qmat[0]);
 +    bits += estimate_acs(error, td->blocks[plane], blocks_per_slice,
 +                         plane_size_factor, ctx->scantable.permutated, qmat);
 +
 +    return FFALIGN(bits, 8);
 +}
 +
 +static int est_alpha_diff(int cur, int prev, int abits)
 +{
 +    const int mask  = (1 << abits) - 1;
 +    const int dbits = (abits == 8) ? 4 : 7;
 +    const int dsize = 1 << dbits - 1;
 +    int diff = cur - prev;
 +
 +    diff &= mask;
 +    if (diff >= (1 << abits) - dsize)
 +        diff -= 1 << abits;
 +    if (diff < -dsize || diff > dsize || !diff)
 +        return abits + 1;
 +    else
 +        return dbits + 1;
 +}
 +
 +static int estimate_alpha_plane(ProresContext *ctx, int *error,
 +                                const uint16_t *src, int linesize,
 +                                int mbs_per_slice, int quant,
 +                                int16_t *blocks)
 +{
 +    const int abits = ctx->alpha_bits;
 +    const int mask  = (1 << abits) - 1;
 +    const int num_coeffs = mbs_per_slice * 256;
 +    int prev = mask, cur;
 +    int idx = 0;
 +    int run = 0;
 +    int bits;
 +
 +    *error = 0;
 +    cur = blocks[idx++];
 +    bits = est_alpha_diff(cur, prev, abits);
 +    prev = cur;
 +    do {
 +        cur = blocks[idx++];
 +        if (cur != prev) {
 +            if (!run)
 +                bits++;
 +            else if (run < 0x10)
 +                bits += 4;
 +            else
 +                bits += 15;
 +            bits += est_alpha_diff(cur, prev, abits);
 +            prev = cur;
 +            run  = 0;
 +        } else {
 +            run++;
 +        }
 +    } while (idx < num_coeffs);
 +
 +    if (run) {
 +        if (run < 0x10)
 +            bits += 4;
 +        else
 +            bits += 15;
 +    }
 +
 +    return bits;
 +}
 +
 +static int find_slice_quant(AVCodecContext *avctx, const AVFrame *pic,
 +                            int trellis_node, int x, int y, int mbs_per_slice,
 +                            ProresThreadData *td)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i, q, pq, xp, yp;
 +    const uint16_t *src;
 +    int slice_width_factor = av_log2(mbs_per_slice);
 +    int num_cblocks[MAX_PLANES], pwidth;
 +    int plane_factor[MAX_PLANES], is_chroma[MAX_PLANES];
 +    const int min_quant = ctx->profile_info->min_quant;
 +    const int max_quant = ctx->profile_info->max_quant;
 +    int error, bits, bits_limit;
 +    int mbs, prev, cur, new_score;
 +    int slice_bits[TRELLIS_WIDTH], slice_score[TRELLIS_WIDTH];
 +    int overquant;
 +    uint16_t *qmat;
 +    int linesize[4], line_add;
 +
 +    if (ctx->pictures_per_frame == 1)
 +        line_add = 0;
 +    else
 +        line_add = ctx->cur_picture_idx ^ !pic->top_field_first;
 +    mbs = x + mbs_per_slice;
 +
 +    for (i = 0; i < ctx->num_planes; i++) {
 +        is_chroma[i]    = (i == 1 || i == 2);
 +        plane_factor[i] = slice_width_factor + 2;
 +        if (is_chroma[i])
 +            plane_factor[i] += ctx->chroma_factor - 3;
 +        if (!is_chroma[i] || ctx->chroma_factor == CFACTOR_Y444) {
 +            xp             = x << 4;
 +            yp             = y << 4;
 +            num_cblocks[i] = 4;
 +            pwidth         = avctx->width;
 +        } else {
 +            xp             = x << 3;
 +            yp             = y << 4;
 +            num_cblocks[i] = 2;
 +            pwidth         = avctx->width >> 1;
 +        }
 +
 +        linesize[i] = pic->linesize[i] * ctx->pictures_per_frame;
 +        src = (const uint16_t*)(pic->data[i] + yp * linesize[i] +
 +                                line_add * pic->linesize[i]) + xp;
 +
 +        if (i < 3) {
 +            get_slice_data(ctx, src, linesize[i], xp, yp,
 +                           pwidth, avctx->height / ctx->pictures_per_frame,
 +                           td->blocks[i], td->emu_buf,
 +                           mbs_per_slice, num_cblocks[i], is_chroma[i]);
 +        } else {
 +            get_alpha_data(ctx, src, linesize[i], xp, yp,
 +                           pwidth, avctx->height / ctx->pictures_per_frame,
 +                           td->blocks[i], mbs_per_slice, ctx->alpha_bits);
 +        }
 +    }
 +
 +    for (q = min_quant; q < max_quant + 2; q++) {
 +        td->nodes[trellis_node + q].prev_node = -1;
 +        td->nodes[trellis_node + q].quant     = q;
 +    }
 +
 +    // todo: maybe perform coarser quantising to fit into frame size when needed
 +    for (q = min_quant; q <= max_quant; q++) {
 +        bits  = 0;
 +        error = 0;
 +        for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
 +            bits += estimate_slice_plane(ctx, &error, i,
 +                                         src, linesize[i],
 +                                         mbs_per_slice,
 +                                         num_cblocks[i], plane_factor[i],
 +                                         ctx->quants[q], td);
 +        }
 +        if (ctx->alpha_bits)
 +            bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
 +                                         mbs_per_slice, q, td->blocks[3]);
 +        if (bits > 65000 * 8) {
 +            error = SCORE_LIMIT;
 +            break;
 +        }
 +        slice_bits[q]  = bits;
 +        slice_score[q] = error;
 +    }
 +    if (slice_bits[max_quant] <= ctx->bits_per_mb * mbs_per_slice) {
 +        slice_bits[max_quant + 1]  = slice_bits[max_quant];
 +        slice_score[max_quant + 1] = slice_score[max_quant] + 1;
 +        overquant = max_quant;
 +    } else {
 +        for (q = max_quant + 1; q < 128; q++) {
 +            bits  = 0;
 +            error = 0;
 +            if (q < MAX_STORED_Q) {
 +                qmat = ctx->quants[q];
 +            } else {
 +                qmat = td->custom_q;
 +                for (i = 0; i < 64; i++)
 +                    qmat[i] = ctx->quant_mat[i] * q;
 +            }
 +            for (i = 0; i < ctx->num_planes - !!ctx->alpha_bits; i++) {
 +                bits += estimate_slice_plane(ctx, &error, i,
 +                                             src, linesize[i],
 +                                             mbs_per_slice,
 +                                             num_cblocks[i], plane_factor[i],
 +                                             qmat, td);
 +            }
 +            if (ctx->alpha_bits)
 +                bits += estimate_alpha_plane(ctx, &error, src, linesize[3],
 +                                             mbs_per_slice, q, td->blocks[3]);
 +            if (bits <= ctx->bits_per_mb * mbs_per_slice)
 +                break;
 +        }
 +
 +        slice_bits[max_quant + 1]  = bits;
 +        slice_score[max_quant + 1] = error;
 +        overquant = q;
 +    }
 +    td->nodes[trellis_node + max_quant + 1].quant = overquant;
 +
 +    bits_limit = mbs * ctx->bits_per_mb;
 +    for (pq = min_quant; pq < max_quant + 2; pq++) {
 +        prev = trellis_node - TRELLIS_WIDTH + pq;
 +
 +        for (q = min_quant; q < max_quant + 2; q++) {
 +            cur = trellis_node + q;
 +
 +            bits  = td->nodes[prev].bits + slice_bits[q];
 +            error = slice_score[q];
 +            if (bits > bits_limit)
 +                error = SCORE_LIMIT;
 +
 +            if (td->nodes[prev].score < SCORE_LIMIT && error < SCORE_LIMIT)
 +                new_score = td->nodes[prev].score + error;
 +            else
 +                new_score = SCORE_LIMIT;
 +            if (td->nodes[cur].prev_node == -1 ||
 +                td->nodes[cur].score >= new_score) {
 +
 +                td->nodes[cur].bits      = bits;
 +                td->nodes[cur].score     = new_score;
 +                td->nodes[cur].prev_node = prev;
 +            }
 +        }
 +    }
 +
 +    error = td->nodes[trellis_node + min_quant].score;
 +    pq    = trellis_node + min_quant;
 +    for (q = min_quant + 1; q < max_quant + 2; q++) {
 +        if (td->nodes[trellis_node + q].score <= error) {
 +            error = td->nodes[trellis_node + q].score;
 +            pq    = trellis_node + q;
 +        }
 +    }
 +
 +    return pq;
 +}
 +
 +static int find_quant_thread(AVCodecContext *avctx, void *arg,
 +                             int jobnr, int threadnr)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    ProresThreadData *td = ctx->tdata + threadnr;
 +    int mbs_per_slice = ctx->mbs_per_slice;
 +    int x, y = jobnr, mb, q = 0;
 +
 +    for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
 +        while (ctx->mb_width - x < mbs_per_slice)
 +            mbs_per_slice >>= 1;
 +        q = find_slice_quant(avctx, avctx->coded_frame,
 +                             (mb + 1) * TRELLIS_WIDTH, x, y,
 +                             mbs_per_slice, td);
 +    }
 +
 +    for (x = ctx->slices_width - 1; x >= 0; x--) {
 +        ctx->slice_q[x + y * ctx->slices_width] = td->nodes[q].quant;
 +        q = td->nodes[q].prev_node;
 +    }
 +
 +    return 0;
 +}
 +
 +static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
 +                        const AVFrame *pic, int *got_packet)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp;
 +    uint8_t *picture_size_pos;
 +    PutBitContext pb;
 +    int x, y, i, mb, q = 0;
 +    int sizes[4] = { 0 };
 +    int slice_hdr_size = 2 + 2 * (ctx->num_planes - 1);
 +    int frame_size, picture_size, slice_size;
 +    int pkt_size, ret;
 +    uint8_t frame_flags;
 +
 +    *avctx->coded_frame           = *pic;
 +    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 +    avctx->coded_frame->key_frame = 1;
 +
 +    pkt_size = ctx->frame_size_upper_bound + FF_MIN_BUFFER_SIZE;
 +
 +    if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size)) < 0)
 +        return ret;
 +
 +    orig_buf = pkt->data;
 +
 +    // frame atom
 +    orig_buf += 4;                              // frame size
 +    bytestream_put_be32  (&orig_buf, FRAME_ID); // frame container ID
 +    buf = orig_buf;
 +
 +    // frame header
 +    tmp = buf;
 +    buf += 2;                                   // frame header size will be stored here
 +    bytestream_put_be16  (&buf, 0);             // version 1
 +    bytestream_put_buffer(&buf, ctx->vendor, 4);
 +    bytestream_put_be16  (&buf, avctx->width);
 +    bytestream_put_be16  (&buf, avctx->height);
 +
 +    frame_flags = ctx->chroma_factor << 6;
 +    if (avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 +        frame_flags |= pic->top_field_first ? 0x04 : 0x08;
 +    bytestream_put_byte  (&buf, frame_flags);
 +
 +    bytestream_put_byte  (&buf, 0);             // reserved
 +    bytestream_put_byte  (&buf, avctx->color_primaries);
 +    bytestream_put_byte  (&buf, avctx->color_trc);
 +    bytestream_put_byte  (&buf, avctx->colorspace);
 +    bytestream_put_byte  (&buf, 0x40 | (ctx->alpha_bits >> 3));
 +    bytestream_put_byte  (&buf, 0);             // reserved
 +    if (ctx->quant_sel != QUANT_MAT_DEFAULT) {
 +        bytestream_put_byte  (&buf, 0x03);      // matrix flags - both matrices are present
 +        // luma quantisation matrix
 +        for (i = 0; i < 64; i++)
 +            bytestream_put_byte(&buf, ctx->quant_mat[i]);
 +        // chroma quantisation matrix
 +        for (i = 0; i < 64; i++)
 +            bytestream_put_byte(&buf, ctx->quant_mat[i]);
 +    } else {
 +        bytestream_put_byte  (&buf, 0x00);      // matrix flags - default matrices are used
 +    }
 +    bytestream_put_be16  (&tmp, buf - orig_buf); // write back frame header size
 +
 +    for (ctx->cur_picture_idx = 0;
 +         ctx->cur_picture_idx < ctx->pictures_per_frame;
 +         ctx->cur_picture_idx++) {
 +        // picture header
 +        picture_size_pos = buf + 1;
 +        bytestream_put_byte  (&buf, 0x40);          // picture header size (in bits)
 +        buf += 4;                                   // picture data size will be stored here
 +        bytestream_put_be16  (&buf, ctx->slices_per_picture);
 +        bytestream_put_byte  (&buf, av_log2(ctx->mbs_per_slice) << 4); // slice width and height in MBs
 +
 +        // seek table - will be filled during slice encoding
 +        slice_sizes = buf;
 +        buf += ctx->slices_per_picture * 2;
 +
 +        // slices
 +        if (!ctx->force_quant) {
 +            ret = avctx->execute2(avctx, find_quant_thread, NULL, NULL,
 +                                  ctx->mb_height);
 +            if (ret)
 +                return ret;
 +        }
 +
 +        for (y = 0; y < ctx->mb_height; y++) {
 +            int mbs_per_slice = ctx->mbs_per_slice;
 +            for (x = mb = 0; x < ctx->mb_width; x += mbs_per_slice, mb++) {
 +                q = ctx->force_quant ? ctx->force_quant
 +                                     : ctx->slice_q[mb + y * ctx->slices_width];
 +
 +                while (ctx->mb_width - x < mbs_per_slice)
 +                    mbs_per_slice >>= 1;
 +
 +                bytestream_put_byte(&buf, slice_hdr_size << 3);
 +                slice_hdr = buf;
 +                buf += slice_hdr_size - 1;
 +                init_put_bits(&pb, buf, (pkt_size - (buf - orig_buf)) * 8);
 +                encode_slice(avctx, pic, &pb, sizes, x, y, q, mbs_per_slice);
 +
 +                bytestream_put_byte(&slice_hdr, q);
 +                slice_size = slice_hdr_size + sizes[ctx->num_planes - 1];
 +                for (i = 0; i < ctx->num_planes - 1; i++) {
 +                    bytestream_put_be16(&slice_hdr, sizes[i]);
 +                    slice_size += sizes[i];
 +                }
 +                bytestream_put_be16(&slice_sizes, slice_size);
 +                buf += slice_size - slice_hdr_size;
 +            }
 +        }
 +
 +        picture_size = buf - (picture_size_pos - 1);
 +        bytestream_put_be32(&picture_size_pos, picture_size);
 +    }
 +
 +    orig_buf -= 8;
 +    frame_size = buf - orig_buf;
 +    bytestream_put_be32(&orig_buf, frame_size);
 +
 +    pkt->size   = frame_size;
 +    pkt->flags |= AV_PKT_FLAG_KEY;
 +    *got_packet = 1;
 +
 +    return 0;
 +}
 +
 +static av_cold int encode_close(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int i;
 +
 +    av_freep(&avctx->coded_frame);
 +
 +    if (ctx->tdata) {
 +        for (i = 0; i < avctx->thread_count; i++)
 +            av_free(ctx->tdata[i].nodes);
 +    }
 +    av_freep(&ctx->tdata);
 +    av_freep(&ctx->slice_q);
 +
 +    return 0;
 +}
 +
 +static av_cold int encode_init(AVCodecContext *avctx)
 +{
 +    ProresContext *ctx = avctx->priv_data;
 +    int mps;
 +    int i, j;
 +    int min_quant, max_quant;
 +    int interlaced = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
 +
 +    avctx->bits_per_raw_sample = 10;
 +    avctx->coded_frame = avcodec_alloc_frame();
 +    if (!avctx->coded_frame)
 +        return AVERROR(ENOMEM);
 +
 +    ff_proresdsp_init(&ctx->dsp, avctx);
 +    ff_init_scantable(ctx->dsp.dct_permutation, &ctx->scantable,
 +                      interlaced ? ff_prores_interlaced_scan
 +                                 : ff_prores_progressive_scan);
 +
 +    mps = ctx->mbs_per_slice;
 +    if (mps & (mps - 1)) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "there should be an integer power of two MBs per slice\n");
 +        return AVERROR(EINVAL);
 +    }
 +    if (av_pix_fmt_desc_get(avctx->pix_fmt)->flags & AV_PIX_FMT_FLAG_ALPHA) {
 +        if (ctx->alpha_bits & 7) {
 +            av_log(avctx, AV_LOG_ERROR, "alpha bits should be 0, 8 or 16\n");
 +            return AVERROR(EINVAL);
 +        }
 +    } else {
 +        ctx->alpha_bits = 0;
 +    }
 +
 +    ctx->chroma_factor = avctx->pix_fmt == AV_PIX_FMT_YUV422P10
 +                         ? CFACTOR_Y422
 +                         : CFACTOR_Y444;
 +    ctx->profile_info  = prores_profile_info + ctx->profile;
 +    ctx->num_planes    = 3 + !!ctx->alpha_bits;
 +
 +    ctx->mb_width      = FFALIGN(avctx->width,  16) >> 4;
 +
 +    if (interlaced)
 +        ctx->mb_height = FFALIGN(avctx->height, 32) >> 5;
 +    else
 +        ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
 +
 +    ctx->slices_width  = ctx->mb_width / mps;
 +    ctx->slices_width += av_popcount(ctx->mb_width - ctx->slices_width * mps);
 +    ctx->slices_per_picture = ctx->mb_height * ctx->slices_width;
 +    ctx->pictures_per_frame = 1 + interlaced;
 +
 +    if (ctx->quant_sel == -1)
 +        ctx->quant_mat = prores_quant_matrices[ctx->profile_info->quant];
 +    else
 +        ctx->quant_mat = prores_quant_matrices[ctx->quant_sel];
 +
 +    if (strlen(ctx->vendor) != 4) {
 +        av_log(avctx, AV_LOG_ERROR, "vendor ID should be 4 bytes\n");
 +        return AVERROR_INVALIDDATA;
 +    }
 +
 +    ctx->force_quant = avctx->global_quality / FF_QP2LAMBDA;
 +    if (!ctx->force_quant) {
 +        if (!ctx->bits_per_mb) {
 +            for (i = 0; i < NUM_MB_LIMITS - 1; i++)
 +                if (prores_mb_limits[i] >= ctx->mb_width * ctx->mb_height *
 +                                           ctx->pictures_per_frame)
 +                    break;
 +            ctx->bits_per_mb   = ctx->profile_info->br_tab[i];
 +        } else if (ctx->bits_per_mb < 128) {
 +            av_log(avctx, AV_LOG_ERROR, "too few bits per MB, please set at least 128\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        min_quant = ctx->profile_info->min_quant;
 +        max_quant = ctx->profile_info->max_quant;
 +        for (i = min_quant; i < MAX_STORED_Q; i++) {
 +            for (j = 0; j < 64; j++)
 +                ctx->quants[i][j] = ctx->quant_mat[j] * i;
 +        }
 +
 +        ctx->slice_q = av_malloc(ctx->slices_per_picture * sizeof(*ctx->slice_q));
 +        if (!ctx->slice_q) {
 +            encode_close(avctx);
 +            return AVERROR(ENOMEM);
 +        }
 +
 +        ctx->tdata = av_mallocz(avctx->thread_count * sizeof(*ctx->tdata));
 +        if (!ctx->tdata) {
 +            encode_close(avctx);
 +            return AVERROR(ENOMEM);
 +        }
 +
 +        for (j = 0; j < avctx->thread_count; j++) {
 +            ctx->tdata[j].nodes = av_malloc((ctx->slices_width + 1)
 +                                            * TRELLIS_WIDTH
 +                                            * sizeof(*ctx->tdata->nodes));
 +            if (!ctx->tdata[j].nodes) {
 +                encode_close(avctx);
 +                return AVERROR(ENOMEM);
 +            }
 +            for (i = min_quant; i < max_quant + 2; i++) {
 +                ctx->tdata[j].nodes[i].prev_node = -1;
 +                ctx->tdata[j].nodes[i].bits      = 0;
 +                ctx->tdata[j].nodes[i].score     = 0;
 +            }
 +        }
 +    } else {
 +        int ls = 0;
 +
 +        if (ctx->force_quant > 64) {
 +            av_log(avctx, AV_LOG_ERROR, "too large quantiser, maximum is 64\n");
 +            return AVERROR_INVALIDDATA;
 +        }
 +
 +        for (j = 0; j < 64; j++) {
 +            ctx->quants[0][j] = ctx->quant_mat[j] * ctx->force_quant;
 +            ls += av_log2((1 << 11)  / ctx->quants[0][j]) * 2 + 1;
 +        }
 +
 +        ctx->bits_per_mb = ls * 8;
 +        if (ctx->chroma_factor == CFACTOR_Y444)
 +            ctx->bits_per_mb += ls * 4;
 +        if (ctx->num_planes == 4)
 +            ctx->bits_per_mb += ls * 4;
 +    }
 +
 +    ctx->frame_size_upper_bound = ctx->pictures_per_frame *
 +                                  ctx->slices_per_picture *
 +                                  (2 + 2 * ctx->num_planes +
 +                                   (mps * ctx->bits_per_mb) / 8)
 +                                  + 200;
 +
 +    avctx->codec_tag   = ctx->profile_info->tag;
 +
 +    av_log(avctx, AV_LOG_DEBUG,
 +           "profile %d, %d slices, interlacing: %s, %d bits per MB\n",
 +           ctx->profile, ctx->slices_per_picture * ctx->pictures_per_frame,
 +           interlaced ? "yes" : "no", ctx->bits_per_mb);
 +    av_log(avctx, AV_LOG_DEBUG, "frame size upper bound: %d\n",
 +           ctx->frame_size_upper_bound);
 +
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(ProresContext, x)
 +#define VE     AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +
 +static const AVOption options[] = {
 +    { "mbs_per_slice", "macroblocks per slice", OFFSET(mbs_per_slice),
 +        AV_OPT_TYPE_INT, { .i64 = 8 }, 1, MAX_MBS_PER_SLICE, VE },
 +    { "profile",       NULL, OFFSET(profile), AV_OPT_TYPE_INT,
 +        { .i64 = PRORES_PROFILE_STANDARD },
 +        PRORES_PROFILE_PROXY, PRORES_PROFILE_4444, VE, "profile" },
 +    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_PROXY },
 +        0, 0, VE, "profile" },
 +    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_LT },
 +        0, 0, VE, "profile" },
 +    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_STANDARD },
 +        0, 0, VE, "profile" },
 +    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_HQ },
 +        0, 0, VE, "profile" },
 +    { "4444",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PRORES_PROFILE_4444 },
 +        0, 0, VE, "profile" },
 +    { "vendor", "vendor ID", OFFSET(vendor),
 +        AV_OPT_TYPE_STRING, { .str = "Lavc" }, CHAR_MIN, CHAR_MAX, VE },
 +    { "bits_per_mb", "desired bits per macroblock", OFFSET(bits_per_mb),
 +        AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 8192, VE },
 +    { "quant_mat", "quantiser matrix", OFFSET(quant_sel), AV_OPT_TYPE_INT,
 +        { .i64 = -1 }, -1, QUANT_MAT_DEFAULT, VE, "quant_mat" },
 +    { "auto",          NULL, 0, AV_OPT_TYPE_CONST, { .i64 = -1 },
 +        0, 0, VE, "quant_mat" },
 +    { "proxy",         NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_PROXY },
 +        0, 0, VE, "quant_mat" },
 +    { "lt",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_LT },
 +        0, 0, VE, "quant_mat" },
 +    { "standard",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_STANDARD },
 +        0, 0, VE, "quant_mat" },
 +    { "hq",            NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_HQ },
 +        0, 0, VE, "quant_mat" },
 +    { "default",       NULL, 0, AV_OPT_TYPE_CONST, { .i64 = QUANT_MAT_DEFAULT },
 +        0, 0, VE, "quant_mat" },
 +    { "alpha_bits", "bits for alpha plane", OFFSET(alpha_bits), AV_OPT_TYPE_INT,
 +        { .i64 = 16 }, 0, 16, VE },
 +    { NULL }
 +};
 +
 +static const AVClass proresenc_class = {
 +    .class_name = "ProRes encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_prores_ks_encoder = {
 +    .name           = "prores_ks",
++    .long_name      = NULL_IF_CONFIG_SMALL("Apple ProRes (iCodec Pro)"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_PRORES,
 +    .priv_data_size = sizeof(ProresContext),
 +    .init           = encode_init,
 +    .close          = encode_close,
 +    .encode2        = encode_frame,
 +    .capabilities   = CODEC_CAP_SLICE_THREADS,
 +    .pix_fmts       = (const enum AVPixelFormat[]) {
 +                          AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,
 +                          AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_NONE
 +                      },
 +    .priv_class     = &proresenc_class,
 +};
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -346,7 -323,5 +347,6 @@@ AVCodec ff_qpeg_decoder = 
      .init           = decode_init,
      .close          = decode_end,
      .decode         = decode_frame,
 +    .flush          = decode_flush,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("Q-team QPEG"),
  };
Simple merge
@@@ -396,7 -337,6 +397,6 @@@ AVCodec ff_qtrle_encoder = 
      .encode2        = qtrle_encode_frame,
      .close          = qtrle_encode_end,
      .pix_fmts       = (const enum AVPixelFormat[]){
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB, AV_PIX_FMT_NONE
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB555BE, AV_PIX_FMT_ARGB, AV_PIX_FMT_GRAY8, AV_PIX_FMT_NONE
      },
-     .long_name      = NULL_IF_CONFIG_SMALL("QuickTime Animation (RLE) video"),
  };
@@@ -106,17 -101,5 +107,16 @@@ AVCodec ff_r10k_decoder = 
      .init           = decode_init,
      .decode         = decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("AJA Kona 10-bit RGB Codec"),
  };
  #endif
 +#if CONFIG_AVRP_DECODER
 +AVCodec ff_avrp_decoder = {
 +    .name           = "avrp",
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_AVRP,
 +    .init           = decode_init,
 +    .decode         = decode_frame,
 +    .capabilities   = CODEC_CAP_DR1,
 +    .long_name = NULL_IF_CONFIG_SMALL("Avid 1:1 10-bit RGB Packer"),
 +};
 +#endif
Simple merge
@@@ -553,7 -555,4 +554,6 @@@ AVCodec ff_ra_144_encoder = 
      .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_SMALL_LAST_FRAME,
      .sample_fmts    = (const enum AVSampleFormat[]){ AV_SAMPLE_FMT_S16,
                                                       AV_SAMPLE_FMT_NONE },
-     .long_name      = NULL_IF_CONFIG_SMALL("RealAudio 1.0 (14.4K)"),
 +    .supported_samplerates = (const int[]){ 8000, 0 },
 +    .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO, 0 },
  };
Simple merge
Simple merge
@@@ -355,6 -261,4 +356,5 @@@ AVCodec ff_rawvideo_decoder = 
      .init           = raw_init_decoder,
      .close          = raw_close_decoder,
      .decode         = raw_decode,
-     .long_name      = NULL_IF_CONFIG_SMALL("raw video"),
 +    .priv_class     = &rawdec_class,
  };
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -764,8 -743,6 +765,7 @@@ AVCodec ff_rv10_decoder = 
      .close          = rv10_decode_end,
      .decode         = rv10_decode_frame,
      .capabilities   = CODEC_CAP_DR1,
-     .long_name      = NULL_IF_CONFIG_SMALL("RealVideo 1.0"),
 +    .max_lowres     = 3,
      .pix_fmts       = ff_pixfmt_list_420,
  };
  
@@@ -779,7