Merge commit '124134e42455763b28cc346fed1d07017a76e84e'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 5 Sep 2012 11:58:11 +0000 (13:58 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 5 Sep 2012 11:58:11 +0000 (13:58 +0200)
* commit '124134e42455763b28cc346fed1d07017a76e84e':
  avopt: Store defaults for AV_OPT_TYPE_CONST in the i64 union member

Conflicts:
libavcodec/aacenc.c
libavcodec/libopenjpegenc.c
libavcodec/options_table.h
libavdevice/bktr.c
libavdevice/v4l2.c
libavdevice/x11grab.c
libavfilter/af_amix.c
libavfilter/vf_drawtext.c
libavformat/movenc.c
libavformat/options_table.h
libavutil/opt.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
40 files changed:
1  2 
libavcodec/aacenc.c
libavcodec/apedec.c
libavcodec/flacenc.c
libavcodec/libfdk-aacenc.c
libavcodec/libopenjpegenc.c
libavcodec/libtwolame.c
libavcodec/libvpxenc.c
libavcodec/libx264.c
libavcodec/libxavs.c
libavcodec/mpegvideo.h
libavcodec/options_table.h
libavcodec/proresenc_kostya.c
libavcodec/tiffenc.c
libavdevice/bktr.c
libavdevice/caca.c
libavdevice/dshow.c
libavdevice/dv1394.c
libavdevice/iec61883.c
libavdevice/libcdio.c
libavdevice/openal-dec.c
libavdevice/v4l.c
libavdevice/v4l2.c
libavdevice/x11grab.c
libavfilter/af_amix.c
libavfilter/vf_drawtext.c
libavfilter/vsrc_mandelbrot.c
libavfilter/vsrc_mptestsrc.c
libavformat/img2dec.c
libavformat/movenc.c
libavformat/mpegtsenc.c
libavformat/options_table.h
libavformat/rtmpproto.c
libavformat/rtpenc.h
libavformat/rtsp.c
libavformat/segment.c
libavformat/spdifenc.c
libavutil/cpu.c
libavutil/opt.c
libswresample/swresample.c
libswscale/options.c

@@@ -802,10 -803,9 +802,10 @@@ fail
  #define AACENC_FLAGS AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_AUDIO_PARAM
  static const AVOption aacenc_options[] = {
      {"stereo_mode", "Stereo coding method", offsetof(AACEncContext, options.stereo_mode), AV_OPT_TYPE_INT, {.dbl = 0}, -1, 1, AACENC_FLAGS, "stereo_mode"},
-         {"auto",     "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.dbl = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
-         {"ms_off",   "Disable Mid/Side coding", 0, AV_OPT_TYPE_CONST, {.dbl =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
-         {"ms_force", "Force Mid/Side for the whole frame if possible", 0, AV_OPT_TYPE_CONST, {.dbl =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+         {"auto",     "Selected by the Encoder", 0, AV_OPT_TYPE_CONST, {.i64 = -1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+         {"ms_off",   "Disable Mid/Side coding", 0, AV_OPT_TYPE_CONST, {.i64 =  0 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
+         {"ms_force", "Force Mid/Side for the whole frame if possible", 0, AV_OPT_TYPE_CONST, {.i64 =  1 }, INT_MIN, INT_MAX, AACENC_FLAGS, "stereo_mode"},
 +    {"aac_coder", "", offsetof(AACEncContext, options.aac_coder), AV_OPT_TYPE_INT, {.dbl = 2}, 0, AAC_CODER_NB-1, AACENC_FLAGS},
      {NULL}
  };
  
Simple merge
Simple merge
Simple merge
@@@ -438,28 -380,28 +438,28 @@@ static av_cold int libopenjpeg_encode_c
  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  static const AVOption options[] = {
      { "format",        "Codec Format",      OFFSET(format),        AV_OPT_TYPE_INT,   { CODEC_JP2   }, CODEC_J2K, CODEC_JP2,   VE, "format"      },
-     { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { CODEC_J2K   }, 0,         0,           VE, "format"      },
-     { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { CODEC_JP2   }, 0,         0,           VE, "format"      },
+     { "j2k",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_J2K   }, 0,         0,           VE, "format"      },
+     { "jp2",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CODEC_JP2   }, 0,         0,           VE, "format"      },
      { "profile",       NULL,                OFFSET(profile),       AV_OPT_TYPE_INT,   { STD_RSIZ    }, STD_RSIZ,  CINEMA4K,    VE, "profile"     },
-     { "jpeg2000",      NULL,                0,                     AV_OPT_TYPE_CONST, { STD_RSIZ    }, 0,         0,           VE, "profile"     },
-     { "cinema2k",      NULL,                0,                     AV_OPT_TYPE_CONST, { CINEMA2K    }, 0,         0,           VE, "profile"     },
-     { "cinema4k",      NULL,                0,                     AV_OPT_TYPE_CONST, { CINEMA4K    }, 0,         0,           VE, "profile"     },
+     { "jpeg2000",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = STD_RSIZ    }, 0,         0,           VE, "profile"     },
+     { "cinema2k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K    }, 0,         0,           VE, "profile"     },
+     { "cinema4k",      NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K    }, 0,         0,           VE, "profile"     },
      { "cinema_mode",   "Digital Cinema",    OFFSET(cinema_mode),   AV_OPT_TYPE_INT,   { OFF         }, OFF,       CINEMA4K_24, VE, "cinema_mode" },
-     { "off",           NULL,                0,                     AV_OPT_TYPE_CONST, { OFF         }, 0,         0,           VE, "cinema_mode" },
-     { "2k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { CINEMA2K_24 }, 0,         0,           VE, "cinema_mode" },
-     { "2k_48",         NULL,                0,                     AV_OPT_TYPE_CONST, { CINEMA2K_48 }, 0,         0,           VE, "cinema_mode" },
-     { "4k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { CINEMA4K_24 }, 0,         0,           VE, "cinema_mode" },
+     { "off",           NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = OFF         }, 0,         0,           VE, "cinema_mode" },
+     { "2k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_24 }, 0,         0,           VE, "cinema_mode" },
+     { "2k_48",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA2K_48 }, 0,         0,           VE, "cinema_mode" },
+     { "4k_24",         NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CINEMA4K_24 }, 0,         0,           VE, "cinema_mode" },
      { "prog_order",    "Progression Order", OFFSET(prog_order),    AV_OPT_TYPE_INT,   { LRCP        }, LRCP,      CPRL,        VE, "prog_order"  },
-     { "lrcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { LRCP        }, 0,         0,           VE, "prog_order"  },
-     { "rlcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { RLCP        }, 0,         0,           VE, "prog_order"  },
-     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { RPCL        }, 0,         0,           VE, "prog_order"  },
-     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { PCRL        }, 0,         0,           VE, "prog_order"  },
-     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { CPRL        }, 0,         0,           VE, "prog_order"  },
+     { "lrcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = LRCP        }, 0,         0,           VE, "prog_order"  },
+     { "rlcp",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RLCP        }, 0,         0,           VE, "prog_order"  },
+     { "rpcl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = RPCL        }, 0,         0,           VE, "prog_order"  },
+     { "pcrl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = PCRL        }, 0,         0,           VE, "prog_order"  },
+     { "cprl",          NULL,                0,                     AV_OPT_TYPE_CONST, { .i64 = CPRL        }, 0,         0,           VE, "prog_order"  },
 -    { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { 6           }, 1,         10,          VE },
 -    { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { 1           }, 1,         10,          VE },
 -    { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { 1           }, 0,         1,           VE },
 -    { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { 0           }, 0,         1,           VE },
 -    { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { 0           }, 0,         1,           VE },
 +    { "numresolution", NULL,                OFFSET(numresolution), AV_OPT_TYPE_INT,   { 6           }, 1,         INT_MAX,     VE                },
 +    { "numlayers",     NULL,                OFFSET(numlayers),     AV_OPT_TYPE_INT,   { 1           }, 1,         10,          VE                },
 +    { "disto_alloc",   NULL,                OFFSET(disto_alloc),   AV_OPT_TYPE_INT,   { 1           }, 0,         1,           VE                },
 +    { "fixed_alloc",   NULL,                OFFSET(fixed_alloc),   AV_OPT_TYPE_INT,   { 0           }, 0,         1,           VE                },
 +    { "fixed_quality", NULL,                OFFSET(fixed_quality), AV_OPT_TYPE_INT,   { 0           }, 0,         1,           VE                },
      { NULL },
  };
  
index 4eb6bdb,0000000..dce7dce
mode 100644,000000..100644
--- /dev/null
@@@ -1,196 -1,0 +1,196 @@@
-     { "auto",         NULL,         0, AV_OPT_TYPE_CONST, { TWOLAME_AUTO_MODE },          0, 0, AE, "mode" },
-     { "stereo",       NULL,         0, AV_OPT_TYPE_CONST, { TWOLAME_STEREO },             0, 0, AE, "mode" },
-     { "joint_stereo", NULL,         0, AV_OPT_TYPE_CONST, { TWOLAME_JOINT_STEREO },       0, 0, AE, "mode" },
-     { "dual_channel", NULL,         0, AV_OPT_TYPE_CONST, { TWOLAME_DUAL_CHANNEL },       0, 0, AE, "mode" },
-     { "mono",         NULL,         0, AV_OPT_TYPE_CONST, { TWOLAME_MONO },               0, 0, AE, "mode" },
 +/*
 + * Interface to libtwolame for mp2 encoding
 + * Copyright (c) 2012 Paul B Mahol
 + *
 + * 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
 + * Interface to libtwolame for mp2 encoding.
 + */
 +
 +#include <twolame.h>
 +
 +#include "libavutil/opt.h"
 +#include "avcodec.h"
 +#include "internal.h"
 +#include "mpegaudio.h"
 +
 +typedef struct TWOLAMEContext {
 +    AVClass  *class;
 +    int      mode;
 +    int      psymodel;
 +    int      energy;
 +    int      error_protection;
 +    int      copyright;
 +    int      original;
 +
 +    twolame_options *glopts;
 +    int64_t  next_pts;
 +} TWOLAMEContext;
 +
 +static av_cold int twolame_encode_close(AVCodecContext *avctx)
 +{
 +    TWOLAMEContext *s = avctx->priv_data;
 +    twolame_close(&s->glopts);
 +    return 0;
 +}
 +
 +static av_cold int twolame_encode_init(AVCodecContext *avctx)
 +{
 +    TWOLAMEContext *s = avctx->priv_data;
 +    int ret;
 +
 +    avctx->frame_size = TWOLAME_SAMPLES_PER_FRAME;
 +
 +    s->glopts = twolame_init();
 +    if (!s->glopts)
 +        return AVERROR(ENOMEM);
 +
 +    twolame_set_verbosity(s->glopts, 0);
 +    twolame_set_mode(s->glopts, s->mode);
 +    twolame_set_psymodel(s->glopts, s->psymodel);
 +    twolame_set_energy_levels(s->glopts, s->energy);
 +    twolame_set_error_protection(s->glopts, s->error_protection);
 +
 +    twolame_set_num_channels(s->glopts, avctx->channels);
 +    twolame_set_in_samplerate(s->glopts, avctx->sample_rate);
 +    twolame_set_out_samplerate(s->glopts, avctx->sample_rate);
 +    if (avctx->flags & CODEC_FLAG_QSCALE || !avctx->bit_rate) {
 +        twolame_set_VBR(s->glopts, TRUE);
 +        twolame_set_VBR_level(s->glopts, avctx->global_quality);
 +        av_log(avctx, AV_LOG_WARNING, "VBR mode is experimental!\n");
 +    } else {
 +        twolame_set_bitrate(s->glopts, avctx->bit_rate / 1000);
 +    }
 +
 +    if ((ret = twolame_init_params(s->glopts)))
 +        goto error;
 +
 +    return 0;
 +error:
 +    twolame_encode_close(avctx);
 +    return ret;
 +}
 +
 +static int twolame_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
 +                                const AVFrame *frame, int *got_packet_ptr)
 +{
 +    TWOLAMEContext *s = avctx->priv_data;
 +    int ret;
 +
 +    if ((ret = ff_alloc_packet2(avctx, avpkt, MPA_MAX_CODED_FRAME_SIZE)))
 +        return ret;
 +
 +    if (frame) {
 +        switch (avctx->sample_fmt) {
 +        case AV_SAMPLE_FMT_FLT:
 +            ret = twolame_encode_buffer_float32_interleaved(s->glopts,
 +                                        frame->data[0],
 +                                        frame->nb_samples,
 +                                        avpkt->data, avpkt->size);
 +            break;
 +        case AV_SAMPLE_FMT_FLTP:
 +            ret = twolame_encode_buffer_float32(s->glopts,
 +                                        frame->data[0], frame->data[1],
 +                                        frame->nb_samples,
 +                                        avpkt->data, avpkt->size);
 +            break;
 +        case AV_SAMPLE_FMT_S16:
 +            ret = twolame_encode_buffer_interleaved(s->glopts,
 +                                        frame->data[0],
 +                                        frame->nb_samples,
 +                                        avpkt->data, avpkt->size);
 +            break;
 +        case AV_SAMPLE_FMT_S16P:
 +            ret = twolame_encode_buffer(s->glopts,
 +                                        frame->data[0], frame->data[1],
 +                                        frame->nb_samples,
 +                                        avpkt->data, avpkt->size);
 +            break;
 +        default:
 +            return AVERROR_BUG;
 +        }
 +    } else {
 +        ret = twolame_encode_flush(s->glopts, avpkt->data, avpkt->size);
 +    }
 +
 +    if (ret > 0) {
 +        avpkt->duration = ff_samples_to_time_base(avctx, avctx->frame_size);
 +        if (frame) {
 +            if (frame->pts != AV_NOPTS_VALUE)
 +                avpkt->pts  = frame->pts;
 +        } else {
 +            avpkt->pts = s->next_pts;
 +        }
 +        if (avpkt->pts != AV_NOPTS_VALUE)
 +            s->next_pts = avpkt->pts + avpkt->duration;
 +
 +        avpkt->size     = ret;
 +        *got_packet_ptr = 1;
 +        return 0;
 +    }
 +
 +    return ret;
 +}
 +
 +#define OFFSET(x) offsetof(TWOLAMEContext, x)
 +#define AE AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 +static const AVOption options[] = {
 +    { "mode",         "Mpeg Mode", OFFSET(mode), AV_OPT_TYPE_INT, { TWOLAME_AUTO_MODE }, TWOLAME_AUTO_MODE, TWOLAME_MONO, AE, "mode"},
++    { "auto",         NULL,         0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_AUTO_MODE },          0, 0, AE, "mode" },
++    { "stereo",       NULL,         0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_STEREO },             0, 0, AE, "mode" },
++    { "joint_stereo", NULL,         0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_JOINT_STEREO },       0, 0, AE, "mode" },
++    { "dual_channel", NULL,         0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_DUAL_CHANNEL },       0, 0, AE, "mode" },
++    { "mono",         NULL,         0, AV_OPT_TYPE_CONST, { .i64 = TWOLAME_MONO },               0, 0, AE, "mode" },
 +    { "psymodel",    "Psychoacoustic Model",  OFFSET(psymodel), AV_OPT_TYPE_INT, { 3 }, -1, 4, AE},
 +    { "energy_levels","enable energy levels", OFFSET(energy),   AV_OPT_TYPE_INT, { 0 },  0, 1, AE},
 +    { "error_protection","enable CRC error protection", OFFSET(error_protection), AV_OPT_TYPE_INT, { 0 },  0, 1, AE},
 +    { "copyright",    "set MPEG Audio Copyright flag",  OFFSET(copyright), AV_OPT_TYPE_INT, { 0 },  0, 1, AE},
 +    { "original",     "set MPEG Audio Original flag",   OFFSET(original),  AV_OPT_TYPE_INT, { 0 },  0, 1, AE},
 +    { NULL },
 +};
 +
 +static const AVClass libtwolame_class = {
 +    .class_name = "libtwolame encoder",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVCodec ff_libtwolame_encoder = {
 +    .name                  = "libtwolame",
 +    .type                  = AVMEDIA_TYPE_AUDIO,
 +    .id                    = AV_CODEC_ID_MP2,
 +    .priv_data_size        = sizeof(TWOLAMEContext),
 +    .init                  = twolame_encode_init,
 +    .encode2               = twolame_encode_frame,
 +    .close                 = twolame_encode_close,
 +    .capabilities          = CODEC_CAP_DELAY,
 +    .sample_fmts           = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLT,
 +                                                             AV_SAMPLE_FMT_FLTP,
 +                                                             AV_SAMPLE_FMT_S16,
 +                                                             AV_SAMPLE_FMT_S16P,
 +                                                             AV_SAMPLE_FMT_NONE },
 +    .channel_layouts       = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
 +                                                  AV_CH_LAYOUT_STEREO,
 +                                                  0 },
 +    .supported_samplerates = (const int[]){ 16000, 22050, 24000, 32000, 44100, 48000, 0 },
 +    .long_name             = NULL_IF_CONFIG_SMALL("libtwolame MP2 (MPEG audio layer 2)"),
 +    .priv_class            = &libtwolame_class,
 +};
@@@ -577,33 -538,22 +577,33 @@@ static const AVOption options[] = 
      { "arnr-maxframes",  "altref noise reduction max frame count", OFFSET(arnr_max_frames), AV_OPT_TYPE_INT, {-1},      -1,      INT_MAX, VE},
      { "arnr-strength",   "altref noise reduction filter strength", OFFSET(arnr_strength),   AV_OPT_TYPE_INT, {-1},      -1,      INT_MAX, VE},
      { "arnr-type",       "altref noise reduction filter type",     OFFSET(arnr_type),       AV_OPT_TYPE_INT, {-1},      -1,      INT_MAX, VE, "arnr_type"},
-     { "backward",        NULL, 0, AV_OPT_TYPE_CONST, {1}, 0, 0, VE, "arnr_type" },
-     { "forward",         NULL, 0, AV_OPT_TYPE_CONST, {2}, 0, 0, VE, "arnr_type" },
-     { "centered",        NULL, 0, AV_OPT_TYPE_CONST, {3}, 0, 0, VE, "arnr_type" },
+     { "backward",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, VE, "arnr_type" },
+     { "forward",         NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 2}, 0, 0, VE, "arnr_type" },
+     { "centered",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 3}, 0, 0, VE, "arnr_type" },
      { "deadline",        "Time to spend encoding, in microseconds.", OFFSET(deadline),      AV_OPT_TYPE_INT, {VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"},
-     { "best",            NULL, 0, AV_OPT_TYPE_CONST, {VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"},
-     { "good",            NULL, 0, AV_OPT_TYPE_CONST, {VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"},
-     { "realtime",        NULL, 0, AV_OPT_TYPE_CONST, {VPX_DL_REALTIME},     0, 0, VE, "quality"},
+     { "best",            NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_BEST_QUALITY}, 0, 0, VE, "quality"},
+     { "good",            NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_GOOD_QUALITY}, 0, 0, VE, "quality"},
+     { "realtime",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = VPX_DL_REALTIME},     0, 0, VE, "quality"},
      { "error-resilient", "Error resilience configuration", OFFSET(error_resilient), AV_OPT_TYPE_FLAGS, {0}, INT_MIN, INT_MAX, VE, "er"},
 +    { "max-intra-rate",  "Maximum I-frame bitrate (pct) 0=unlimited",  OFFSET(max_intra_rate),  AV_OPT_TYPE_INT,  {-1}, -1,      INT_MAX, VE},
  #ifdef VPX_ERROR_RESILIENT_DEFAULT
-     { "default",         "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
+     { "default",         "Improve resiliency against losses of whole frames", 0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_DEFAULT}, 0, 0, VE, "er"},
      { "partitions",      "The frame partitions are independently decodable "
                           "by the bool decoder, meaning that partitions can be decoded even "
                           "though earlier partitions have been lost. Note that intra predicition"
-                          " is still done over the partition boundary.",       0, AV_OPT_TYPE_CONST, {VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"},
+                          " is still done over the partition boundary.",       0, AV_OPT_TYPE_CONST, {.i64 = VPX_ERROR_RESILIENT_PARTITIONS}, 0, 0, VE, "er"},
  #endif
 -    { NULL }
 +{"speed", "", offsetof(VP8Context, cpu_used), AV_OPT_TYPE_INT, {.dbl = 3}, -16, 16, VE},
 +{"quality", "", offsetof(VP8Context, deadline), AV_OPT_TYPE_INT, {.dbl = VPX_DL_GOOD_QUALITY}, INT_MIN, INT_MAX, VE, "quality"},
 +{"vp8flags", "", offsetof(VP8Context, flags), FF_OPT_TYPE_FLAGS, {.dbl = 0}, 0, UINT_MAX, VE, "flags"},
 +{"error_resilient", "enable error resilience", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_ERROR_RESILIENT}, INT_MIN, INT_MAX, VE, "flags"},
 +{"altref", "enable use of alternate reference frames (VP8/2-pass only)", 0, FF_OPT_TYPE_CONST, {.dbl = VP8F_AUTO_ALT_REF}, INT_MIN, INT_MAX, VE, "flags"},
 +{"arnr_max_frames", "altref noise reduction max frame count", offsetof(VP8Context, arnr_max_frames), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 15, VE},
 +{"arnr_strength", "altref noise reduction filter strength", offsetof(VP8Context, arnr_strength), AV_OPT_TYPE_INT, {.dbl = 3}, 0, 6, VE},
 +{"arnr_type", "altref noise reduction filter type", offsetof(VP8Context, arnr_type), AV_OPT_TYPE_INT, {.dbl = 3}, 1, 3, VE},
 +{"rc_lookahead", "Number of frames to look ahead for alternate reference frame selection", offsetof(VP8Context, lag_in_frames), AV_OPT_TYPE_INT, {.dbl = 25}, 0, 25, VE},
 +{"crf", "Select the quality for constant quality mode", offsetof(VP8Context, crf), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 63, VE},
 +{NULL}
  };
  
  static const AVClass class = {
Simple merge
Simple merge
Simple merge
@@@ -47,40 -44,38 +47,40 @@@ static const AVOption options[]=
         "ratecontrol is willing to deviate from the target average bitrate value. This is not related "
         "to min/max bitrate. Lowering tolerance too much has an adverse effect on quality.",
         OFFSET(bit_rate_tolerance), AV_OPT_TYPE_INT, {.dbl = AV_CODEC_DEFAULT_BITRATE*20 }, 1, INT_MAX, V|E},
 -{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, UINT_MAX, V|A|E|D, "flags"},
 +{"flags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, UINT_MAX, V|A|S|E|D, "flags"},
- {"mv4", "use four motion vector by macroblock (mpeg4)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V|E, "flags"},
- {"qpel", "use 1/4 pel motion compensation", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V|E, "flags"},
- {"loop", "use loop filter", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V|E, "flags"},
- {"qscale", "use fixed qscale", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QSCALE }, INT_MIN, INT_MAX, 0, "flags"},
- {"gmc", "use gmc", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GMC }, INT_MIN, INT_MAX, V|E, "flags"},
- {"mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_MV0 }, INT_MIN, INT_MAX, V|E, "flags"},
- {"input_preserved", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INPUT_PRESERVED }, INT_MIN, INT_MAX, 0, "flags"},
- {"pass1", "use internal 2pass ratecontrol in first  pass mode", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PASS1 }, INT_MIN, INT_MAX, 0, "flags"},
- {"pass2", "use internal 2pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
- {"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},
- {"emu_edge", "don't draw edges", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_EMU_EDGE }, INT_MIN, INT_MAX, 0, "flags"},
- {"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"},
- {"truncated", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, 0, "flags"},
- {"naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_NORMALIZE_AQP }, INT_MIN, INT_MAX, V|E, "flags"},
- {"ildct", "use interlaced dct", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"},
- {"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"},
- {"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},
- {"bitexact", "use only bitexact stuff (except (i)dct)", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A|V|S|D|E, "flags"},
- {"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"mv4", "use four motion vector by macroblock (mpeg4)", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_4MV }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"qpel", "use 1/4 pel motion compensation", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QPEL }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"loop", "use loop filter", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_LOOP_FILTER }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"qscale", "use fixed qscale", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QSCALE }, INT_MIN, INT_MAX, 0, "flags"},
+ {"gmc", "use gmc", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GMC }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"mv0", "always try a mb with mv=<0,0>", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_MV0 }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"input_preserved", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INPUT_PRESERVED }, INT_MIN, INT_MAX, 0, "flags"},
+ {"pass1", "use internal 2pass ratecontrol in first  pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PASS1 }, INT_MIN, INT_MAX, 0, "flags"},
+ {"pass2", "use internal 2pass ratecontrol in second pass mode", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PASS2 }, INT_MIN, INT_MAX, 0, "flags"},
+ {"gray", "only decode/encode grayscale", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GRAY }, INT_MIN, INT_MAX, V|E|D, "flags"},
+ {"emu_edge", "don't draw edges", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_EMU_EDGE }, INT_MIN, INT_MAX, 0, "flags"},
+ {"psnr", "error[?] variables will be set during encoding", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_PSNR }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"truncated", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_TRUNCATED }, INT_MIN, INT_MAX, 0, "flags"},
+ {"naq", "normalize adaptive quantization", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_NORMALIZE_AQP }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"ildct", "use interlaced dct", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INTERLACED_DCT }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"low_delay", "force low delay", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_LOW_DELAY }, INT_MIN, INT_MAX, V|D|E, "flags"},
+ {"global_header", "place global headers in extradata instead of every keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_GLOBAL_HEADER }, INT_MIN, INT_MAX, V|A|E, "flags"},
+ {"bitexact", "use only bitexact stuff (except (i)dct)", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_BITEXACT }, INT_MIN, INT_MAX, A|V|S|D|E, "flags"},
+ {"aic", "h263 advanced intra coding / mpeg4 ac prediction", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_AC_PRED }, INT_MIN, INT_MAX, V|E, "flags"},
  #if FF_API_MPV_GLOBAL_OPTS
- {"cbp", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
- {"qprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"cbp", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_CBP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"qprd", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_QP_RD }, INT_MIN, INT_MAX, V|E, "flags"},
  #endif
- {"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},
- {"cgop", "closed gop", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},
- {"fast", "allow non spec compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},
+ {"ilme", "interlaced motion estimation", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_INTERLACED_ME }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"cgop", "closed gop", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG_CLOSED_GOP }, INT_MIN, INT_MAX, V|E, "flags"},
+ {"fast", "allow non spec compliant speedup tricks", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_FAST }, INT_MIN, INT_MAX, V|E, "flags2"},
  #if FF_API_MPV_GLOBAL_OPTS
- {"sgop", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_STRICT_GOP }, INT_MIN, INT_MAX, V|E, "flags2"},
+ {"sgop", "Deprecated, use mpegvideo private options instead", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_STRICT_GOP }, INT_MIN, INT_MAX, V|E, "flags2"},
  #endif
- {"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
- {"chunks", "Frame data might be split into multiple chunks", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_CHUNKS }, INT_MIN, INT_MAX, V|D, "flags2"},
- {"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.dbl = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
+ {"noout", "skip bitstream encoding", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_NO_OUTPUT }, INT_MIN, INT_MAX, V|E, "flags2"},
+ {"local_header", "place global headers at every keyframe instead of in extradata", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_LOCAL_HEADER }, INT_MIN, INT_MAX, V|E, "flags2"},
++{"chunks", "Frame data might be split into multiple chunks", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_CHUNKS }, INT_MIN, INT_MAX, V|D, "flags2"},
++{"showall", "Show all frames before the first keyframe", 0, AV_OPT_TYPE_CONST, {.i64 = CODEC_FLAG2_SHOW_ALL }, INT_MIN, INT_MAX, V|D, "flags2"},
  #if FF_API_SUB_ID
  {"sub_id", NULL, OFFSET(sub_id), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  #endif
  {"celim", "single coefficient elimination threshold for chrominance (negative values also consider dc coefficient)", OFFSET(chroma_elim_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  #endif
  {"strict", "how strictly to follow the standards", OFFSET(strict_std_compliance), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, A|V|D|E, "strict"},
- {"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
- {"strict", "strictly conform to all the things in the spec no matter what consequences", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
- {"normal", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_NORMAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
- {"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
- {"experimental", "allow non standardized experimental things", 0, AV_OPT_TYPE_CONST, {.dbl = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
+ {"very", "strictly conform to a older more strict version of the spec or reference software", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_VERY_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
+ {"strict", "strictly conform to all the things in the spec no matter what consequences", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_STRICT }, INT_MIN, INT_MAX, V|D|E, "strict"},
+ {"normal", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_NORMAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
+ {"unofficial", "allow unofficial extensions", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_UNOFFICIAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
+ {"experimental", "allow non standardized experimental things", 0, AV_OPT_TYPE_CONST, {.i64 = FF_COMPLIANCE_EXPERIMENTAL }, INT_MIN, INT_MAX, V|D|E, "strict"},
  {"b_qoffset", "qp offset between P and B frames", OFFSET(b_quant_offset), AV_OPT_TYPE_FLOAT, {.dbl = 1.25 }, -FLT_MAX, FLT_MAX, V|E},
  {"err_detect", "set error detection flags", OFFSET(err_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
- {"aggressive", "consider things that a sane encoder should not do as an error", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
 -{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, V|D, "err_detect"},
 -{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, V|D, "err_detect"},
++{"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CAREFUL }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
++{"aggressive", "consider things that a sane encoder should not do as an error", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, A|V|D, "err_detect"},
  {"has_b_frames", NULL, OFFSET(has_b_frames), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  {"block_align", NULL, OFFSET(block_align), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  {"mpeg_quant", "use MPEG quantizers instead of H.263", OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"p_mask", "inter masking", OFFSET(p_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
  {"dark_mask", "compresses dark areas stronger than medium ones", OFFSET(dark_masking), AV_OPT_TYPE_FLOAT, {.dbl = 0 }, -FLT_MAX, FLT_MAX, V|E},
  {"idct", "select IDCT implementation", OFFSET(idct_algo), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, V|E|D, "idct"},
- {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_AUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"int", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simple", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simplemmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"libmpeg2mmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_LIBMPEG2MMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"mmi", NULL, 0, AV_OPT_TYPE_CONST, { .dbl = FF_IDCT_MMI }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"arm", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_ARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_ALTIVEC }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"sh4", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SH4 }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simplearm", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simplearmv5te", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simplearmv6", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simpleneon", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"simplealpha", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_SIMPLEALPHA }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"h264", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_H264 }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"vp3", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_VP3 }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"ipp", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"xvidmmx", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_XVIDMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
- {"faani", "floating point AAN IDCT", 0, AV_OPT_TYPE_CONST, {.dbl = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},
+ {"auto", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_AUTO }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"int", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_INT }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simple", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLE }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simplemmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
++{"libmpeg2mmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_LIBMPEG2MMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"mmi", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_MMI }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"arm", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"altivec", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_ALTIVEC }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"sh4", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SH4 }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simplearm", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARM }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simplearmv5te", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV5TE }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simplearmv6", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEARMV6 }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simpleneon", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLENEON }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"simplealpha", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_SIMPLEALPHA }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"h264", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_H264 }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"vp3", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_VP3 }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"ipp", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_IPP }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"xvidmmx", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_XVIDMMX }, INT_MIN, INT_MAX, V|E|D, "idct"},
+ {"faani", "floating point AAN IDCT", 0, AV_OPT_TYPE_CONST, {.i64 = FF_IDCT_FAAN }, INT_MIN, INT_MAX, V|D|E, "idct"},
  {"slice_count", NULL, OFFSET(slice_count), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  {"ec", "set error concealment strategy", OFFSET(error_concealment), AV_OPT_TYPE_FLAGS, {.dbl = 3 }, INT_MIN, INT_MAX, V|D, "ec"},
- {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},
- {"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.dbl = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},
+ {"guess_mvs", "iterative motion vector (MV) search (slow)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_GUESS_MVS }, INT_MIN, INT_MAX, V|D, "ec"},
+ {"deblock", "use strong deblock filter for damaged MBs", 0, AV_OPT_TYPE_CONST, {.i64 = FF_EC_DEBLOCK }, INT_MIN, INT_MAX, V|D, "ec"},
  {"bits_per_coded_sample", NULL, OFFSET(bits_per_coded_sample), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX},
  {"pred", "prediction method", OFFSET(prediction_method), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "pred"},
- {"left", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},
- {"plane", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_PLANE }, INT_MIN, INT_MAX, V|E, "pred"},
- {"median", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PRED_MEDIAN }, INT_MIN, INT_MAX, V|E, "pred"},
+ {"left", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_LEFT }, INT_MIN, INT_MAX, V|E, "pred"},
+ {"plane", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_PLANE }, INT_MIN, INT_MAX, V|E, "pred"},
+ {"median", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PRED_MEDIAN }, INT_MIN, INT_MAX, V|E, "pred"},
  {"aspect", "sample aspect ratio", OFFSET(sample_aspect_ratio), AV_OPT_TYPE_RATIONAL, {.dbl = 0}, 0, 10, V|E},
  {"debug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, V|A|S|E|D, "debug"},
- {"pict", "picture info", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_PICT_INFO }, INT_MIN, INT_MAX, V|D, "debug"},
- {"rc", "rate control", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_RC }, INT_MIN, INT_MAX, V|E, "debug"},
- {"bitstream", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BITSTREAM }, INT_MIN, INT_MAX, V|D, "debug"},
- {"mb_type", "macroblock (MB) type", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
- {"qp", "per-block quantization parameter (QP)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_QP }, INT_MIN, INT_MAX, V|D, "debug"},
- {"mv", "motion vector", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MV }, INT_MIN, INT_MAX, V|D, "debug"},
- {"dct_coeff", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_DCT_COEFF }, INT_MIN, INT_MAX, V|D, "debug"},
- {"skip", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_SKIP }, INT_MIN, INT_MAX, V|D, "debug"},
- {"startcode", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_STARTCODE }, INT_MIN, INT_MAX, V|D, "debug"},
- {"pts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_PTS }, INT_MIN, INT_MAX, V|D, "debug"},
- {"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},
- {"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},
- {"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},
- {"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_QP }, INT_MIN, INT_MAX, V|D, "debug"},
- {"vis_mb_type", "visualize block types", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
- {"buffers", "picture buffer allocations", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_BUFFERS }, INT_MIN, INT_MAX, V|D, "debug"},
- {"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"pict", "picture info", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PICT_INFO }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"rc", "rate control", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_RC }, INT_MIN, INT_MAX, V|E, "debug"},
+ {"bitstream", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BITSTREAM }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"mb_type", "macroblock (MB) type", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"qp", "per-block quantization parameter (QP)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_QP }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"mv", "motion vector", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MV }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"dct_coeff", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_DCT_COEFF }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"skip", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_SKIP }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"startcode", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_STARTCODE }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"pts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_PTS }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"er", "error recognition", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_ER }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"mmco", "memory management control operations (H.264)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_MMCO }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"bugs", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUGS }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"vis_qp", "visualize quantization parameter (QP), lower QP are tinted greener", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_QP }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"vis_mb_type", "visualize block types", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MB_TYPE }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"buffers", "picture buffer allocations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_BUFFERS }, INT_MIN, INT_MAX, V|D, "debug"},
+ {"thread_ops", "threading operations", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_THREADS }, INT_MIN, INT_MAX, V|D, "debug"},
  {"vismv", "visualize motion vectors (MVs)", OFFSET(debug_mv), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, V|D, "debug_mv"},
- {"pf", "forward predicted MVs of P-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_P_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
- {"bf", "forward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_B_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
- {"bb", "backward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.dbl = FF_DEBUG_VIS_MV_B_BACK }, INT_MIN, INT_MAX, V|D, "debug_mv"},
+ {"pf", "forward predicted MVs of P-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_P_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
+ {"bf", "forward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_FOR }, INT_MIN, INT_MAX, V|D, "debug_mv"},
+ {"bb", "backward predicted MVs of B-frames", 0, AV_OPT_TYPE_CONST, {.i64 = FF_DEBUG_VIS_MV_B_BACK }, INT_MIN, INT_MAX, V|D, "debug_mv"},
  {"cmp", "full pel me compare function", OFFSET(me_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"subcmp", "sub pel me compare function", OFFSET(me_sub_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"mbcmp", "macroblock compare function", OFFSET(mb_cmp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E, "cmp_func"},
  {"skip_top", "number of macroblock rows at the top which are skipped", OFFSET(skip_top), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|D},
  {"skip_bottom", "number of macroblock rows at the bottom which are skipped", OFFSET(skip_bottom), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|D},
  {"profile", NULL, OFFSET(profile), AV_OPT_TYPE_INT, {.dbl = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
- {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
- {"aac_main", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_MAIN }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_low", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_LOW }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_ssr", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_SSR }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_ltp", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_LTP }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_he", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_HE }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_he_v2", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_HE_V2 }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_ld", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_LD }, INT_MIN, INT_MAX, A|E, "profile"},
- {"aac_eld", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_AAC_ELD }, INT_MIN, INT_MAX, A|E, "profile"},
- {"dts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS }, INT_MIN, INT_MAX, A|E, "profile"},
- {"dts_es", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_ES }, INT_MIN, INT_MAX, A|E, "profile"},
- {"dts_96_24", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_96_24 }, INT_MIN, INT_MAX, A|E, "profile"},
- {"dts_hd_hra", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_HD_HRA }, INT_MIN, INT_MAX, A|E, "profile"},
- {"dts_hd_ma", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_PROFILE_DTS_HD_MA }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "profile"},
+ {"aac_main", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_MAIN }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_low", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LOW }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_ssr", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_SSR }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_ltp", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LTP }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_he", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_HE }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_he_v2", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_HE_V2 }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_ld", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_LD }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"aac_eld", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_AAC_ELD }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_es", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_ES }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_96_24", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_96_24 }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_hd_hra", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_HD_HRA }, INT_MIN, INT_MAX, A|E, "profile"},
+ {"dts_hd_ma", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_PROFILE_DTS_HD_MA }, INT_MIN, INT_MAX, A|E, "profile"},
  {"level", NULL, OFFSET(level), AV_OPT_TYPE_INT, {.dbl = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
- {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
+ {"unknown", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_LEVEL_UNKNOWN }, INT_MIN, INT_MAX, V|A|E, "level"},
 +{"lowres", "decode at 1= 1/2, 2=1/4, 3=1/8 resolutions", OFFSET(lowres), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, V|A|D},
  {"skip_threshold", "frame skip threshold", OFFSET(frame_skip_threshold), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"skip_factor", "frame skip factor", OFFSET(frame_skip_factor), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"skip_exp", "frame skip exponent", OFFSET(frame_skip_exp), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"skip_loop_filter", NULL, OFFSET(skip_loop_filter), AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"skip_idct"       , NULL, OFFSET(skip_idct)       , AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"skip_frame"      , NULL, OFFSET(skip_frame)      , AV_OPT_TYPE_INT, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"none"            , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONE    }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"default"         , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"noref"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONREF  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"bidir"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_BIDIR   }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"nokey"           , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_NONKEY  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
- {"all"             , NULL, 0, AV_OPT_TYPE_CONST, {.dbl = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"none"            , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONE    }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"default"         , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_DEFAULT }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"noref"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONREF  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"bidir"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_BIDIR   }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"nokey"           , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_NONKEY  }, INT_MIN, INT_MAX, V|D, "avdiscard"},
+ {"all"             , NULL, 0, AV_OPT_TYPE_CONST, {.i64 = AVDISCARD_ALL     }, INT_MIN, INT_MAX, V|D, "avdiscard"},
  {"bidir_refine", "refine the two motion vectors used in bidirectional macroblocks", OFFSET(bidir_refine), AV_OPT_TYPE_INT, {.dbl = 1 }, 0, 4, V|E},
  {"brd_scale", "downscales frames for dynamic B-frame decision", OFFSET(brd_scale), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, 10, V|E},
 -{"keyint_min", "minimum interval between IDR-frames (x264)", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 -{"refs", "reference frames to consider for motion compensation (Snow)", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
 +{"keyint_min", "minimum interval between IDR-frames", OFFSET(keyint_min), AV_OPT_TYPE_INT, {.dbl = 25 }, INT_MIN, INT_MAX, V|E},
 +{"refs", "reference frames to consider for motion compensation", OFFSET(refs), AV_OPT_TYPE_INT, {.dbl = 1 }, INT_MIN, INT_MAX, V|E},
  {"chromaoffset", "chroma qp offset from luma", OFFSET(chromaoffset), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|E},
  {"trellis", "rate-distortion optimal quantization", OFFSET(trellis), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, INT_MIN, INT_MAX, V|A|E},
  #if FF_API_MPV_GLOBAL_OPTS
  {"log_level_offset", "set the log level offset", OFFSET(log_level_offset), AV_OPT_TYPE_INT, {.dbl = 0 }, INT_MIN, INT_MAX },
  {"slices", "number of slices, used in parallelized encoding", OFFSET(slices), AV_OPT_TYPE_INT, {.dbl = 0 }, 0, INT_MAX, V|E},
  {"thread_type", "select multithreading type", OFFSET(thread_type), AV_OPT_TYPE_FLAGS, {.dbl = FF_THREAD_SLICE|FF_THREAD_FRAME }, 0, INT_MAX, V|E|D, "thread_type"},
- {"slice", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_THREAD_SLICE }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
- {"frame", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_THREAD_FRAME }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
+ {"slice", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_THREAD_SLICE }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
+ {"frame", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_THREAD_FRAME }, INT_MIN, INT_MAX, V|E|D, "thread_type"},
  {"audio_service_type", "audio service type", OFFSET(audio_service_type), AV_OPT_TYPE_INT, {.dbl = AV_AUDIO_SERVICE_TYPE_MAIN }, 0, AV_AUDIO_SERVICE_TYPE_NB-1, A|E, "audio_service_type"},
- {"ma", "Main Audio Service", 0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_MAIN },              INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"ef", "Effects",            0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_EFFECTS },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"vi", "Visually Impaired",  0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"hi", "Hearing Impaired",   0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED },  INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"di", "Dialogue",           0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_DIALOGUE },          INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"co", "Commentary",         0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_COMMENTARY },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"em", "Emergency",          0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_EMERGENCY },         INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"vo", "Voice Over",         0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_VOICE_OVER },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
- {"ka", "Karaoke",            0, AV_OPT_TYPE_CONST, {.dbl = AV_AUDIO_SERVICE_TYPE_KARAOKE },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"ma", "Main Audio Service", 0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_MAIN },              INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"ef", "Effects",            0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_EFFECTS },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"vi", "Visually Impaired",  0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED }, INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"hi", "Hearing Impaired",   0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED },  INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"di", "Dialogue",           0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_DIALOGUE },          INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"co", "Commentary",         0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_COMMENTARY },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"em", "Emergency",          0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_EMERGENCY },         INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"vo", "Voice Over",         0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_VOICE_OVER },        INT_MIN, INT_MAX, A|E, "audio_service_type"},
+ {"ka", "Karaoke",            0, AV_OPT_TYPE_CONST, {.i64 = AV_AUDIO_SERVICE_TYPE_KARAOKE },           INT_MIN, INT_MAX, A|E, "audio_service_type"},
 -{"request_sample_fmt", NULL, OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.dbl = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
 +{"request_sample_fmt", "sample format audio decoders should prefer", OFFSET(request_sample_fmt), AV_OPT_TYPE_INT, {.dbl = AV_SAMPLE_FMT_NONE }, AV_SAMPLE_FMT_NONE, AV_SAMPLE_FMT_NB-1, A|D, "request_sample_fmt"},
- {"u8" , "8-bit unsigned integer", 0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_U8  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"s16", "16-bit signed integer",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S16 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"s32", "32-bit signed integer",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S32 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"flt", "32-bit float",           0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_FLT }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"dbl", "64-bit double",          0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_DBL }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"u8p" , "8-bit unsigned integer planar", 0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_U8P  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"s16p", "16-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S16P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"s32p", "32-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_S32P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"fltp", "32-bit float planar",           0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_FLTP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
- {"dblp", "64-bit double planar",          0, AV_OPT_TYPE_CONST, {.dbl = AV_SAMPLE_FMT_DBLP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"u8" , "8-bit unsigned integer", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_U8  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s16", "16-bit signed integer",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S16 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s32", "32-bit signed integer",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32 }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"flt", "32-bit float",           0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_FLT }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"dbl", "64-bit double",          0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_DBL }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"u8p" , "8-bit unsigned integer planar", 0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_U8P  }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s16p", "16-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S16P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"s32p", "32-bit signed integer planar",  0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_S32P }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"fltp", "32-bit float planar",           0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_FLTP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
+ {"dblp", "64-bit double planar",          0, AV_OPT_TYPE_CONST, {.i64 = AV_SAMPLE_FMT_DBLP }, INT_MIN, INT_MAX, A|D, "request_sample_fmt"},
 +{"pkt_timebase", NULL, OFFSET(pkt_timebase), AV_OPT_TYPE_RATIONAL, {.dbl = 0 }, 0, INT_MAX, 0},
  {NULL},
  };
  
Simple merge
@@@ -493,13 -450,12 +493,13 @@@ static av_cold int encode_close(AVCodec
  #define OFFSET(x) offsetof(TiffEncoderContext, x)
  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  static const AVOption options[] = {
 +    {"dpi", "set the image resolution (in dpi)", OFFSET(dpi), AV_OPT_TYPE_INT, {.dbl = 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_ENCODING_PARAM},
      { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, {TIFF_PACKBITS}, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
-     { "packbits", NULL, 0, AV_OPT_TYPE_CONST, {TIFF_PACKBITS}, 0, 0, VE, "compression_algo" },
-     { "raw",      NULL, 0, AV_OPT_TYPE_CONST, {TIFF_RAW},      0, 0, VE, "compression_algo" },
-     { "lzw",      NULL, 0, AV_OPT_TYPE_CONST, {TIFF_LZW},      0, 0, VE, "compression_algo" },
+     { "packbits", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_PACKBITS}, 0, 0, VE, "compression_algo" },
+     { "raw",      NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_RAW},      0, 0, VE, "compression_algo" },
+     { "lzw",      NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_LZW},      0, 0, VE, "compression_algo" },
  #if CONFIG_ZLIB
-     { "deflate",  NULL, 0, AV_OPT_TYPE_CONST, {TIFF_DEFLATE},  0, 0, VE, "compression_algo" },
+     { "deflate",  NULL, 0, AV_OPT_TYPE_CONST, {.i64 = TIFF_DEFLATE},  0, 0, VE, "compression_algo" },
  #endif
      { NULL },
  };
@@@ -316,13 -325,13 +316,13 @@@ static int grab_read_close(AVFormatCont
  #define DEC AV_OPT_FLAG_DECODING_PARAM
  static const AVOption options[] = {
      { "standard", "", offsetof(VideoData, standard), AV_OPT_TYPE_INT, {.dbl = VIDEO_FORMAT}, PAL, NTSCJ, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "PAL",      "", 0, AV_OPT_TYPE_CONST, {.dbl = PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "NTSC",     "", 0, AV_OPT_TYPE_CONST, {.dbl = NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "SECAM",    "", 0, AV_OPT_TYPE_CONST, {.dbl = SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "PALN",     "", 0, AV_OPT_TYPE_CONST, {.dbl = PALN},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "PALM",     "", 0, AV_OPT_TYPE_CONST, {.dbl = PALM},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "NTSCJ",    "", 0, AV_OPT_TYPE_CONST, {.dbl = NTSCJ}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "PAL",      "", 0, AV_OPT_TYPE_CONST, {.i64 = PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "NTSC",     "", 0, AV_OPT_TYPE_CONST, {.i64 = NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "SECAM",    "", 0, AV_OPT_TYPE_CONST, {.i64 = SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "PALN",     "", 0, AV_OPT_TYPE_CONST, {.i64 = PALN},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "PALM",     "", 0, AV_OPT_TYPE_CONST, {.i64 = PALM},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
+     { "NTSCJ",    "", 0, AV_OPT_TYPE_CONST, {.i64 = NTSCJ}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
 -    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = "vga"}, 0, 0, DEC },
 +    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(width), AV_OPT_TYPE_IMAGE_SIZE, {.str = "vga"}, 0, 0, DEC },
      { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
      { NULL },
  };
index bd5dde5,0000000..74de809
mode 100644,000000..100644
--- /dev/null
@@@ -1,240 -1,0 +1,240 @@@
-     { "true",         NULL, 0, AV_OPT_TYPE_CONST, {.dbl = 1}, 0, 0, ENC, "list_drivers" },
-     { "false",        NULL, 0, AV_OPT_TYPE_CONST, {.dbl = 0}, 0, 0, ENC, "list_drivers" },
 +/*
 + * Copyright (c) 2012 Paul B Mahol
 + *
 + * 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 <caca.h>
 +#include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "avdevice.h"
 +
 +typedef struct CACAContext {
 +    AVClass         *class;
 +    AVFormatContext *ctx;
 +    char            *window_title;
 +    int             window_width,  window_height;
 +
 +    caca_canvas_t   *canvas;
 +    caca_display_t  *display;
 +    caca_dither_t   *dither;
 +
 +    char            *algorithm, *antialias;
 +    char            *charset, *color;
 +    char            *driver;
 +
 +    char            *list_dither;
 +    int             list_drivers;
 +} CACAContext;
 +
 +static int caca_write_trailer(AVFormatContext *s)
 +{
 +    CACAContext *c = s->priv_data;
 +
 +    av_freep(&c->window_title);
 +
 +    if (c->display) {
 +        caca_free_display(c->display);
 +        c->display = NULL;
 +    }
 +    if (c->dither) {
 +        caca_free_dither(c->dither);
 +        c->dither = NULL;
 +    }
 +    if (c->canvas) {
 +        caca_free_canvas(c->canvas);
 +        c->canvas = NULL;
 +    }
 +    return 0;
 +}
 +
 +static void list_drivers(CACAContext *c)
 +{
 +    const char *const *drivers = caca_get_display_driver_list();
 +    int i;
 +
 +    av_log(c->ctx, AV_LOG_INFO, "Available drivers:\n");
 +    for (i = 0; drivers[i]; i += 2)
 +        av_log(c->ctx, AV_LOG_INFO, "%s : %s\n", drivers[i], drivers[i + 1]);
 +}
 +
 +#define DEFINE_LIST_DITHER(thing, thing_str)                                 \
 +static void list_dither_## thing(CACAContext *c)                         \
 +{                                                                            \
 +    const char *const *thing = caca_get_dither_## thing ##_list(c->dither);  \
 +    int i;                                                                   \
 +                                                                             \
 +    av_log(c->ctx, AV_LOG_INFO, "Available %s:\n", thing_str);               \
 +    for (i = 0; thing[i]; i += 2)                                            \
 +        av_log(c->ctx, AV_LOG_INFO, "%s : %s\n", thing[i], thing[i + 1]);    \
 +}
 +
 +DEFINE_LIST_DITHER(color, "colors");
 +DEFINE_LIST_DITHER(charset, "charsets");
 +DEFINE_LIST_DITHER(algorithm, "algorithms");
 +DEFINE_LIST_DITHER(antialias, "antialias");
 +
 +static int caca_write_header(AVFormatContext *s)
 +{
 +    CACAContext *c = s->priv_data;
 +    AVStream *st = s->streams[0];
 +    AVCodecContext *encctx = st->codec;
 +    int ret, bpp;
 +
 +    c->ctx = s;
 +    if (c->list_drivers) {
 +        list_drivers(c);
 +        return AVERROR_EXIT;
 +    }
 +    if (c->list_dither) {
 +        if (!strcmp(c->list_dither, "colors")) {
 +            list_dither_color(c);
 +        } else if (!strcmp(c->list_dither, "charsets")) {
 +            list_dither_charset(c);
 +        } else if (!strcmp(c->list_dither, "algorithms")) {
 +            list_dither_algorithm(c);
 +        } else if (!strcmp(c->list_dither, "antialiases")) {
 +            list_dither_antialias(c);
 +        } else {
 +            av_log(s, AV_LOG_ERROR,
 +                   "Invalid argument '%s', for 'list_dither' option\n"
 +                   "Argument must be one of 'algorithms, 'antialiases', 'charsets', 'colors'\n",
 +                   c->list_dither);
 +            return AVERROR(EINVAL);
 +        }
 +        return AVERROR_EXIT;
 +    }
 +
 +    if (   s->nb_streams > 1
 +        || encctx->codec_type != AVMEDIA_TYPE_VIDEO
 +        || encctx->codec_id   != AV_CODEC_ID_RAWVIDEO) {
 +        av_log(s, AV_LOG_ERROR, "Only supports one rawvideo stream\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (encctx->pix_fmt != PIX_FMT_RGB24) {
 +        av_log(s, AV_LOG_ERROR,
 +               "Unsupported pixel format '%s', choose rgb24\n",
 +               av_get_pix_fmt_name(encctx->pix_fmt));
 +        return AVERROR(EINVAL);
 +    }
 +
 +    c->canvas = caca_create_canvas(c->window_width, c->window_height);
 +    if (!c->canvas) {
 +        av_log(s, AV_LOG_ERROR, "Failed to create canvas\n");
 +        ret = AVERROR(errno);
 +        goto fail;
 +    }
 +
 +    bpp = av_get_bits_per_pixel(&av_pix_fmt_descriptors[encctx->pix_fmt]);
 +    c->dither = caca_create_dither(bpp, encctx->width, encctx->height,
 +                                   bpp / 8 * encctx->width,
 +                                   0x0000ff, 0x00ff00, 0xff0000, 0);
 +    if (!c->dither) {
 +        av_log(s, AV_LOG_ERROR, "Failed to create dither\n");
 +        ret =  AVERROR(errno);
 +        goto fail;
 +    }
 +
 +#define CHECK_DITHER_OPT(opt)                                           \
 +    if (caca_set_dither_##opt(c->dither, c->opt) < 0)  {                \
 +        ret = AVERROR(errno);                                           \
 +        av_log(s, AV_LOG_ERROR, "Failed to set value '%s' for option '%s'\n", \
 +               c->opt, #opt);                                           \
 +        goto fail;                                                      \
 +    }
 +    CHECK_DITHER_OPT(algorithm);
 +    CHECK_DITHER_OPT(antialias);
 +    CHECK_DITHER_OPT(charset);
 +    CHECK_DITHER_OPT(color);
 +
 +    c->display = caca_create_display_with_driver(c->canvas, c->driver);
 +    if (!c->display) {
 +        av_log(s, AV_LOG_ERROR, "Failed to create display\n");
 +        list_drivers(c);
 +        ret = AVERROR(errno);
 +        goto fail;
 +    }
 +
 +    if (!c->window_width || !c->window_height) {
 +        c->window_width  = caca_get_canvas_width(c->canvas);
 +        c->window_height = caca_get_canvas_height(c->canvas);
 +    }
 +
 +    if (!c->window_title)
 +        c->window_title = av_strdup(s->filename);
 +    caca_set_display_title(c->display, c->window_title);
 +    caca_set_display_time(c->display, av_rescale_q(1, st->codec->time_base, AV_TIME_BASE_Q));
 +
 +    return 0;
 +
 +fail:
 +    caca_write_trailer(s);
 +    return ret;
 +}
 +
 +static int caca_write_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    CACAContext *c = s->priv_data;
 +
 +    caca_dither_bitmap(c->canvas, 0, 0, c->window_width, c->window_height, c->dither, pkt->data);
 +    caca_refresh_display(c->display);
 +
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(CACAContext,x)
 +#define ENC AV_OPT_FLAG_ENCODING_PARAM
 +
 +static const AVOption options[] = {
 +    { "window_size",  "set window forced size",  OFFSET(window_width), AV_OPT_TYPE_IMAGE_SIZE, {.str = NULL }, 0, 0, ENC},
 +    { "window_title", "set window title",        OFFSET(window_title), AV_OPT_TYPE_STRING,     {.str = NULL }, 0, 0, ENC },
 +    { "driver",       "set display driver",      OFFSET(driver),    AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, ENC },
 +    { "algorithm",    "set dithering algorithm", OFFSET(algorithm), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 +    { "antialias",    "set antialias method",    OFFSET(antialias), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 +    { "charset",      "set charset used to render output", OFFSET(charset), AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 +    { "color",        "set color used to render output",   OFFSET(color),   AV_OPT_TYPE_STRING, {.str = "default" }, 0, 0, ENC },
 +    { "list_drivers", "list available drivers",  OFFSET(list_drivers), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, ENC, "list_drivers" },
++    { "true",         NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 1}, 0, 0, ENC, "list_drivers" },
++    { "false",        NULL, 0, AV_OPT_TYPE_CONST, {.i64 = 0}, 0, 0, ENC, "list_drivers" },
 +    { "list_dither", "list available dither options", OFFSET(list_dither), AV_OPT_TYPE_STRING, {.dbl=0}, 0, 1, ENC, "list_dither" },
 +    { "algorithms",   NULL, 0, AV_OPT_TYPE_CONST, {.str = "algorithms"}, 0, 0, ENC, "list_dither" },
 +    { "antialiases",  NULL, 0, AV_OPT_TYPE_CONST, {.str = "antialiases"},0, 0, ENC, "list_dither" },
 +    { "charsets",     NULL, 0, AV_OPT_TYPE_CONST, {.str = "charsets"},   0, 0, ENC, "list_dither" },
 +    { "colors",       NULL, 0, AV_OPT_TYPE_CONST, {.str = "colors"},     0, 0, ENC, "list_dither" },
 +    { NULL },
 +};
 +
 +static const AVClass caca_class = {
 +    .class_name = "caca_outdev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVOutputFormat ff_caca_muxer = {
 +    .name           = "caca",
 +    .long_name      = NULL_IF_CONFIG_SMALL("caca (color ASCII art) output device"),
 +    .priv_data_size = sizeof(CACAContext),
 +    .audio_codec    = AV_CODEC_ID_NONE,
 +    .video_codec    = AV_CODEC_ID_RAWVIDEO,
 +    .write_header   = caca_write_header,
 +    .write_packet   = caca_write_packet,
 +    .write_trailer  = caca_write_trailer,
 +    .flags          = AVFMT_NOFILE,
 +    .priv_class     = &caca_class,
 +};
index 18adf8f,0000000..48bab37
mode 100644,000000..100644
--- /dev/null
@@@ -1,1025 -1,0 +1,1025 @@@
-     { "true", "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, DEC, "list_devices" },
-     { "false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, DEC, "list_devices" },
 +/*
 + * Directshow capture interface
 + * Copyright (c) 2010 Ramiro Polla
 + *
 + * 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/parseutils.h"
 +#include "libavutil/opt.h"
 +#include "libavformat/internal.h"
 +#include "avdevice.h"
 +#include "dshow_capture.h"
 +
 +struct dshow_ctx {
 +    const AVClass *class;
 +
 +    IGraphBuilder *graph;
 +
 +    char *device_name[2];
 +    int video_device_number;
 +    int audio_device_number;
 +
 +    int   list_options;
 +    int   list_devices;
 +    int   audio_buffer_size;
 +
 +    IBaseFilter *device_filter[2];
 +    IPin        *device_pin[2];
 +    libAVFilter *capture_filter[2];
 +    libAVPin    *capture_pin[2];
 +
 +    HANDLE mutex;
 +    HANDLE event;
 +    AVPacketList *pktl;
 +
 +    int64_t curbufsize;
 +    unsigned int video_frame_num;
 +
 +    IMediaControl *control;
 +
 +    char *video_size;
 +    char *framerate;
 +
 +    int requested_width;
 +    int requested_height;
 +    AVRational requested_framerate;
 +
 +    int sample_rate;
 +    int sample_size;
 +    int channels;
 +};
 +
 +static enum PixelFormat dshow_pixfmt(DWORD biCompression, WORD biBitCount)
 +{
 +    switch(biCompression) {
 +    case MKTAG('U', 'Y', 'V', 'Y'):
 +        return PIX_FMT_UYVY422;
 +    case MKTAG('Y', 'U', 'Y', '2'):
 +        return PIX_FMT_YUYV422;
 +    case MKTAG('I', '4', '2', '0'):
 +        return PIX_FMT_YUV420P;
 +    case BI_BITFIELDS:
 +    case BI_RGB:
 +        switch(biBitCount) { /* 1-8 are untested */
 +            case 1:
 +                return PIX_FMT_MONOWHITE;
 +            case 4:
 +                return PIX_FMT_RGB4;
 +            case 8:
 +                return PIX_FMT_RGB8;
 +            case 16:
 +                return PIX_FMT_RGB555;
 +            case 24:
 +                return PIX_FMT_BGR24;
 +            case 32:
 +                return PIX_FMT_RGB32;
 +        }
 +    }
 +    return PIX_FMT_NONE;
 +}
 +
 +static enum AVCodecID dshow_codecid(DWORD biCompression)
 +{
 +    switch(biCompression) {
 +    case MKTAG('d', 'v', 's', 'd'):
 +        return AV_CODEC_ID_DVVIDEO;
 +    case MKTAG('M', 'J', 'P', 'G'):
 +    case MKTAG('m', 'j', 'p', 'g'):
 +        return AV_CODEC_ID_MJPEG;
 +    }
 +    return AV_CODEC_ID_NONE;
 +}
 +
 +static int
 +dshow_read_close(AVFormatContext *s)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList *pktl;
 +
 +    if (ctx->control) {
 +        IMediaControl_Stop(ctx->control);
 +        IMediaControl_Release(ctx->control);
 +    }
 +
 +    if (ctx->graph) {
 +        IEnumFilters *fenum;
 +        int r;
 +        r = IGraphBuilder_EnumFilters(ctx->graph, &fenum);
 +        if (r == S_OK) {
 +            IBaseFilter *f;
 +            IEnumFilters_Reset(fenum);
 +            while (IEnumFilters_Next(fenum, 1, &f, NULL) == S_OK) {
 +                if (IGraphBuilder_RemoveFilter(ctx->graph, f) == S_OK)
 +                    IEnumFilters_Reset(fenum); /* When a filter is removed,
 +                                                * the list must be reset. */
 +                IBaseFilter_Release(f);
 +            }
 +            IEnumFilters_Release(fenum);
 +        }
 +        IGraphBuilder_Release(ctx->graph);
 +    }
 +
 +    if (ctx->capture_pin[VideoDevice])
 +        libAVPin_Release(ctx->capture_pin[VideoDevice]);
 +    if (ctx->capture_pin[AudioDevice])
 +        libAVPin_Release(ctx->capture_pin[AudioDevice]);
 +    if (ctx->capture_filter[VideoDevice])
 +        libAVFilter_Release(ctx->capture_filter[VideoDevice]);
 +    if (ctx->capture_filter[AudioDevice])
 +        libAVFilter_Release(ctx->capture_filter[AudioDevice]);
 +
 +    if (ctx->device_pin[VideoDevice])
 +        IPin_Release(ctx->device_pin[VideoDevice]);
 +    if (ctx->device_pin[AudioDevice])
 +        IPin_Release(ctx->device_pin[AudioDevice]);
 +    if (ctx->device_filter[VideoDevice])
 +        IBaseFilter_Release(ctx->device_filter[VideoDevice]);
 +    if (ctx->device_filter[AudioDevice])
 +        IBaseFilter_Release(ctx->device_filter[AudioDevice]);
 +
 +    if (ctx->device_name[0])
 +        av_free(ctx->device_name[0]);
 +    if (ctx->device_name[1])
 +        av_free(ctx->device_name[1]);
 +
 +    if(ctx->mutex)
 +        CloseHandle(ctx->mutex);
 +    if(ctx->event)
 +        CloseHandle(ctx->event);
 +
 +    pktl = ctx->pktl;
 +    while (pktl) {
 +        AVPacketList *next = pktl->next;
 +        av_destruct_packet(&pktl->pkt);
 +        av_free(pktl);
 +        pktl = next;
 +    }
 +
 +    return 0;
 +}
 +
 +static char *dup_wchar_to_utf8(wchar_t *w)
 +{
 +    char *s = NULL;
 +    int l = WideCharToMultiByte(CP_UTF8, 0, w, -1, 0, 0, 0, 0);
 +    s = av_malloc(l);
 +    if (s)
 +        WideCharToMultiByte(CP_UTF8, 0, w, -1, s, l, 0, 0);
 +    return s;
 +}
 +
 +static int shall_we_drop(AVFormatContext *s)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    const uint8_t dropscore[] = {62, 75, 87, 100};
 +    const int ndropscores = FF_ARRAY_ELEMS(dropscore);
 +    unsigned int buffer_fullness = (ctx->curbufsize*100)/s->max_picture_buffer;
 +
 +    if(dropscore[++ctx->video_frame_num%ndropscores] <= buffer_fullness) {
 +        av_log(s, AV_LOG_ERROR,
 +              "real-time buffer %d%% full! frame dropped!\n", buffer_fullness);
 +        return 1;
 +    }
 +
 +    return 0;
 +}
 +
 +static void
 +callback(void *priv_data, int index, uint8_t *buf, int buf_size, int64_t time)
 +{
 +    AVFormatContext *s = priv_data;
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList **ppktl, *pktl_next;
 +
 +//    dump_videohdr(s, vdhdr);
 +
 +    WaitForSingleObject(ctx->mutex, INFINITE);
 +
 +    if(shall_we_drop(s))
 +        goto fail;
 +
 +    pktl_next = av_mallocz(sizeof(AVPacketList));
 +    if(!pktl_next)
 +        goto fail;
 +
 +    if(av_new_packet(&pktl_next->pkt, buf_size) < 0) {
 +        av_free(pktl_next);
 +        goto fail;
 +    }
 +
 +    pktl_next->pkt.stream_index = index;
 +    pktl_next->pkt.pts = time;
 +    memcpy(pktl_next->pkt.data, buf, buf_size);
 +
 +    for(ppktl = &ctx->pktl ; *ppktl ; ppktl = &(*ppktl)->next);
 +    *ppktl = pktl_next;
 +
 +    ctx->curbufsize += buf_size;
 +
 +    SetEvent(ctx->event);
 +    ReleaseMutex(ctx->mutex);
 +
 +    return;
 +fail:
 +    ReleaseMutex(ctx->mutex);
 +    return;
 +}
 +
 +/**
 + * Cycle through available devices using the device enumerator devenum,
 + * retrieve the device with type specified by devtype and return the
 + * pointer to the object found in *pfilter.
 + * If pfilter is NULL, list all device names.
 + */
 +static int
 +dshow_cycle_devices(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                    enum dshowDeviceType devtype, IBaseFilter **pfilter)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    IEnumMoniker *classenum = NULL;
 +    IMoniker *m = NULL;
 +    const char *device_name = ctx->device_name[devtype];
 +    int skip = (devtype == VideoDevice) ? ctx->video_device_number
 +                                        : ctx->audio_device_number;
 +    int r;
 +
 +    const GUID *device_guid[2] = { &CLSID_VideoInputDeviceCategory,
 +                                   &CLSID_AudioInputDeviceCategory };
 +    const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 +
 +    r = ICreateDevEnum_CreateClassEnumerator(devenum, device_guid[devtype],
 +                                             (IEnumMoniker **) &classenum, 0);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate %s devices.\n",
 +               devtypename);
 +        return AVERROR(EIO);
 +    }
 +
 +    while (!device_filter && IEnumMoniker_Next(classenum, 1, &m, NULL) == S_OK) {
 +        IPropertyBag *bag = NULL;
 +        char *buf = NULL;
 +        VARIANT var;
 +
 +        r = IMoniker_BindToStorage(m, 0, 0, &IID_IPropertyBag, (void *) &bag);
 +        if (r != S_OK)
 +            goto fail1;
 +
 +        var.vt = VT_BSTR;
 +        r = IPropertyBag_Read(bag, L"FriendlyName", &var, NULL);
 +        if (r != S_OK)
 +            goto fail1;
 +
 +        buf = dup_wchar_to_utf8(var.bstrVal);
 +
 +        if (pfilter) {
 +            if (strcmp(device_name, buf))
 +                goto fail1;
 +
 +            if (!skip--)
 +                IMoniker_BindToObject(m, 0, 0, &IID_IBaseFilter, (void *) &device_filter);
 +        } else {
 +            av_log(avctx, AV_LOG_INFO, " \"%s\"\n", buf);
 +        }
 +
 +fail1:
 +        if (buf)
 +            av_free(buf);
 +        if (bag)
 +            IPropertyBag_Release(bag);
 +        IMoniker_Release(m);
 +    }
 +
 +    IEnumMoniker_Release(classenum);
 +
 +    if (pfilter) {
 +        if (!device_filter) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not find %s device.\n",
 +                   devtypename);
 +            return AVERROR(EIO);
 +        }
 +        *pfilter = device_filter;
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * Cycle through available formats using the specified pin,
 + * try to set parameters specified through AVOptions and if successful
 + * return 1 in *pformat_set.
 + * If pformat_set is NULL, list all pin capabilities.
 + */
 +static void
 +dshow_cycle_formats(AVFormatContext *avctx, enum dshowDeviceType devtype,
 +                    IPin *pin, int *pformat_set)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IAMStreamConfig *config = NULL;
 +    AM_MEDIA_TYPE *type = NULL;
 +    int format_set = 0;
 +    void *caps = NULL;
 +    int i, n, size;
 +
 +    if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)
 +        return;
 +    if (IAMStreamConfig_GetNumberOfCapabilities(config, &n, &size) != S_OK)
 +        goto end;
 +
 +    caps = av_malloc(size);
 +    if (!caps)
 +        goto end;
 +
 +    for (i = 0; i < n && !format_set; i++) {
 +        IAMStreamConfig_GetStreamCaps(config, i, &type, (void *) caps);
 +
 +#if DSHOWDEBUG
 +        ff_print_AM_MEDIA_TYPE(type);
 +#endif
 +
 +        if (devtype == VideoDevice) {
 +            VIDEO_STREAM_CONFIG_CAPS *vcaps = caps;
 +            BITMAPINFOHEADER *bih;
 +            int64_t *fr;
 +#if DSHOWDEBUG
 +            ff_print_VIDEO_STREAM_CONFIG_CAPS(vcaps);
 +#endif
 +            if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo)) {
 +                VIDEOINFOHEADER *v = (void *) type->pbFormat;
 +                fr = &v->AvgTimePerFrame;
 +                bih = &v->bmiHeader;
 +            } else if (IsEqualGUID(&type->formattype, &FORMAT_VideoInfo2)) {
 +                VIDEOINFOHEADER2 *v = (void *) type->pbFormat;
 +                fr = &v->AvgTimePerFrame;
 +                bih = &v->bmiHeader;
 +            } else {
 +                goto next;
 +            }
 +            if (!pformat_set) {
 +                av_log(avctx, AV_LOG_INFO, "  min s=%ldx%ld fps=%g max s=%ldx%ld fps=%g\n",
 +                       vcaps->MinOutputSize.cx, vcaps->MinOutputSize.cy,
 +                       1e7 / vcaps->MaxFrameInterval,
 +                       vcaps->MaxOutputSize.cx, vcaps->MaxOutputSize.cy,
 +                       1e7 / vcaps->MinFrameInterval);
 +                continue;
 +            }
 +            if (ctx->framerate) {
 +                int64_t framerate = ((int64_t) ctx->requested_framerate.den*10000000)
 +                                            /  ctx->requested_framerate.num;
 +                if (framerate > vcaps->MaxFrameInterval ||
 +                    framerate < vcaps->MinFrameInterval)
 +                    goto next;
 +                *fr = framerate;
 +            }
 +            if (ctx->video_size) {
 +                if (ctx->requested_width  > vcaps->MaxOutputSize.cx ||
 +                    ctx->requested_width  < vcaps->MinOutputSize.cx ||
 +                    ctx->requested_height > vcaps->MaxOutputSize.cy ||
 +                    ctx->requested_height < vcaps->MinOutputSize.cy)
 +                    goto next;
 +                bih->biWidth  = ctx->requested_width;
 +                bih->biHeight = ctx->requested_height;
 +            }
 +        } else {
 +            AUDIO_STREAM_CONFIG_CAPS *acaps = caps;
 +            WAVEFORMATEX *fx;
 +#if DSHOWDEBUG
 +            ff_print_AUDIO_STREAM_CONFIG_CAPS(acaps);
 +#endif
 +            if (IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx)) {
 +                fx = (void *) type->pbFormat;
 +            } else {
 +                goto next;
 +            }
 +            if (!pformat_set) {
 +                av_log(avctx, AV_LOG_INFO, "  min ch=%lu bits=%lu rate=%6lu max ch=%lu bits=%lu rate=%6lu\n",
 +                       acaps->MinimumChannels, acaps->MinimumBitsPerSample, acaps->MinimumSampleFrequency,
 +                       acaps->MaximumChannels, acaps->MaximumBitsPerSample, acaps->MaximumSampleFrequency);
 +                continue;
 +            }
 +            if (ctx->sample_rate) {
 +                if (ctx->sample_rate > acaps->MaximumSampleFrequency ||
 +                    ctx->sample_rate < acaps->MinimumSampleFrequency)
 +                    goto next;
 +                fx->nSamplesPerSec = ctx->sample_rate;
 +            }
 +            if (ctx->sample_size) {
 +                if (ctx->sample_size > acaps->MaximumBitsPerSample ||
 +                    ctx->sample_size < acaps->MinimumBitsPerSample)
 +                    goto next;
 +                fx->wBitsPerSample = ctx->sample_size;
 +            }
 +            if (ctx->channels) {
 +                if (ctx->channels > acaps->MaximumChannels ||
 +                    ctx->channels < acaps->MinimumChannels)
 +                    goto next;
 +                fx->nChannels = ctx->channels;
 +            }
 +        }
 +        if (IAMStreamConfig_SetFormat(config, type) != S_OK)
 +            goto next;
 +        format_set = 1;
 +next:
 +        if (type->pbFormat)
 +            CoTaskMemFree(type->pbFormat);
 +        CoTaskMemFree(type);
 +    }
 +end:
 +    IAMStreamConfig_Release(config);
 +    if (caps)
 +        av_free(caps);
 +    if (pformat_set)
 +        *pformat_set = format_set;
 +}
 +
 +/**
 + * Set audio device buffer size in milliseconds (which can directly impact
 + * latency, depending on the device).
 + */
 +static int
 +dshow_set_audio_buffer_size(AVFormatContext *avctx, IPin *pin)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IAMBufferNegotiation *buffer_negotiation = NULL;
 +    ALLOCATOR_PROPERTIES props = { -1, -1, -1, -1 };
 +    IAMStreamConfig *config = NULL;
 +    AM_MEDIA_TYPE *type = NULL;
 +    int ret = AVERROR(EIO);
 +
 +    if (IPin_QueryInterface(pin, &IID_IAMStreamConfig, (void **) &config) != S_OK)
 +        goto end;
 +    if (IAMStreamConfig_GetFormat(config, &type) != S_OK)
 +        goto end;
 +    if (!IsEqualGUID(&type->formattype, &FORMAT_WaveFormatEx))
 +        goto end;
 +
 +    props.cbBuffer = (((WAVEFORMATEX *) type->pbFormat)->nAvgBytesPerSec)
 +                   * ctx->audio_buffer_size / 1000;
 +
 +    if (IPin_QueryInterface(pin, &IID_IAMBufferNegotiation, (void **) &buffer_negotiation) != S_OK)
 +        goto end;
 +    if (IAMBufferNegotiation_SuggestAllocatorProperties(buffer_negotiation, &props) != S_OK)
 +        goto end;
 +
 +    ret = 0;
 +
 +end:
 +    if (buffer_negotiation)
 +        IAMBufferNegotiation_Release(buffer_negotiation);
 +    if (type) {
 +        if (type->pbFormat)
 +            CoTaskMemFree(type->pbFormat);
 +        CoTaskMemFree(type);
 +    }
 +    if (config)
 +        IAMStreamConfig_Release(config);
 +
 +    return ret;
 +}
 +
 +/**
 + * Cycle through available pins using the device_filter device, of type
 + * devtype, retrieve the first output pin and return the pointer to the
 + * object found in *ppin.
 + * If ppin is NULL, cycle through all pins listing audio/video capabilities.
 + */
 +static int
 +dshow_cycle_pins(AVFormatContext *avctx, enum dshowDeviceType devtype,
 +                 IBaseFilter *device_filter, IPin **ppin)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IEnumPins *pins = 0;
 +    IPin *device_pin = NULL;
 +    IPin *pin;
 +    int r;
 +
 +    const GUID *mediatype[2] = { &MEDIATYPE_Video, &MEDIATYPE_Audio };
 +    const char *devtypename = (devtype == VideoDevice) ? "video" : "audio";
 +
 +    int set_format = (devtype == VideoDevice && (ctx->video_size || ctx->framerate))
 +                  || (devtype == AudioDevice && (ctx->channels || ctx->sample_rate));
 +    int format_set = 0;
 +
 +    r = IBaseFilter_EnumPins(device_filter, &pins);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate pins.\n");
 +        return AVERROR(EIO);
 +    }
 +
 +    if (!ppin) {
 +        av_log(avctx, AV_LOG_INFO, "DirectShow %s device options\n",
 +               devtypename);
 +    }
 +    while (!device_pin && IEnumPins_Next(pins, 1, &pin, NULL) == S_OK) {
 +        IKsPropertySet *p = NULL;
 +        IEnumMediaTypes *types = NULL;
 +        PIN_INFO info = {0};
 +        AM_MEDIA_TYPE *type;
 +        GUID category;
 +        DWORD r2;
 +
 +        IPin_QueryPinInfo(pin, &info);
 +        IBaseFilter_Release(info.pFilter);
 +
 +        if (info.dir != PINDIR_OUTPUT)
 +            goto next;
 +        if (IPin_QueryInterface(pin, &IID_IKsPropertySet, (void **) &p) != S_OK)
 +            goto next;
 +        if (IKsPropertySet_Get(p, &AMPROPSETID_Pin, AMPROPERTY_PIN_CATEGORY,
 +                               NULL, 0, &category, sizeof(GUID), &r2) != S_OK)
 +            goto next;
 +        if (!IsEqualGUID(&category, &PIN_CATEGORY_CAPTURE))
 +            goto next;
 +
 +        if (!ppin) {
 +            char *buf = dup_wchar_to_utf8(info.achName);
 +            av_log(avctx, AV_LOG_INFO, " Pin \"%s\"\n", buf);
 +            av_free(buf);
 +            dshow_cycle_formats(avctx, devtype, pin, NULL);
 +            goto next;
 +        }
 +        if (set_format) {
 +            dshow_cycle_formats(avctx, devtype, pin, &format_set);
 +            if (!format_set) {
 +                goto next;
 +            }
 +        }
 +        if (devtype == AudioDevice && ctx->audio_buffer_size) {
 +            if (dshow_set_audio_buffer_size(avctx, pin) < 0)
 +                goto next;
 +        }
 +
 +        if (IPin_EnumMediaTypes(pin, &types) != S_OK)
 +            goto next;
 +
 +        IEnumMediaTypes_Reset(types);
 +        while (!device_pin && IEnumMediaTypes_Next(types, 1, &type, NULL) == S_OK) {
 +            if (IsEqualGUID(&type->majortype, mediatype[devtype])) {
 +                device_pin = pin;
 +                goto next;
 +            }
 +            CoTaskMemFree(type);
 +        }
 +
 +next:
 +        if (types)
 +            IEnumMediaTypes_Release(types);
 +        if (p)
 +            IKsPropertySet_Release(p);
 +        if (device_pin != pin)
 +            IPin_Release(pin);
 +    }
 +
 +    IEnumPins_Release(pins);
 +
 +    if (ppin) {
 +        if (set_format && !format_set) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not set %s options\n", devtypename);
 +            return AVERROR(EIO);
 +        }
 +        if (!device_pin) {
 +            av_log(avctx, AV_LOG_ERROR,
 +                "Could not find output pin from %s capture device.\n", devtypename);
 +            return AVERROR(EIO);
 +        }
 +        *ppin = device_pin;
 +    }
 +
 +    return 0;
 +}
 +
 +/**
 + * List options for device with type devtype.
 + *
 + * @param devenum device enumerator used for accessing the device
 + */
 +static int
 +dshow_list_device_options(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                          enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    int r;
 +
 +    if ((r = dshow_cycle_devices(avctx, devenum, devtype, &device_filter)) < 0)
 +        return r;
 +    ctx->device_filter[devtype] = device_filter;
 +    if ((r = dshow_cycle_pins(avctx, devtype, device_filter, NULL)) < 0)
 +        return r;
 +
 +    return 0;
 +}
 +
 +static int
 +dshow_open_device(AVFormatContext *avctx, ICreateDevEnum *devenum,
 +                  enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IBaseFilter *device_filter = NULL;
 +    IGraphBuilder *graph = ctx->graph;
 +    IPin *device_pin = NULL;
 +    libAVPin *capture_pin = NULL;
 +    libAVFilter *capture_filter = NULL;
 +    int ret = AVERROR(EIO);
 +    int r;
 +
 +    const wchar_t *filter_name[2] = { L"Audio capture filter", L"Video capture filter" };
 +
 +    if ((r = dshow_cycle_devices(avctx, devenum, devtype, &device_filter)) < 0) {
 +        ret = r;
 +        goto error;
 +    }
 +
 +    ctx->device_filter [devtype] = device_filter;
 +
 +    r = IGraphBuilder_AddFilter(graph, device_filter, NULL);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not add device filter to graph.\n");
 +        goto error;
 +    }
 +
 +    if ((r = dshow_cycle_pins(avctx, devtype, device_filter, &device_pin)) < 0) {
 +        ret = r;
 +        goto error;
 +    }
 +    ctx->device_pin[devtype] = device_pin;
 +
 +    capture_filter = libAVFilter_Create(avctx, callback, devtype);
 +    if (!capture_filter) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create grabber filter.\n");
 +        goto error;
 +    }
 +    ctx->capture_filter[devtype] = capture_filter;
 +
 +    r = IGraphBuilder_AddFilter(graph, (IBaseFilter *) capture_filter,
 +                                filter_name[devtype]);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not add capture filter to graph\n");
 +        goto error;
 +    }
 +
 +    libAVPin_AddRef(capture_filter->pin);
 +    capture_pin = capture_filter->pin;
 +    ctx->capture_pin[devtype] = capture_pin;
 +
 +    r = IGraphBuilder_ConnectDirect(graph, device_pin, (IPin *) capture_pin, NULL);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not connect pins\n");
 +        goto error;
 +    }
 +
 +    ret = 0;
 +
 +error:
 +    return ret;
 +}
 +
 +static enum AVCodecID waveform_codec_id(enum AVSampleFormat sample_fmt)
 +{
 +    switch (sample_fmt) {
 +    case AV_SAMPLE_FMT_U8:  return AV_CODEC_ID_PCM_U8;
 +    case AV_SAMPLE_FMT_S16: return AV_CODEC_ID_PCM_S16LE;
 +    case AV_SAMPLE_FMT_S32: return AV_CODEC_ID_PCM_S32LE;
 +    default:                return AV_CODEC_ID_NONE; /* Should never happen. */
 +    }
 +}
 +
 +static enum AVSampleFormat sample_fmt_bits_per_sample(int bits)
 +{
 +    switch (bits) {
 +    case 8:  return AV_SAMPLE_FMT_U8;
 +    case 16: return AV_SAMPLE_FMT_S16;
 +    case 32: return AV_SAMPLE_FMT_S32;
 +    default: return AV_SAMPLE_FMT_NONE; /* Should never happen. */
 +    }
 +}
 +
 +static int
 +dshow_add_device(AVFormatContext *avctx,
 +                 enum dshowDeviceType devtype)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    AM_MEDIA_TYPE type;
 +    AVCodecContext *codec;
 +    AVStream *st;
 +    int ret = AVERROR(EIO);
 +
 +    st = avformat_new_stream(avctx, NULL);
 +    if (!st) {
 +        ret = AVERROR(ENOMEM);
 +        goto error;
 +    }
 +    st->id = devtype;
 +
 +    ctx->capture_filter[devtype]->stream_index = st->index;
 +
 +    libAVPin_ConnectionMediaType(ctx->capture_pin[devtype], &type);
 +
 +    codec = st->codec;
 +    if (devtype == VideoDevice) {
 +        BITMAPINFOHEADER *bih = NULL;
 +        AVRational time_base;
 +
 +        if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo)) {
 +            VIDEOINFOHEADER *v = (void *) type.pbFormat;
 +            time_base = (AVRational) { v->AvgTimePerFrame, 10000000 };
 +            bih = &v->bmiHeader;
 +        } else if (IsEqualGUID(&type.formattype, &FORMAT_VideoInfo2)) {
 +            VIDEOINFOHEADER2 *v = (void *) type.pbFormat;
 +            time_base = (AVRational) { v->AvgTimePerFrame, 10000000 };
 +            bih = &v->bmiHeader;
 +        }
 +        if (!bih) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
 +            goto error;
 +        }
 +
 +        codec->time_base  = time_base;
 +        codec->codec_type = AVMEDIA_TYPE_VIDEO;
 +        codec->width      = bih->biWidth;
 +        codec->height     = bih->biHeight;
 +        codec->pix_fmt    = dshow_pixfmt(bih->biCompression, bih->biBitCount);
 +        if (codec->pix_fmt == PIX_FMT_NONE) {
 +            codec->codec_id = dshow_codecid(bih->biCompression);
 +            if (codec->codec_id == AV_CODEC_ID_NONE) {
 +                av_log(avctx, AV_LOG_ERROR, "Unknown compression type. "
 +                                 "Please report verbose (-v 9) debug information.\n");
 +                dshow_read_close(avctx);
 +                return AVERROR_PATCHWELCOME;
 +            }
 +            codec->bits_per_coded_sample = bih->biBitCount;
 +        } else {
 +            codec->codec_id = AV_CODEC_ID_RAWVIDEO;
 +            if (bih->biCompression == BI_RGB || bih->biCompression == BI_BITFIELDS) {
 +                codec->bits_per_coded_sample = bih->biBitCount;
 +                codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);
 +                if (codec->extradata) {
 +                    codec->extradata_size = 9;
 +                    memcpy(codec->extradata, "BottomUp", 9);
 +                }
 +            }
 +        }
 +    } else {
 +        WAVEFORMATEX *fx = NULL;
 +
 +        if (IsEqualGUID(&type.formattype, &FORMAT_WaveFormatEx)) {
 +            fx = (void *) type.pbFormat;
 +        }
 +        if (!fx) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not get media type.\n");
 +            goto error;
 +        }
 +
 +        codec->codec_type  = AVMEDIA_TYPE_AUDIO;
 +        codec->sample_fmt  = sample_fmt_bits_per_sample(fx->wBitsPerSample);
 +        codec->codec_id    = waveform_codec_id(codec->sample_fmt);
 +        codec->sample_rate = fx->nSamplesPerSec;
 +        codec->channels    = fx->nChannels;
 +    }
 +
 +    avpriv_set_pts_info(st, 64, 1, 10000000);
 +
 +    ret = 0;
 +
 +error:
 +    return ret;
 +}
 +
 +static int parse_device_name(AVFormatContext *avctx)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    char **device_name = ctx->device_name;
 +    char *name = av_strdup(avctx->filename);
 +    char *tmp = name;
 +    int ret = 1;
 +    char *type;
 +
 +    while ((type = strtok(tmp, "="))) {
 +        char *token = strtok(NULL, ":");
 +        tmp = NULL;
 +
 +        if        (!strcmp(type, "video")) {
 +            device_name[0] = token;
 +        } else if (!strcmp(type, "audio")) {
 +            device_name[1] = token;
 +        } else {
 +            device_name[0] = NULL;
 +            device_name[1] = NULL;
 +            break;
 +        }
 +    }
 +
 +    if (!device_name[0] && !device_name[1]) {
 +        ret = 0;
 +    } else {
 +        if (device_name[0])
 +            device_name[0] = av_strdup(device_name[0]);
 +        if (device_name[1])
 +            device_name[1] = av_strdup(device_name[1]);
 +    }
 +
 +    av_free(name);
 +    return ret;
 +}
 +
 +static int dshow_read_header(AVFormatContext *avctx)
 +{
 +    struct dshow_ctx *ctx = avctx->priv_data;
 +    IGraphBuilder *graph = NULL;
 +    ICreateDevEnum *devenum = NULL;
 +    IMediaControl *control = NULL;
 +    int ret = AVERROR(EIO);
 +    int r;
 +
 +    if (!ctx->list_devices && !parse_device_name(avctx)) {
 +        av_log(avctx, AV_LOG_ERROR, "Malformed dshow input string.\n");
 +        goto error;
 +    }
 +
 +    if (ctx->video_size) {
 +        r = av_parse_video_size(&ctx->requested_width, &ctx->requested_height, ctx->video_size);
 +        if (r < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not parse video size '%s'.\n", ctx->video_size);
 +            goto error;
 +        }
 +    }
 +    if (ctx->framerate) {
 +        r = av_parse_video_rate(&ctx->requested_framerate, ctx->framerate);
 +        if (r < 0) {
 +            av_log(avctx, AV_LOG_ERROR, "Could not parse framerate '%s'.\n", ctx->framerate);
 +            goto error;
 +        }
 +    }
 +
 +    CoInitialize(0);
 +
 +    r = CoCreateInstance(&CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
 +                         &IID_IGraphBuilder, (void **) &graph);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create capture graph.\n");
 +        goto error;
 +    }
 +    ctx->graph = graph;
 +
 +    r = CoCreateInstance(&CLSID_SystemDeviceEnum, NULL, CLSCTX_INPROC_SERVER,
 +                         &IID_ICreateDevEnum, (void **) &devenum);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not enumerate system devices.\n");
 +        goto error;
 +    }
 +
 +    if (ctx->list_devices) {
 +        av_log(avctx, AV_LOG_INFO, "DirectShow video devices\n");
 +        dshow_cycle_devices(avctx, devenum, VideoDevice, NULL);
 +        av_log(avctx, AV_LOG_INFO, "DirectShow audio devices\n");
 +        dshow_cycle_devices(avctx, devenum, AudioDevice, NULL);
 +        ret = AVERROR_EXIT;
 +        goto error;
 +    }
 +    if (ctx->list_options) {
 +        if (ctx->device_name[VideoDevice])
 +            dshow_list_device_options(avctx, devenum, VideoDevice);
 +        if (ctx->device_name[AudioDevice])
 +            dshow_list_device_options(avctx, devenum, AudioDevice);
 +        ret = AVERROR_EXIT;
 +        goto error;
 +    }
 +
 +    if (ctx->device_name[VideoDevice]) {
 +        ret = dshow_open_device(avctx, devenum, VideoDevice);
 +        if (ret < 0)
 +            goto error;
 +        ret = dshow_add_device(avctx, VideoDevice);
 +        if (ret < 0)
 +            goto error;
 +    }
 +    if (ctx->device_name[AudioDevice]) {
 +        ret = dshow_open_device(avctx, devenum, AudioDevice);
 +        if (ret < 0)
 +            goto error;
 +        ret = dshow_add_device(avctx, AudioDevice);
 +        if (ret < 0)
 +            goto error;
 +    }
 +
 +    ctx->mutex = CreateMutex(NULL, 0, NULL);
 +    if (!ctx->mutex) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create Mutex\n");
 +        goto error;
 +    }
 +    ctx->event = CreateEvent(NULL, 1, 0, NULL);
 +    if (!ctx->event) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not create Event\n");
 +        goto error;
 +    }
 +
 +    r = IGraphBuilder_QueryInterface(graph, &IID_IMediaControl, (void **) &control);
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not get media control.\n");
 +        goto error;
 +    }
 +    ctx->control = control;
 +
 +    r = IMediaControl_Run(control);
 +    if (r == S_FALSE) {
 +        OAFilterState pfs;
 +        r = IMediaControl_GetState(control, 0, &pfs);
 +    }
 +    if (r != S_OK) {
 +        av_log(avctx, AV_LOG_ERROR, "Could not run filter\n");
 +        goto error;
 +    }
 +
 +    ret = 0;
 +
 +error:
 +
 +    if (ret < 0)
 +        dshow_read_close(avctx);
 +
 +    if (devenum)
 +        ICreateDevEnum_Release(devenum);
 +
 +    return ret;
 +}
 +
 +static int dshow_read_packet(AVFormatContext *s, AVPacket *pkt)
 +{
 +    struct dshow_ctx *ctx = s->priv_data;
 +    AVPacketList *pktl = NULL;
 +
 +    while (!pktl) {
 +        WaitForSingleObject(ctx->mutex, INFINITE);
 +        pktl = ctx->pktl;
 +        if (pktl) {
 +            *pkt = pktl->pkt;
 +            ctx->pktl = ctx->pktl->next;
 +            av_free(pktl);
 +            ctx->curbufsize -= pkt->size;
 +        }
 +        ResetEvent(ctx->event);
 +        ReleaseMutex(ctx->mutex);
 +        if (!pktl) {
 +            if (s->flags & AVFMT_FLAG_NONBLOCK) {
 +                return AVERROR(EAGAIN);
 +            } else {
 +                WaitForSingleObject(ctx->event, INFINITE);
 +            }
 +        }
 +    }
 +
 +    return pkt->size;
 +}
 +
 +#define OFFSET(x) offsetof(struct dshow_ctx, x)
 +#define DEC AV_OPT_FLAG_DECODING_PARAM
 +static const AVOption options[] = {
 +    { "video_size", "set video size given a string such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 +    { "framerate", "set video frame rate", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 +    { "sample_rate", "set audio sample rate", OFFSET(sample_rate), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "sample_size", "set audio sample size", OFFSET(sample_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 16, DEC },
 +    { "channels", "set number of audio channels, such as 1 or 2", OFFSET(channels), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "list_devices", "list available devices", OFFSET(list_devices), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, DEC, "list_devices" },
-     { "true", "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, DEC, "list_options" },
-     { "false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, DEC, "list_options" },
++    { "true", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, DEC, "list_devices" },
++    { "false", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, DEC, "list_devices" },
 +    { "list_options", "list available options for specified device", OFFSET(list_options), AV_OPT_TYPE_INT, {.dbl=0}, 0, 1, DEC, "list_options" },
++    { "true", "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, DEC, "list_options" },
++    { "false", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, DEC, "list_options" },
 +    { "video_device_number", "set video device number for devices with same name (starts at 0)", OFFSET(video_device_number), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "audio_device_number", "set audio device number for devices with same name (starts at 0)", OFFSET(audio_device_number), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { "audio_buffer_size", "set audio device buffer latency size in milliseconds (default is the device's default)", OFFSET(audio_buffer_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, DEC },
 +    { NULL },
 +};
 +
 +static const AVClass dshow_class = {
 +    .class_name = "DirectShow indev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVInputFormat ff_dshow_demuxer = {
 +    .name           = "dshow",
 +    .long_name      = NULL_IF_CONFIG_SMALL("DirectShow capture"),
 +    .priv_data_size = sizeof(struct dshow_ctx),
 +    .read_header    = dshow_read_header,
 +    .read_packet    = dshow_read_packet,
 +    .read_close     = dshow_read_close,
 +    .flags          = AVFMT_NOFILE,
 +    .priv_class     = &dshow_class,
 +};
Simple merge
index 25cdf10,0000000..f21499b
mode 100644,000000..100644
--- /dev/null
@@@ -1,466 -1,0 +1,466 @@@
-     { "auto",   "auto detect DV/HDV", 0, AV_OPT_TYPE_CONST, {.dbl = IEC61883_AUTO}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
-     { "dv",     "force device being treated as DV device", 0, AV_OPT_TYPE_CONST, {.dbl = IEC61883_DV},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
-     { "hdv" ,   "force device being treated as HDV device", 0, AV_OPT_TYPE_CONST, {.dbl = IEC61883_HDV},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
 +/*
 + * Copyright (c) 2012 Georg Lippitsch <georg.lippitsch@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +/**
 + * @file
 + * libiec61883 interface
 + */
 +
 +#include <sys/poll.h>
 +#include <libraw1394/raw1394.h>
 +#include <libavc1394/avc1394.h>
 +#include <libavc1394/rom1394.h>
 +#include <libiec61883/iec61883.h>
 +#include "libavformat/dv.h"
 +#include "libavformat/mpegts.h"
 +#include "libavutil/opt.h"
 +#include "avdevice.h"
 +
 +#define THREADS HAVE_PTHREADS
 +
 +#if THREADS
 +#include <pthread.h>
 +#endif
 +
 +#define MOTDCT_SPEC_ID      0x00005068
 +#define IEC61883_AUTO       0
 +#define IEC61883_DV         1
 +#define IEC61883_HDV        2
 +
 +/**
 + * For DV, one packet corresponds exactly to one frame.
 + * For HDV, these are MPEG2 transport stream packets.
 + * The queue is implemented as linked list.
 + */
 +typedef struct DVPacket {
 +    uint8_t *buf;                       ///< actual buffer data
 +    int len;                            ///< size of buffer allocated
 +    struct DVPacket *next;              ///< next DVPacket
 +} DVPacket;
 +
 +struct iec61883_data {
 +    AVClass *class;
 +    raw1394handle_t raw1394;            ///< handle for libraw1394
 +    iec61883_dv_fb_t iec61883_dv;       ///< handle for libiec61883 when used with DV
 +    iec61883_mpeg2_t iec61883_mpeg2;    ///< handle for libiec61883 when used with HDV
 +
 +    DVDemuxContext *dv_demux;           ///< generic DV muxing/demuxing context
 +    MpegTSContext *mpeg_demux;          ///< generic HDV muxing/demuxing context
 +
 +    DVPacket *queue_first;              ///< first element of packet queue
 +    DVPacket *queue_last;               ///< last element of packet queue
 +
 +    int packets;                        ///< Number of packets queued
 +    int max_packets;                    ///< Max. number of packets in queue
 +
 +    int bandwidth;                      ///< returned by libiec61883
 +    int channel;                        ///< returned by libiec61883
 +    int input_port;                     ///< returned by libiec61883
 +    int type;                           ///< Stream type, to distinguish DV/HDV
 +    int node;                           ///< returned by libiec61883
 +    int output_port;                    ///< returned by libiec61883
 +    int thread_loop;                    ///< Condition for thread while-loop
 +    int receiving;                      ///< True as soon data from device available
 +    int receive_error;                  ///< Set in receive task in case of error
 +    int eof;                            ///< True as soon as no more data available
 +
 +    struct pollfd raw1394_poll;         ///< to poll for new data from libraw1394
 +
 +    /** Parse function for DV/HDV differs, so this is set before packets arrive */
 +    int (*parse_queue)(struct iec61883_data *dv, AVPacket *pkt);
 +
 +#if THREADS
 +    pthread_t receive_task_thread;
 +    pthread_mutex_t mutex;
 +    pthread_cond_t cond;
 +#endif
 +};
 +
 +static int iec61883_callback(unsigned char *data, int length,
 +                             int complete, void *callback_data)
 +{
 +    struct iec61883_data *dv = callback_data;
 +    DVPacket *packet;
 +    int ret;
 +
 +#ifdef THREADS
 +    pthread_mutex_lock(&dv->mutex);
 +#endif
 +
 +    if (dv->packets >= dv->max_packets) {
 +        av_log(NULL, AV_LOG_ERROR, "DV packet queue overrun, dropping.\n");
 +        ret = 0;
 +        goto exit;
 +    }
 +
 +    packet = av_mallocz(sizeof(*packet));
 +    if (!packet) {
 +        ret = -1;
 +        goto exit;
 +    }
 +
 +    packet->buf = av_malloc(length);
 +    if (!packet->buf) {
 +        ret = -1;
 +        goto exit;
 +    }
 +    packet->len = length;
 +
 +    memcpy(packet->buf, data, length);
 +
 +    if (dv->queue_first) {
 +        dv->queue_last->next = packet;
 +        dv->queue_last = packet;
 +    } else {
 +        dv->queue_first = packet;
 +        dv->queue_last = packet;
 +    }
 +    dv->packets++;
 +
 +    ret = 0;
 +
 +exit:
 +#ifdef THREADS
 +    pthread_cond_signal(&dv->cond);
 +    pthread_mutex_unlock(&dv->mutex);
 +#endif
 +    return ret;
 +}
 +
 +static void *iec61883_receive_task(void *opaque)
 +{
 +    struct iec61883_data *dv = (struct iec61883_data *)opaque;
 +    int result;
 +
 +#ifdef THREADS
 +    while (dv->thread_loop)
 +#endif
 +    {
 +        while ((result = poll(&dv->raw1394_poll, 1, 200)) < 0) {
 +            if (!(errno == EAGAIN || errno == EINTR)) {
 +                av_log(NULL, AV_LOG_ERROR, "Raw1394 poll error occurred.\n");
 +                dv->receive_error = AVERROR(EIO);
 +                return NULL;
 +            }
 +        }
 +        if (result > 0 && ((dv->raw1394_poll.revents & POLLIN)
 +                           || (dv->raw1394_poll.revents & POLLPRI))) {
 +            dv->receiving = 1;
 +            raw1394_loop_iterate(dv->raw1394);
 +        } else if (dv->receiving) {
 +            av_log(NULL, AV_LOG_ERROR, "No more input data available\n");
 +#ifdef THREADS
 +            pthread_mutex_lock(&dv->mutex);
 +            dv->eof = 1;
 +            pthread_cond_signal(&dv->cond);
 +            pthread_mutex_unlock(&dv->mutex);
 +#else
 +            dv->eof = 1;
 +#endif
 +            return NULL;
 +        }
 +    }
 +
 +    return NULL;
 +}
 +
 +static int iec61883_parse_queue_dv(struct iec61883_data *dv, AVPacket *pkt)
 +{
 +    DVPacket *packet;
 +    int size;
 +
 +    size = avpriv_dv_get_packet(dv->dv_demux, pkt);
 +    if (size > 0)
 +        return size;
 +
 +    packet = dv->queue_first;
 +    if (!packet)
 +        return -1;
 +
 +    size = avpriv_dv_produce_packet(dv->dv_demux, pkt,
 +                                    packet->buf, packet->len, -1);
 +    pkt->destruct = av_destruct_packet;
 +    dv->queue_first = packet->next;
 +    av_free(packet);
 +    dv->packets--;
 +
 +    if (size > 0)
 +        return size;
 +
 +    return -1;
 +}
 +
 +static int iec61883_parse_queue_hdv(struct iec61883_data *dv, AVPacket *pkt)
 +{
 +    DVPacket *packet;
 +    int size;
 +
 +    while (dv->queue_first) {
 +        packet = dv->queue_first;
 +        size = ff_mpegts_parse_packet(dv->mpeg_demux, pkt, packet->buf,
 +                                      packet->len);
 +        dv->queue_first = packet->next;
 +        av_free(packet->buf);
 +        av_free(packet);
 +        dv->packets--;
 +
 +        if (size > 0)
 +            return size;
 +    }
 +
 +    return -1;
 +}
 +
 +static int iec61883_read_header(AVFormatContext *context)
 +{
 +    struct iec61883_data *dv = context->priv_data;
 +    struct raw1394_portinfo pinf[16];
 +    rom1394_directory rom_dir;
 +    char *endptr;
 +    int inport;
 +    int nb_ports;
 +    int port = -1;
 +    int response;
 +    int i, j = 0;
 +
 +    dv->input_port = -1;
 +    dv->output_port = -1;
 +    dv->channel = -1;
 +
 +    dv->raw1394 = raw1394_new_handle();
 +
 +    if (!dv->raw1394) {
 +        av_log(context, AV_LOG_ERROR, "Failed to open IEEE1394 interface.\n");
 +        return AVERROR(EIO);
 +    }
 +
 +    if ((nb_ports = raw1394_get_port_info(dv->raw1394, pinf, 16)) < 0) {
 +        av_log(context, AV_LOG_ERROR, "Failed to get number of IEEE1394 ports.\n");
 +        goto fail;
 +    }
 +
 +    inport = strtol(context->filename, &endptr, 10);
 +    if (endptr != context->filename && *endptr == '\0') {
 +        av_log(context, AV_LOG_INFO, "Selecting IEEE1394 port: %d\n", inport);
 +        j = inport;
 +        nb_ports = inport + 1;
 +    } else if (strcmp(context->filename, "auto")) {
 +        av_log(context, AV_LOG_ERROR, "Invalid input \"%s\", you should specify "
 +               "\"auto\" for auto-detection, or the port number.\n", context->filename);
 +        goto fail;
 +    }
 +
 +    /* Select first AV/C tape recorder player node */
 +
 +    for (; j < nb_ports && port==-1; ++j) {
 +        if (raw1394_set_port(dv->raw1394, j)) {
 +            av_log(context, AV_LOG_ERROR, "Failed setting IEEE1394 port.\n");
 +            goto fail;
 +        }
 +        for (i=0; i<raw1394_get_nodecount(dv->raw1394); ++i) {
 +            if (rom1394_get_directory(dv->raw1394, i, &rom_dir) < 0)
 +                continue;
 +            if (((rom1394_get_node_type(&rom_dir) == ROM1394_NODE_TYPE_AVC) &&
 +                 avc1394_check_subunit_type(dv->raw1394, i, AVC1394_SUBUNIT_TYPE_VCR)) ||
 +                (rom_dir.unit_spec_id == MOTDCT_SPEC_ID)) {
 +                rom1394_free_directory(&rom_dir);
 +                dv->node = i;
 +                port = j;
 +                break;
 +            }
 +            rom1394_free_directory(&rom_dir);
 +        }
 +    }
 +
 +    if (port == -1) {
 +        av_log(context, AV_LOG_ERROR, "No AV/C devices found.\n");
 +        goto fail;
 +    }
 +
 +    /* Find out if device is DV or HDV */
 +
 +    if (dv->type == IEC61883_AUTO) {
 +        response = avc1394_transaction(dv->raw1394, dv->node,
 +                                       AVC1394_CTYPE_STATUS |
 +                                       AVC1394_SUBUNIT_TYPE_TAPE_RECORDER |
 +                                       AVC1394_SUBUNIT_ID_0 |
 +                                       AVC1394_VCR_COMMAND_OUTPUT_SIGNAL_MODE |
 +                                       0xFF, 2);
 +        response = AVC1394_GET_OPERAND0(response);
 +        dv->type = (response == 0x10 || response == 0x90 || response == 0x1A || response == 0x9A) ?
 +            IEC61883_HDV : IEC61883_DV;
 +    }
 +
 +    /* Connect to device, and do initialization */
 +
 +    dv->channel = iec61883_cmp_connect(dv->raw1394, dv->node, &dv->output_port,
 +                                       raw1394_get_local_id(dv->raw1394),
 +                                       &dv->input_port, &dv->bandwidth);
 +
 +    if (dv->channel < 0)
 +        dv->channel = 63;
 +
 +    if (!dv->max_packets)
 +        dv->max_packets = 100;
 +
 +    if (dv->type == IEC61883_HDV) {
 +
 +        /* Init HDV receive */
 +
 +        avformat_new_stream(context, NULL);
 +
 +        dv->mpeg_demux = ff_mpegts_parse_open(context);
 +        if (!dv->mpeg_demux)
 +            goto fail;
 +
 +        dv->parse_queue = iec61883_parse_queue_hdv;
 +
 +        dv->iec61883_mpeg2 = iec61883_mpeg2_recv_init(dv->raw1394,
 +                                                      (iec61883_mpeg2_recv_t)iec61883_callback,
 +                                                      dv);
 +
 +        dv->max_packets *= 766;
 +    } else {
 +
 +        /* Init DV receive */
 +
 +        dv->dv_demux = avpriv_dv_init_demux(context);
 +        if (!dv->dv_demux)
 +            goto fail;
 +
 +        dv->parse_queue = iec61883_parse_queue_dv;
 +
 +        dv->iec61883_dv = iec61883_dv_fb_init(dv->raw1394, iec61883_callback, dv);
 +    }
 +
 +    dv->raw1394_poll.fd = raw1394_get_fd(dv->raw1394);
 +    dv->raw1394_poll.events = POLLIN | POLLERR | POLLHUP | POLLPRI;
 +
 +    /* Actually start receiving */
 +
 +    if (dv->type == IEC61883_HDV)
 +        iec61883_mpeg2_recv_start(dv->iec61883_mpeg2, dv->channel);
 +    else
 +        iec61883_dv_fb_start(dv->iec61883_dv, dv->channel);
 +
 +#if THREADS
 +    dv->thread_loop = 1;
 +    pthread_mutex_init(&dv->mutex, NULL);
 +    pthread_cond_init(&dv->cond, NULL);
 +    pthread_create(&dv->receive_task_thread, NULL, iec61883_receive_task, dv);
 +#endif
 +
 +    return 0;
 +
 +fail:
 +    raw1394_destroy_handle(dv->raw1394);
 +    return AVERROR(EIO);
 +}
 +
 +static int iec61883_read_packet(AVFormatContext *context, AVPacket *pkt)
 +{
 +    struct iec61883_data *dv = context->priv_data;
 +    int size;
 +
 +    /**
 +     * Try to parse frames from queue
 +     */
 +
 +#ifdef THREADS
 +    pthread_mutex_lock(&dv->mutex);
 +    while ((size = dv->parse_queue(dv, pkt)) == -1)
 +        if (!dv->eof)
 +            pthread_cond_wait(&dv->cond, &dv->mutex);
 +        else
 +            break;
 +    pthread_mutex_unlock(&dv->mutex);
 +#else
 +    int result;
 +    while ((size = dv->parse_queue(dv, pkt)) == -1) {
 +        iec61883_receive_task((void *)dv);
 +        if (dv->receive_error)
 +            return dv->receive_error;
 +    }
 +#endif
 +
 +    return size;
 +}
 +
 +static int iec61883_close(AVFormatContext *context)
 +{
 +    struct iec61883_data *dv = context->priv_data;
 +
 +#if THREADS
 +    dv->thread_loop = 0;
 +    pthread_join(dv->receive_task_thread, NULL);
 +    pthread_cond_destroy(&dv->cond);
 +    pthread_mutex_destroy(&dv->mutex);
 +#endif
 +
 +    if (dv->type == IEC61883_HDV) {
 +        iec61883_mpeg2_recv_stop(dv->iec61883_mpeg2);
 +        iec61883_mpeg2_close(dv->iec61883_mpeg2);
 +        ff_mpegts_parse_close(dv->mpeg_demux);
 +    } else {
 +        iec61883_dv_fb_stop(dv->iec61883_dv);
 +        iec61883_dv_fb_close(dv->iec61883_dv);
 +    }
 +    while (dv->queue_first) {
 +        DVPacket *packet = dv->queue_first;
 +        dv->queue_first = packet->next;
 +        av_free(packet->buf);
 +        av_free(packet);
 +    }
 +
 +    iec61883_cmp_disconnect(dv->raw1394, dv->node, dv->output_port,
 +                            raw1394_get_local_id(dv->raw1394),
 +                            dv->input_port, dv->channel, dv->bandwidth);
 +
 +    raw1394_destroy_handle(dv->raw1394);
 +
 +    return 0;
 +}
 +
 +static const AVOption options[] = {
 +    { "dvtype", "override autodetection of DV/HDV", offsetof(struct iec61883_data, type), AV_OPT_TYPE_INT, {.dbl = IEC61883_AUTO}, IEC61883_AUTO, IEC61883_HDV, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
++    { "auto",   "auto detect DV/HDV", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_AUTO}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
++    { "dv",     "force device being treated as DV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_DV},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
++    { "hdv" ,   "force device being treated as HDV device", 0, AV_OPT_TYPE_CONST, {.i64 = IEC61883_HDV},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "dvtype" },
 +    { "dvbuffer", "set queue buffer size (in packets)", offsetof(struct iec61883_data, max_packets), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_DECODING_PARAM },
 +    { NULL },
 +};
 +
 +static const AVClass iec61883_class = {
 +    .class_name = "iec61883 indev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVInputFormat ff_iec61883_demuxer = {
 +    .name           = "iec61883",
 +    .long_name      = NULL_IF_CONFIG_SMALL("libiec61883 (new DV1394) A/V input device"),
 +    .priv_data_size = sizeof(struct iec61883_data),
 +    .read_header    = iec61883_read_header,
 +    .read_packet    = iec61883_read_packet,
 +    .read_close     = iec61883_close,
 +    .flags          = AVFMT_NOFILE,
 +    .priv_class     = &iec61883_class,
 +};
Simple merge
index 29db2d5,0000000..a2f4ea1
mode 100644,000000..100644
--- /dev/null
@@@ -1,251 -1,0 +1,251 @@@
-     {"true",  "", 0, AV_OPT_TYPE_CONST, {.dbl=1}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
-     {"false", "", 0, AV_OPT_TYPE_CONST, {.dbl=0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
 +/*
 + * Copyright (c) 2011 Jonathan Baldwin
 + *
 + * This file is part of FFmpeg.
 + *
 + * Permission to use, copy, modify, and/or distribute this software for any
 + * purpose with or without fee is hereby granted, provided that the above
 + * copyright notice and this permission notice appear in all copies.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
 + * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 + * AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
 + * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 + * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 + * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 + * PERFORMANCE OF THIS SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * OpenAL 1.1 capture device for libavdevice
 + **/
 +
 +#include <AL/al.h>
 +#include <AL/alc.h>
 +
 +#include "libavutil/opt.h"
 +#include "libavformat/internal.h"
 +#include "avdevice.h"
 +
 +typedef struct {
 +    AVClass *class;
 +    /** OpenAL capture device context. **/
 +    ALCdevice *device;
 +    /** The number of channels in the captured audio. **/
 +    int channels;
 +    /** The sample rate (in Hz) of the captured audio. **/
 +    int sample_rate;
 +    /** The sample size (in bits) of the captured audio. **/
 +    int sample_size;
 +    /** The OpenAL sample format of the captured audio. **/
 +    ALCenum sample_format;
 +    /** The number of bytes between two consecutive samples of the same channel/component. **/
 +    ALCint sample_step;
 +    /** If true, print a list of capture devices on this system and exit. **/
 +    int list_devices;
 +} al_data;
 +
 +typedef struct {
 +    ALCenum al_fmt;
 +    enum AVCodecID codec_id;
 +    int channels;
 +} al_format_info;
 +
 +#define LOWEST_AL_FORMAT FFMIN(FFMIN(AL_FORMAT_MONO8,AL_FORMAT_MONO16),FFMIN(AL_FORMAT_STEREO8,AL_FORMAT_STEREO16))
 +
 +/**
 + * Get information about an AL_FORMAT value.
 + * @param al_fmt the AL_FORMAT value to find information about.
 + * @return A pointer to a structure containing information about the AL_FORMAT value.
 + */
 +static inline al_format_info* get_al_format_info(ALCenum al_fmt)
 +{
 +    static al_format_info info_table[] = {
 +        [AL_FORMAT_MONO8-LOWEST_AL_FORMAT]    = {AL_FORMAT_MONO8, AV_CODEC_ID_PCM_U8, 1},
 +        [AL_FORMAT_MONO16-LOWEST_AL_FORMAT]   = {AL_FORMAT_MONO16, AV_NE (AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE), 1},
 +        [AL_FORMAT_STEREO8-LOWEST_AL_FORMAT]  = {AL_FORMAT_STEREO8, AV_CODEC_ID_PCM_U8, 2},
 +        [AL_FORMAT_STEREO16-LOWEST_AL_FORMAT] = {AL_FORMAT_STEREO16, AV_NE (AV_CODEC_ID_PCM_S16BE, AV_CODEC_ID_PCM_S16LE), 2},
 +    };
 +
 +    return &info_table[al_fmt-LOWEST_AL_FORMAT];
 +}
 +
 +/**
 + * Get the OpenAL error code, translated into an av/errno error code.
 + * @param device The ALC device to check for errors.
 + * @param error_msg_ret A pointer to a char* in which to return the error message, or NULL if desired.
 + * @return The error code, or 0 if there is no error.
 + */
 +static inline int al_get_error(ALCdevice *device, const char** error_msg_ret)
 +{
 +    ALCenum error = alcGetError(device);
 +    if (error_msg_ret)
 +        *error_msg_ret = (const char*) alcGetString(device, error);
 +    switch (error) {
 +    case ALC_NO_ERROR:
 +        return 0;
 +    case ALC_INVALID_DEVICE:
 +        return AVERROR(ENODEV);
 +        break;
 +    case ALC_INVALID_CONTEXT:
 +    case ALC_INVALID_ENUM:
 +    case ALC_INVALID_VALUE:
 +        return AVERROR(EINVAL);
 +        break;
 +    case ALC_OUT_OF_MEMORY:
 +        return AVERROR(ENOMEM);
 +        break;
 +    default:
 +        return AVERROR(EIO);
 +    }
 +}
 +
 +/**
 + * Print out a list of OpenAL capture devices on this system.
 + */
 +static inline void print_al_capture_devices(void *log_ctx)
 +{
 +    const char *devices;
 +
 +    if (!(devices = alcGetString(NULL, ALC_CAPTURE_DEVICE_SPECIFIER)))
 +        return;
 +
 +    av_log(log_ctx, AV_LOG_INFO, "List of OpenAL capture devices on this system:\n");
 +
 +    for (; *devices != '\0'; devices += strlen(devices) + 1)
 +        av_log(log_ctx, AV_LOG_INFO, "  %s\n", devices);
 +}
 +
 +static int read_header(AVFormatContext *ctx)
 +{
 +    al_data *ad = ctx->priv_data;
 +    static const ALCenum sample_formats[2][2] = {
 +        { AL_FORMAT_MONO8,  AL_FORMAT_STEREO8  },
 +        { AL_FORMAT_MONO16, AL_FORMAT_STEREO16 }
 +    };
 +    int error = 0;
 +    const char *error_msg;
 +    AVStream *st = NULL;
 +    AVCodecContext *codec = NULL;
 +
 +    if (ad->list_devices) {
 +        print_al_capture_devices(ctx);
 +        return AVERROR_EXIT;
 +    }
 +
 +    ad->sample_format = sample_formats[ad->sample_size/8-1][ad->channels-1];
 +
 +    /* Open device for capture */
 +    ad->device =
 +        alcCaptureOpenDevice(ctx->filename[0] ? ctx->filename : NULL,
 +                             ad->sample_rate,
 +                             ad->sample_format,
 +                             ad->sample_rate); /* Maximum 1 second of sample data to be read at once */
 +
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    /* Create stream */
 +    if (!(st = avformat_new_stream(ctx, NULL))) {
 +        error = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    /* We work in microseconds */
 +    avpriv_set_pts_info(st, 64, 1, 1000000);
 +
 +    /* Set codec parameters */
 +    codec = st->codec;
 +    codec->codec_type = AVMEDIA_TYPE_AUDIO;
 +    codec->sample_rate = ad->sample_rate;
 +    codec->channels = get_al_format_info(ad->sample_format)->channels;
 +    codec->codec_id = get_al_format_info(ad->sample_format)->codec_id;
 +
 +    /* This is needed to read the audio data */
 +    ad->sample_step = (av_get_bits_per_sample(get_al_format_info(ad->sample_format)->codec_id) *
 +                       get_al_format_info(ad->sample_format)->channels) / 8;
 +
 +    /* Finally, start the capture process */
 +    alcCaptureStart(ad->device);
 +
 +    return 0;
 +
 +fail:
 +    /* Handle failure */
 +    if (ad->device)
 +        alcCaptureCloseDevice(ad->device);
 +    if (error_msg)
 +        av_log(ctx, AV_LOG_ERROR, "Cannot open device: %s\n", error_msg);
 +    return error;
 +}
 +
 +static int read_packet(AVFormatContext* ctx, AVPacket *pkt)
 +{
 +    al_data *ad = ctx->priv_data;
 +    int error=0;
 +    const char *error_msg;
 +    ALCint nb_samples;
 +
 +    /* Get number of samples available */
 +    alcGetIntegerv(ad->device, ALC_CAPTURE_SAMPLES, (ALCsizei) sizeof(ALCint), &nb_samples);
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    /* Create a packet of appropriate size */
 +    av_new_packet(pkt, nb_samples*ad->sample_step);
 +    pkt->pts = av_gettime();
 +
 +    /* Fill the packet with the available samples */
 +    alcCaptureSamples(ad->device, pkt->data, nb_samples);
 +    if (error = al_get_error(ad->device, &error_msg)) goto fail;
 +
 +    return pkt->size;
 +fail:
 +    /* Handle failure */
 +    if (pkt->data)
 +        av_destruct_packet(pkt);
 +    if (error_msg)
 +        av_log(ctx, AV_LOG_ERROR, "Error: %s\n", error_msg);
 +    return error;
 +}
 +
 +static int read_close(AVFormatContext* ctx)
 +{
 +    al_data *ad = ctx->priv_data;
 +
 +    if (ad->device) {
 +        alcCaptureStop(ad->device);
 +        alcCaptureCloseDevice(ad->device);
 +    }
 +    return 0;
 +}
 +
 +#define OFFSET(x) offsetof(al_data, x)
 +
 +static const AVOption options[] = {
 +    {"channels", "set number of channels",     OFFSET(channels),     AV_OPT_TYPE_INT, {.dbl=2},     1, 2,      AV_OPT_FLAG_DECODING_PARAM },
 +    {"sample_rate", "set sample rate",         OFFSET(sample_rate),  AV_OPT_TYPE_INT, {.dbl=44100}, 1, 192000, AV_OPT_FLAG_DECODING_PARAM },
 +    {"sample_size", "set sample size",         OFFSET(sample_size),  AV_OPT_TYPE_INT, {.dbl=16},    8, 16,     AV_OPT_FLAG_DECODING_PARAM },
 +    {"list_devices", "list available devices", OFFSET(list_devices), AV_OPT_TYPE_INT, {.dbl=0},     0, 1,      AV_OPT_FLAG_DECODING_PARAM, "list_devices"  },
++    {"true",  "", 0, AV_OPT_TYPE_CONST, {.i64=1}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
++    {"false", "", 0, AV_OPT_TYPE_CONST, {.i64=0}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "list_devices" },
 +    {NULL},
 +};
 +
 +static const AVClass class = {
 +    .class_name = "openal",
 +    .item_name = av_default_item_name,
 +    .option = options,
 +    .version = LIBAVUTIL_VERSION_INT
 +};
 +
 +AVInputFormat ff_openal_demuxer = {
 +    .name = "openal",
 +    .long_name = NULL_IF_CONFIG_SMALL("OpenAL audio capture device"),
 +    .priv_data_size = sizeof(al_data),
 +    .read_probe = NULL,
 +    .read_header = read_header,
 +    .read_packet = read_packet,
 +    .read_close = read_close,
 +    .flags = AVFMT_NOFILE,
 +    .priv_class = &class
 +};
index 63047f9,0000000..df48cb9
mode 100644,000000..100644
--- /dev/null
@@@ -1,363 -1,0 +1,363 @@@
-     { "PAL",   "", 0, AV_OPT_TYPE_CONST, {.dbl = VIDEO_MODE_PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "SECAM", "", 0, AV_OPT_TYPE_CONST, {.dbl = VIDEO_MODE_SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
-     { "NTSC",  "", 0, AV_OPT_TYPE_CONST, {.dbl = VIDEO_MODE_NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
 +/*
 + * Linux video grab interface
 + * Copyright (c) 2000,2001 Fabrice Bellard
 + *
 + * 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 "avdevice.h"
 +
 +#undef __STRICT_ANSI__ //workaround due to broken kernel headers
 +#include "config.h"
 +#include "libavutil/rational.h"
 +#include "libavutil/imgutils.h"
 +#include "libavutil/log.h"
 +#include "libavutil/opt.h"
 +#include "libavformat/internal.h"
 +#include "libavcodec/dsputil.h"
 +#include <unistd.h>
 +#include <fcntl.h>
 +#include <sys/ioctl.h>
 +#include <sys/mman.h>
 +#include <sys/time.h>
 +#define _LINUX_TIME_H 1
 +#include <linux/videodev.h>
 +#include <time.h>
 +#include "avdevice.h"
 +
 +typedef struct {
 +    AVClass *class;
 +    int fd;
 +    int frame_format; /* see VIDEO_PALETTE_xxx */
 +    int use_mmap;
 +    AVRational time_base;
 +    int64_t time_frame;
 +    int frame_size;
 +    struct video_capability video_cap;
 +    struct video_audio audio_saved;
 +    struct video_window video_win;
 +    uint8_t *video_buf;
 +    struct video_mbuf gb_buffers;
 +    struct video_mmap gb_buf;
 +    int gb_frame;
 +    int standard;
 +} VideoData;
 +
 +static const struct {
 +    int palette;
 +    int depth;
 +    enum PixelFormat pix_fmt;
 +} video_formats [] = {
 +    {.palette = VIDEO_PALETTE_YUV420P, .depth = 12, .pix_fmt = PIX_FMT_YUV420P },
 +    {.palette = VIDEO_PALETTE_YUV422,  .depth = 16, .pix_fmt = PIX_FMT_YUYV422 },
 +    {.palette = VIDEO_PALETTE_UYVY,    .depth = 16, .pix_fmt = PIX_FMT_UYVY422 },
 +    {.palette = VIDEO_PALETTE_YUYV,    .depth = 16, .pix_fmt = PIX_FMT_YUYV422 },
 +    /* NOTE: v4l uses BGR24, not RGB24 */
 +    {.palette = VIDEO_PALETTE_RGB24,   .depth = 24, .pix_fmt = PIX_FMT_BGR24   },
 +    {.palette = VIDEO_PALETTE_RGB565,  .depth = 16, .pix_fmt = PIX_FMT_BGR565  },
 +    {.palette = VIDEO_PALETTE_GREY,    .depth = 8,  .pix_fmt = PIX_FMT_GRAY8   },
 +};
 +
 +
 +static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap)
 +{
 +    VideoData *s = s1->priv_data;
 +    AVStream *st;
 +    int video_fd;
 +    int desired_palette, desired_depth;
 +    struct video_tuner tuner;
 +    struct video_audio audio;
 +    struct video_picture pict;
 +    int j;
 +    int vformat_num = FF_ARRAY_ELEMS(video_formats);
 +
 +    av_log(s1, AV_LOG_WARNING, "V4L input device is deprecated and will be removed in the next release.");
 +
 +    if (ap->time_base.den <= 0) {
 +        av_log(s1, AV_LOG_ERROR, "Wrong time base (%d)\n", ap->time_base.den);
 +        return -1;
 +    }
 +    s->time_base = ap->time_base;
 +
 +    s->video_win.width = ap->width;
 +    s->video_win.height = ap->height;
 +
 +    st = avformat_new_stream(s1, NULL);
 +    if (!st)
 +        return AVERROR(ENOMEM);
 +    avpriv_set_pts_info(st, 64, 1, 1000000); /* 64 bits pts in us */
 +
 +    video_fd = open(s1->filename, O_RDWR);
 +    if (video_fd < 0) {
 +        av_log(s1, AV_LOG_ERROR, "%s: %s\n", s1->filename, strerror(errno));
 +        goto fail;
 +    }
 +
 +    if (ioctl(video_fd, VIDIOCGCAP, &s->video_cap) < 0) {
 +        av_log(s1, AV_LOG_ERROR, "VIDIOCGCAP: %s\n", strerror(errno));
 +        goto fail;
 +    }
 +
 +    if (!(s->video_cap.type & VID_TYPE_CAPTURE)) {
 +        av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not handle capture\n");
 +        goto fail;
 +    }
 +
 +    /* no values set, autodetect them */
 +    if (s->video_win.width <= 0 || s->video_win.height <= 0) {
 +        if (ioctl(video_fd, VIDIOCGWIN, &s->video_win, sizeof(s->video_win)) < 0) {
 +            av_log(s1, AV_LOG_ERROR, "VIDIOCGWIN: %s\n", strerror(errno));
 +            goto fail;
 +        }
 +    }
 +
 +    if(av_image_check_size(s->video_win.width, s->video_win.height, 0, s1) < 0)
 +        return -1;
 +
 +    desired_palette = -1;
 +    desired_depth = -1;
 +    for (j = 0; j < vformat_num; j++) {
 +        if (ap->pix_fmt == video_formats[j].pix_fmt) {
 +            desired_palette = video_formats[j].palette;
 +            desired_depth = video_formats[j].depth;
 +            break;
 +        }
 +    }
 +
 +    /* set tv standard */
 +    if (!ioctl(video_fd, VIDIOCGTUNER, &tuner)) {
 +        tuner.mode = s->standard;
 +        ioctl(video_fd, VIDIOCSTUNER, &tuner);
 +    }
 +
 +    /* unmute audio */
 +    audio.audio = 0;
 +    ioctl(video_fd, VIDIOCGAUDIO, &audio);
 +    memcpy(&s->audio_saved, &audio, sizeof(audio));
 +    audio.flags &= ~VIDEO_AUDIO_MUTE;
 +    ioctl(video_fd, VIDIOCSAUDIO, &audio);
 +
 +    ioctl(video_fd, VIDIOCGPICT, &pict);
 +    av_dlog(s1, "v4l: colour=%d hue=%d brightness=%d constrast=%d whiteness=%d\n",
 +            pict.colour, pict.hue, pict.brightness, pict.contrast, pict.whiteness);
 +    /* try to choose a suitable video format */
 +    pict.palette = desired_palette;
 +    pict.depth= desired_depth;
 +    if (desired_palette == -1 || ioctl(video_fd, VIDIOCSPICT, &pict) < 0) {
 +        for (j = 0; j < vformat_num; j++) {
 +            pict.palette = video_formats[j].palette;
 +            pict.depth = video_formats[j].depth;
 +            if (-1 != ioctl(video_fd, VIDIOCSPICT, &pict))
 +                break;
 +        }
 +        if (j >= vformat_num)
 +            goto fail1;
 +    }
 +
 +    if (ioctl(video_fd, VIDIOCGMBUF, &s->gb_buffers) < 0) {
 +        /* try to use read based access */
 +        int val;
 +
 +        s->video_win.x = 0;
 +        s->video_win.y = 0;
 +        s->video_win.chromakey = -1;
 +        s->video_win.flags = 0;
 +
 +        if (ioctl(video_fd, VIDIOCSWIN, s->video_win) < 0) {
 +            av_log(s1, AV_LOG_ERROR, "VIDIOCSWIN: %s\n", strerror(errno));
 +            goto fail;
 +        }
 +
 +        s->frame_format = pict.palette;
 +
 +        val = 1;
 +        if (ioctl(video_fd, VIDIOCCAPTURE, &val) < 0) {
 +            av_log(s1, AV_LOG_ERROR, "VIDIOCCAPTURE: %s\n", strerror(errno));
 +            goto fail;
 +        }
 +
 +        s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
 +        s->use_mmap = 0;
 +    } else {
 +        s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_SHARED, video_fd, 0);
 +        if ((unsigned char*)-1 == s->video_buf) {
 +            s->video_buf = mmap(0, s->gb_buffers.size, PROT_READ|PROT_WRITE, MAP_PRIVATE, video_fd, 0);
 +            if ((unsigned char*)-1 == s->video_buf) {
 +                av_log(s1, AV_LOG_ERROR, "mmap: %s\n", strerror(errno));
 +                goto fail;
 +            }
 +        }
 +        s->gb_frame = 0;
 +        s->time_frame = av_gettime() * s->time_base.den / s->time_base.num;
 +
 +        /* start to grab the first frame */
 +        s->gb_buf.frame = s->gb_frame % s->gb_buffers.frames;
 +        s->gb_buf.height = s->video_win.height;
 +        s->gb_buf.width = s->video_win.width;
 +        s->gb_buf.format = pict.palette;
 +
 +        if (ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
 +            if (errno != EAGAIN) {
 +            fail1:
 +                av_log(s1, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
 +            } else {
 +                av_log(s1, AV_LOG_ERROR, "Fatal: grab device does not receive any video signal\n");
 +            }
 +            goto fail;
 +        }
 +        for (j = 1; j < s->gb_buffers.frames; j++) {
 +          s->gb_buf.frame = j;
 +          ioctl(video_fd, VIDIOCMCAPTURE, &s->gb_buf);
 +        }
 +        s->frame_format = s->gb_buf.format;
 +        s->use_mmap = 1;
 +    }
 +
 +    for (j = 0; j < vformat_num; j++) {
 +        if (s->frame_format == video_formats[j].palette) {
 +            s->frame_size = s->video_win.width * s->video_win.height * video_formats[j].depth / 8;
 +            st->codec->pix_fmt = video_formats[j].pix_fmt;
 +            break;
 +        }
 +    }
 +
 +    if (j >= vformat_num)
 +        goto fail;
 +
 +    s->fd = video_fd;
 +
 +    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
 +    st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
 +    st->codec->width = s->video_win.width;
 +    st->codec->height = s->video_win.height;
 +    st->codec->time_base = s->time_base;
 +    st->codec->bit_rate = s->frame_size * 1/av_q2d(st->codec->time_base) * 8;
 +
 +    return 0;
 + fail:
 +    if (video_fd >= 0)
 +        close(video_fd);
 +    return AVERROR(EIO);
 +}
 +
 +static int v4l_mm_read_picture(VideoData *s, uint8_t *buf)
 +{
 +    uint8_t *ptr;
 +
 +    while (ioctl(s->fd, VIDIOCSYNC, &s->gb_frame) < 0 &&
 +           (errno == EAGAIN || errno == EINTR));
 +
 +    ptr = s->video_buf + s->gb_buffers.offsets[s->gb_frame];
 +    memcpy(buf, ptr, s->frame_size);
 +
 +    /* Setup to capture the next frame */
 +    s->gb_buf.frame = s->gb_frame;
 +    if (ioctl(s->fd, VIDIOCMCAPTURE, &s->gb_buf) < 0) {
 +        if (errno == EAGAIN)
 +            av_log(NULL, AV_LOG_ERROR, "Cannot Sync\n");
 +        else
 +            av_log(NULL, AV_LOG_ERROR, "VIDIOCMCAPTURE: %s\n", strerror(errno));
 +        return AVERROR(EIO);
 +    }
 +
 +    /* This is now the grabbing frame */
 +    s->gb_frame = (s->gb_frame + 1) % s->gb_buffers.frames;
 +
 +    return s->frame_size;
 +}
 +
 +static int grab_read_packet(AVFormatContext *s1, AVPacket *pkt)
 +{
 +    VideoData *s = s1->priv_data;
 +    int64_t curtime, delay;
 +    struct timespec ts;
 +
 +    /* Calculate the time of the next frame */
 +    s->time_frame += INT64_C(1000000);
 +
 +    /* wait based on the frame rate */
 +    for(;;) {
 +        curtime = av_gettime();
 +        delay = s->time_frame * s->time_base.num / s->time_base.den - curtime;
 +        if (delay <= 0) {
 +            if (delay < INT64_C(-1000000) * s->time_base.num / s->time_base.den) {
 +                /* printf("grabbing is %d frames late (dropping)\n", (int) -(delay / 16666)); */
 +                s->time_frame += INT64_C(1000000);
 +            }
 +            break;
 +        }
 +        ts.tv_sec = delay / 1000000;
 +        ts.tv_nsec = (delay % 1000000) * 1000;
 +        nanosleep(&ts, NULL);
 +    }
 +
 +    if (av_new_packet(pkt, s->frame_size) < 0)
 +        return AVERROR(EIO);
 +
 +    pkt->pts = curtime;
 +
 +    /* read one frame */
 +    if (s->use_mmap) {
 +        return v4l_mm_read_picture(s, pkt->data);
 +    } else {
 +        if (read(s->fd, pkt->data, pkt->size) != pkt->size)
 +            return AVERROR(EIO);
 +        return s->frame_size;
 +    }
 +}
 +
 +static int grab_read_close(AVFormatContext *s1)
 +{
 +    VideoData *s = s1->priv_data;
 +
 +    if (s->use_mmap)
 +        munmap(s->video_buf, s->gb_buffers.size);
 +
 +    /* mute audio. we must force it because the BTTV driver does not
 +       return its state correctly */
 +    s->audio_saved.flags |= VIDEO_AUDIO_MUTE;
 +    ioctl(s->fd, VIDIOCSAUDIO, &s->audio_saved);
 +
 +    close(s->fd);
 +    return 0;
 +}
 +
 +static const AVOption options[] = {
 +    { "standard", "", offsetof(VideoData, standard), AV_OPT_TYPE_INT, {.dbl = VIDEO_MODE_NTSC}, VIDEO_MODE_PAL, VIDEO_MODE_NTSC, AV_OPT_FLAG_DECODING_PARAM, "standard" },
++    { "PAL",   "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_PAL},   0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
++    { "SECAM", "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_SECAM}, 0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
++    { "NTSC",  "", 0, AV_OPT_TYPE_CONST, {.i64 = VIDEO_MODE_NTSC},  0, 0, AV_OPT_FLAG_DECODING_PARAM, "standard" },
 +    { NULL },
 +};
 +
 +static const AVClass v4l_class = {
 +    .class_name = "V4L indev",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +};
 +
 +AVInputFormat ff_v4l_demuxer = {
 +    .name           = "video4linux,v4l",
 +    .long_name      = NULL_IF_CONFIG_SMALL("Video4Linux device grab"),
 +    .priv_data_size = sizeof(VideoData),
 +    .read_header    = grab_read_header,
 +    .read_packet    = grab_read_packet,
 +    .read_close     = grab_read_close,
 +    .flags          = AVFMT_NOFILE,
 +    .priv_class     = &v4l_class,
 +};
@@@ -929,14 -832,9 +929,14 @@@ static const AVOption options[] = 
      { "input_format", "Preferred pixel format (for raw video) or codec name",      OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       DEC },
      { "framerate",    "",                                                          OFFSET(framerate),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       DEC },
      { "list_formats", "List available formats and exit",                           OFFSET(list_format),  AV_OPT_TYPE_INT,    {.dbl = 0 },  0, INT_MAX, DEC, "list_formats" },
-     { "all",          "Show all available formats",                                OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.dbl = V4L_ALLFORMATS  },    0, INT_MAX, DEC, "list_formats" },
-     { "raw",          "Show only non-compressed formats",                          OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.dbl = V4L_RAWFORMATS  },    0, INT_MAX, DEC, "list_formats" },
-     { "compressed",   "Show only compressed formats",                              OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.dbl = V4L_COMPFORMATS },    0, INT_MAX, DEC, "list_formats" },
+     { "all",          "Show all available formats",                                OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_ALLFORMATS  },    0, INT_MAX, DEC, "list_formats" },
+     { "raw",          "Show only non-compressed formats",                          OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_RAWFORMATS  },    0, INT_MAX, DEC, "list_formats" },
+     { "compressed",   "Show only compressed formats",                              OFFSET(list_format),  AV_OPT_TYPE_CONST,  {.i64 = V4L_COMPFORMATS },    0, INT_MAX, DEC, "list_formats" },
 +    { "timestamps",   "Kind of timestamps for grabbed frames",                     OFFSET(ts_mode),      AV_OPT_TYPE_INT,    {.dbl = 0 }, 0, 2, DEC, "timestamps" },
-     { "default",      "Use timestamps from the kernel",                            OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.dbl = V4L_TS_DEFAULT  }, 0, 2, DEC, "timestamps" },
-     { "abs",          "Use absolute timestamps (wall clock)",                      OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.dbl = V4L_TS_ABS      }, 0, 2, DEC, "timestamps" },
-     { "mono2abs",     "Force conversion from monotonic to absolute timestamps",    OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.dbl = V4L_TS_MONO2ABS }, 0, 2, DEC, "timestamps" },
++    { "default",      "Use timestamps from the kernel",                            OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_DEFAULT  }, 0, 2, DEC, "timestamps" },
++    { "abs",          "Use absolute timestamps (wall clock)",                      OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_ABS      }, 0, 2, DEC, "timestamps" },
++    { "mono2abs",     "Force conversion from monotonic to absolute timestamps",    OFFSET(ts_mode),      AV_OPT_TYPE_CONST,  {.i64 = V4L_TS_MONO2ABS }, 0, 2, DEC, "timestamps" },
 +    { "ts",           "Kind of timestamps for grabbed frames",                     OFFSET(ts_mode),      AV_OPT_TYPE_INT,    {.dbl = 0 }, 0, 2, DEC, "timestamps" },
      { NULL },
  };
  
@@@ -586,16 -585,13 +586,16 @@@ x11grab_read_close(AVFormatContext *s1
  #define OFFSET(x) offsetof(struct x11grab, x)
  #define DEC AV_OPT_FLAG_DECODING_PARAM
  static const AVOption options[] = {
 -    { "video_size", "A string describing frame size, such as 640x480 or hd720.", OFFSET(video_size), AV_OPT_TYPE_STRING, {.str = "vga"}, 0, 0, DEC },
 -    { "framerate", "", OFFSET(framerate), AV_OPT_TYPE_STRING, {.str = "ntsc"}, 0, 0, DEC },
 -    { "draw_mouse", "Draw the mouse pointer.", OFFSET(draw_mouse), AV_OPT_TYPE_INT, { 1 }, 0, 1, DEC },
 -    { "follow_mouse", "Move the grabbing region when the mouse pointer reaches within specified amount of pixels to the edge of region.",
 -      OFFSET(follow_mouse), AV_OPT_TYPE_INT, { 0 }, -1, INT_MAX, DEC, "follow_mouse" },
 -    { "centered", "Keep the mouse pointer at the center of grabbing region when following.", 0, AV_OPT_TYPE_CONST, { .i64 = -1 }, INT_MIN, INT_MAX, DEC, "follow_mouse" },
 -    { "show_region", "Show the grabbing region.", OFFSET(show_region), AV_OPT_TYPE_INT, { 0 }, 0, 1, DEC },
 +    { "draw_mouse", "draw the mouse pointer", OFFSET(draw_mouse), AV_OPT_TYPE_INT, {1}, 0, 1, DEC },
 +
 +    { "follow_mouse", "move the grabbing region when the mouse pointer reaches within specified amount of pixels to the edge of region",
 +      OFFSET(follow_mouse), AV_OPT_TYPE_INT, {0}, -1, INT_MAX, DEC, "follow_mouse" },
 +    { "centered",     "keep the mouse pointer at the center of grabbing region when following",
-       0, AV_OPT_TYPE_CONST, {-1}, INT_MIN, INT_MAX, DEC, "follow_mouse" },
++      0, AV_OPT_TYPE_CONST, {.i64 = -1}, INT_MIN, INT_MAX, DEC, "follow_mouse" },
 +
 +    { "framerate",  "set video frame rate",      OFFSET(framerate),   AV_OPT_TYPE_STRING,     {.str = "ntsc"}, 0, 0, DEC },
 +    { "show_region", "show the grabbing region", OFFSET(show_region), AV_OPT_TYPE_INT,        {0}, 0, 1, DEC },
 +    { "video_size",  "set video frame size",     OFFSET(width),       AV_OPT_TYPE_IMAGE_SIZE, {.str = "vga"}, 0, 0, DEC },
      { NULL },
  };
  
@@@ -174,18 -174,17 +174,18 @@@ typedef struct MixContext 
  
  #define OFFSET(x) offsetof(MixContext, x)
  #define A AV_OPT_FLAG_AUDIO_PARAM
 -static const AVOption options[] = {
 +#define F AV_OPT_FLAG_FILTERING_PARAM
 +static const AVOption amix_options[] = {
      { "inputs", "Number of inputs.",
 -            OFFSET(nb_inputs), AV_OPT_TYPE_INT, { 2 }, 1, 32, A },
 +            OFFSET(nb_inputs), AV_OPT_TYPE_INT, { 2 }, 1, 32, A|F },
      { "duration", "How to determine the end-of-stream.",
 -            OFFSET(duration_mode), AV_OPT_TYPE_INT, { DURATION_LONGEST }, 0,  2, A, "duration" },
 -        { "longest",  "Duration of longest input.",  0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST  }, INT_MIN, INT_MAX, A, "duration" },
 -        { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, INT_MIN, INT_MAX, A, "duration" },
 -        { "first",    "Duration of first input.",    0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST    }, INT_MIN, INT_MAX, A, "duration" },
 +            OFFSET(duration_mode), AV_OPT_TYPE_INT, { DURATION_LONGEST }, 0,  2, A|F, "duration" },
-         { "longest",  "Duration of longest input.",  0, AV_OPT_TYPE_CONST, { DURATION_LONGEST  }, INT_MIN, INT_MAX, A|F, "duration" },
-         { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { DURATION_SHORTEST }, INT_MIN, INT_MAX, A|F, "duration" },
-         { "first",    "Duration of first input.",    0, AV_OPT_TYPE_CONST, { DURATION_FIRST    }, INT_MIN, INT_MAX, A|F, "duration" },
++        { "longest",  "Duration of longest input.",  0, AV_OPT_TYPE_CONST, { .i64 = DURATION_LONGEST  }, INT_MIN, INT_MAX, A|F, "duration" },
++        { "shortest", "Duration of shortest input.", 0, AV_OPT_TYPE_CONST, { .i64 = DURATION_SHORTEST }, INT_MIN, INT_MAX, A|F, "duration" },
++        { "first",    "Duration of first input.",    0, AV_OPT_TYPE_CONST, { .i64 = DURATION_FIRST    }, INT_MIN, INT_MAX, A|F, "duration" },
      { "dropout_transition", "Transition time, in seconds, for volume "
                              "renormalization when an input stream ends.",
 -            OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { 2.0 }, 0, INT_MAX, A },
 +            OFFSET(dropout_transition), AV_OPT_TYPE_FLOAT, { 2.0 }, 0, INT_MAX, A|F },
      { NULL },
  };
  
@@@ -163,48 -146,42 +163,48 @@@ typedef struct 
  } DrawTextContext;
  
  #define OFFSET(x) offsetof(DrawTextContext, x)
 +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM
  
  static const AVOption drawtext_options[]= {
 -{"fontfile", "set font file",        OFFSET(fontfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"text",     "set text",             OFFSET(text),               AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"textfile", "set text file",        OFFSET(textfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"fontcolor","set foreground color", OFFSET(fontcolor_string),   AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"boxcolor", "set box color",        OFFSET(boxcolor_string),    AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"shadowcolor", "set shadow color",  OFFSET(shadowcolor_string), AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX },
 -{"box",      "set box",              OFFSET(draw_box),           AV_OPT_TYPE_INT,    {.dbl=0},     0,        1        },
 -{"fontsize", "set font size",        OFFSET(fontsize),           AV_OPT_TYPE_INT,    {.dbl=16},    1,        72       },
 -{"x",        "set x",                OFFSET(x_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX },
 -{"y",        "set y",                OFFSET(y_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX },
 -{"shadowx",  "set x",                OFFSET(shadowx),            AV_OPT_TYPE_INT,    {.dbl=0},     INT_MIN,  INT_MAX  },
 -{"shadowy",  "set y",                OFFSET(shadowy),            AV_OPT_TYPE_INT,    {.dbl=0},     INT_MIN,  INT_MAX  },
 -{"tabsize",  "set tab size",         OFFSET(tabsize),            AV_OPT_TYPE_INT,    {.dbl=4},     0,        INT_MAX  },
 -{"draw",     "if false do not draw", OFFSET(d_expr),             AV_OPT_TYPE_STRING, {.str="1"},   CHAR_MIN, CHAR_MAX },
 -{"fix_bounds", "if true, check and fix text coords to avoid clipping",
 -                                     OFFSET(fix_bounds),         AV_OPT_TYPE_INT,    {.dbl=1},     0,        1        },
 +{"fontfile", "set font file",        OFFSET(fontfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
 +{"text",     "set text",             OFFSET(text),               AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
 +{"textfile", "set text file",        OFFSET(textfile),           AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
 +{"fontcolor",   "set foreground color", OFFSET(fontcolor_string),   AV_OPT_TYPE_STRING, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
 +{"boxcolor",    "set box color",        OFFSET(boxcolor_string),    AV_OPT_TYPE_STRING, {.str="white"}, CHAR_MIN, CHAR_MAX, FLAGS},
 +{"shadowcolor", "set shadow color",     OFFSET(shadowcolor_string), AV_OPT_TYPE_STRING, {.str="black"}, CHAR_MIN, CHAR_MAX, FLAGS},
 +{"box",      "set box",              OFFSET(draw_box),           AV_OPT_TYPE_INT,    {.dbl=0},     0,        1       , FLAGS},
 +{"fontsize", "set font size",        OFFSET(fontsize),           AV_OPT_TYPE_INT,    {.dbl=0},     0,        INT_MAX , FLAGS},
 +{"x",        "set x expression",     OFFSET(x_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
 +{"y",        "set y expression",     OFFSET(y_expr),             AV_OPT_TYPE_STRING, {.str="0"},   CHAR_MIN, CHAR_MAX, FLAGS},
 +{"shadowx",  "set x",                OFFSET(shadowx),            AV_OPT_TYPE_INT,    {.dbl=0},     INT_MIN,  INT_MAX , FLAGS},
 +{"shadowy",  "set y",                OFFSET(shadowy),            AV_OPT_TYPE_INT,    {.dbl=0},     INT_MIN,  INT_MAX , FLAGS},
 +{"tabsize",  "set tab size",         OFFSET(tabsize),            AV_OPT_TYPE_INT,    {.dbl=4},     0,        INT_MAX , FLAGS},
 +{"basetime", "set base time",        OFFSET(basetime),           AV_OPT_TYPE_INT64,  {.i64=AV_NOPTS_VALUE}, INT64_MIN, INT64_MAX , FLAGS},
 +{"draw",     "if false do not draw", OFFSET(draw_expr),          AV_OPT_TYPE_STRING, {.str="1"},   CHAR_MIN, CHAR_MAX, FLAGS},
 +{"timecode", "set initial timecode", OFFSET(tc_opt_string),      AV_OPT_TYPE_STRING, {.str=NULL},  CHAR_MIN, CHAR_MAX, FLAGS},
 +{"tc24hmax", "set 24 hours max (timecode only)", OFFSET(tc24hmax), AV_OPT_TYPE_INT,  {.dbl=0},            0,        1, FLAGS},
 +{"timecode_rate", "set rate (timecode only)", OFFSET(tc_rate),   AV_OPT_TYPE_RATIONAL, {.dbl=0},          0,  INT_MAX, FLAGS},
 +{"r",        "set rate (timecode only)", OFFSET(tc_rate),        AV_OPT_TYPE_RATIONAL, {.dbl=0},          0,  INT_MAX, FLAGS},
 +{"rate",     "set rate (timecode only)", OFFSET(tc_rate),        AV_OPT_TYPE_RATIONAL, {.dbl=0},          0,  INT_MAX, FLAGS},
 +{"fix_bounds", "if true, check and fix text coords to avoid clipping", OFFSET(fix_bounds), AV_OPT_TYPE_INT, {.dbl=1}, 0, 1, FLAGS},
  
  /* FT_LOAD_* flags */
 -{"ft_load_flags", "set font loading flags for libfreetype",   OFFSET(ft_load_flags),  AV_OPT_TYPE_FLAGS,  {.dbl=FT_LOAD_DEFAULT|FT_LOAD_RENDER}, 0, INT_MAX, 0, "ft_load_flags" },
 -{"default",                     "set default",                     0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_DEFAULT},                     INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"no_scale",                    "set no_scale",                    0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_NO_SCALE},                    INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"no_hinting",                  "set no_hinting",                  0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_NO_HINTING},                  INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"render",                      "set render",                      0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_RENDER},                      INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"no_bitmap",                   "set no_bitmap",                   0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_NO_BITMAP},                   INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"vertical_layout",             "set vertical_layout",             0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_VERTICAL_LAYOUT},             INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"force_autohint",              "set force_autohint",              0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_FORCE_AUTOHINT},              INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"crop_bitmap",                 "set crop_bitmap",                 0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_CROP_BITMAP},                 INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"pedantic",                    "set pedantic",                    0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_PEDANTIC},                    INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"ignore_global_advance_width", "set ignore_global_advance_width", 0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH}, INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"no_recurse",                  "set no_recurse",                  0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_NO_RECURSE},                  INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"ignore_transform",            "set ignore_transform",            0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_IGNORE_TRANSFORM},            INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"monochrome",                  "set monochrome",                  0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_MONOCHROME},                  INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"linear_design",               "set linear_design",               0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_LINEAR_DESIGN},               INT_MIN, INT_MAX, 0, "ft_load_flags" },
 -{"no_autohint",                 "set no_autohint",                 0, AV_OPT_TYPE_CONST, {.i64 = FT_LOAD_NO_AUTOHINT},                 INT_MIN, INT_MAX, 0, "ft_load_flags" },
 +{"ft_load_flags", "set font loading flags for libfreetype",   OFFSET(ft_load_flags),  AV_OPT_TYPE_FLAGS,  {.dbl=FT_LOAD_DEFAULT|FT_LOAD_RENDER}, 0, INT_MAX, FLAGS, "ft_load_flags"},
- {"default",                     "set default",                     0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_DEFAULT},                     INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"no_scale",                    "set no_scale",                    0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_NO_SCALE},                    INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"no_hinting",                  "set no_hinting",                  0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_NO_HINTING},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"render",                      "set render",                      0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_RENDER},                      INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"no_bitmap",                   "set no_bitmap",                   0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_NO_BITMAP},                   INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"vertical_layout",             "set vertical_layout",             0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_VERTICAL_LAYOUT},             INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"force_autohint",              "set force_autohint",              0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_FORCE_AUTOHINT},              INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"crop_bitmap",                 "set crop_bitmap",                 0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_CROP_BITMAP},                 INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"pedantic",                    "set pedantic",                    0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_PEDANTIC},                    INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"ignore_global_advance_width", "set ignore_global_advance_width", 0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH}, INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"no_recurse",                  "set no_recurse",                  0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_NO_RECURSE},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"ignore_transform",            "set ignore_transform",            0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_IGNORE_TRANSFORM},            INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"monochrome",                  "set monochrome",                  0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_MONOCHROME},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"linear_design",               "set linear_design",               0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_LINEAR_DESIGN},               INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
- {"no_autohint",                 "set no_autohint",                 0, AV_OPT_TYPE_CONST, {.dbl=FT_LOAD_NO_AUTOHINT},                 INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"default",                     "set default",                     0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_DEFAULT},                     INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"no_scale",                    "set no_scale",                    0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_NO_SCALE},                    INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"no_hinting",                  "set no_hinting",                  0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_NO_HINTING},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"render",                      "set render",                      0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_RENDER},                      INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"no_bitmap",                   "set no_bitmap",                   0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_NO_BITMAP},                   INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"vertical_layout",             "set vertical_layout",             0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_VERTICAL_LAYOUT},             INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"force_autohint",              "set force_autohint",              0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_FORCE_AUTOHINT},              INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"crop_bitmap",                 "set crop_bitmap",                 0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_CROP_BITMAP},                 INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"pedantic",                    "set pedantic",                    0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_PEDANTIC},                    INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"ignore_global_advance_width", "set ignore_global_advance_width", 0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH}, INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"no_recurse",                  "set no_recurse",                  0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_NO_RECURSE},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"ignore_transform",            "set ignore_transform",            0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_IGNORE_TRANSFORM},            INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"monochrome",                  "set monochrome",                  0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_MONOCHROME},                  INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"linear_design",               "set linear_design",               0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_LINEAR_DESIGN},               INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
++{"no_autohint",                 "set no_autohint",                 0, AV_OPT_TYPE_CONST, {.i64=FT_LOAD_NO_AUTOHINT},                 INT_MIN, INT_MAX, FLAGS, "ft_load_flags"},
  {NULL},
  };
  
index 59a79ac,0000000..6c107c0
mode 100644,000000..100644
--- /dev/null
@@@ -1,416 -1,0 +1,416 @@@
-     {"iteration_count", "set iteration count mode",  0, AV_OPT_TYPE_CONST, {.dbl=ITERATION_COUNT}, INT_MIN, INT_MAX, FLAGS, "outer" },
-     {"normalized_iteration_count", "set normalized iteration count mode",   0, AV_OPT_TYPE_CONST, {.dbl=NORMALIZED_ITERATION_COUNT}, INT_MIN, INT_MAX, FLAGS, "outer" },
 +/*
 + * Copyright (c) 2011 Michael Niedermayer
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + *
 + * The vsrc_color filter from Stefano Sabatini was used as template to create
 + * this
 + */
 +
 +/**
 + * @file
 + * Mandelbrot fraktal renderer
 + */
 +
 +#include "avfilter.h"
 +#include "formats.h"
 +#include "video.h"
 +#include "internal.h"
 +#include "libavutil/imgutils.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/parseutils.h"
 +#include <float.h>
 +#include <math.h>
 +
 +#define SQR(a) ((a)*(a))
 +
 +enum Outer{
 +    ITERATION_COUNT,
 +    NORMALIZED_ITERATION_COUNT,
 +};
 +
 +enum Inner{
 +    BLACK,
 +    PERIOD,
 +    CONVTIME,
 +    MINCOL,
 +};
 +
 +typedef struct Point {
 +    double p[2];
 +    uint32_t val;
 +} Point;
 +
 +typedef struct {
 +    const AVClass *class;
 +    int w, h;
 +    AVRational time_base;
 +    uint64_t pts;
 +    char *rate;
 +    int maxiter;
 +    double start_x;
 +    double start_y;
 +    double start_scale;
 +    double end_scale;
 +    double end_pts;
 +    double bailout;
 +    enum Outer outer;
 +    enum Inner inner;
 +    int cache_allocated;
 +    int cache_used;
 +    Point *point_cache;
 +    Point *next_cache;
 +    double (*zyklus)[2];
 +    uint32_t dither;
 +} MBContext;
 +
 +#define OFFSET(x) offsetof(MBContext, x)
 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
 +
 +static const AVOption mandelbrot_options[] = {
 +    {"size",        "set frame size",                OFFSET(w),       AV_OPT_TYPE_IMAGE_SIZE, {.str="640x480"},  CHAR_MIN, CHAR_MAX, FLAGS },
 +    {"s",           "set frame size",                OFFSET(w),       AV_OPT_TYPE_IMAGE_SIZE, {.str="640x480"},  CHAR_MIN, CHAR_MAX, FLAGS },
 +    {"rate",        "set frame rate",                OFFSET(rate),    AV_OPT_TYPE_STRING,     {.str="25"},  CHAR_MIN, CHAR_MAX, FLAGS },
 +    {"r",           "set frame rate",                OFFSET(rate),    AV_OPT_TYPE_STRING,     {.str="25"},  CHAR_MIN, CHAR_MAX, FLAGS },
 +    {"maxiter",     "set max iterations number",     OFFSET(maxiter), AV_OPT_TYPE_INT,        {.dbl=7189},  1,        INT_MAX, FLAGS },
 +    {"start_x",     "set the initial x position",    OFFSET(start_x), AV_OPT_TYPE_DOUBLE,     {.dbl=-0.743643887037158704752191506114774}, -100, 100, FLAGS },
 +    {"start_y",     "set the initial y position",    OFFSET(start_y), AV_OPT_TYPE_DOUBLE,     {.dbl=-0.131825904205311970493132056385139}, -100, 100, FLAGS },
 +    {"start_scale", "set the initial scale value",   OFFSET(start_scale), AV_OPT_TYPE_DOUBLE, {.dbl=3.0},  0, FLT_MAX, FLAGS },
 +    {"end_scale",   "set the terminal scale value",  OFFSET(end_scale), AV_OPT_TYPE_DOUBLE,   {.dbl=0.3},  0, FLT_MAX, FLAGS },
 +    {"end_pts",     "set the terminal pts value",    OFFSET(end_pts), AV_OPT_TYPE_DOUBLE,     {.dbl=400},  0, INT64_MAX, FLAGS },
 +    {"bailout",     "set the bailout value",         OFFSET(bailout), AV_OPT_TYPE_DOUBLE,     {.dbl=10},   0, FLT_MAX, FLAGS },
 +
 +    {"outer",       "set outer coloring mode",       OFFSET(outer), AV_OPT_TYPE_INT, {.dbl=NORMALIZED_ITERATION_COUNT}, 0, INT_MAX, FLAGS, "outer" },
-     {"black",       "set black mode",                0, AV_OPT_TYPE_CONST, {.dbl=BLACK}, INT_MIN, INT_MAX, FLAGS, "inner"},
-     {"period",      "set period mode",               0, AV_OPT_TYPE_CONST, {.dbl=PERIOD}, INT_MIN, INT_MAX, FLAGS, "inner"},
-     {"convergence", "show time until convergence",   0, AV_OPT_TYPE_CONST, {.dbl=CONVTIME}, INT_MIN, INT_MAX, FLAGS, "inner"},
-     {"mincol",      "color based on point closest to the origin of the iterations",   0, AV_OPT_TYPE_CONST, {.dbl=MINCOL}, INT_MIN, INT_MAX, FLAGS, "inner"},
++    {"iteration_count", "set iteration count mode",  0, AV_OPT_TYPE_CONST, {.i64=ITERATION_COUNT}, INT_MIN, INT_MAX, FLAGS, "outer" },
++    {"normalized_iteration_count", "set normalized iteration count mode",   0, AV_OPT_TYPE_CONST, {.i64=NORMALIZED_ITERATION_COUNT}, INT_MIN, INT_MAX, FLAGS, "outer" },
 +
 +    {"inner",       "set inner coloring mode",       OFFSET(inner), AV_OPT_TYPE_INT, {.dbl=MINCOL}, 0, INT_MAX, FLAGS, "inner" },
++    {"black",       "set black mode",                0, AV_OPT_TYPE_CONST, {.i64=BLACK}, INT_MIN, INT_MAX, FLAGS, "inner"},
++    {"period",      "set period mode",               0, AV_OPT_TYPE_CONST, {.i64=PERIOD}, INT_MIN, INT_MAX, FLAGS, "inner"},
++    {"convergence", "show time until convergence",   0, AV_OPT_TYPE_CONST, {.i64=CONVTIME}, INT_MIN, INT_MAX, FLAGS, "inner"},
++    {"mincol",      "color based on point closest to the origin of the iterations",   0, AV_OPT_TYPE_CONST, {.i64=MINCOL}, INT_MIN, INT_MAX, FLAGS, "inner"},
 +
 +    {NULL},
 +};
 +
 +AVFILTER_DEFINE_CLASS(mandelbrot);
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    MBContext *mb = ctx->priv;
 +    AVRational rate_q;
 +    int err;
 +
 +    mb->class = &mandelbrot_class;
 +    av_opt_set_defaults(mb);
 +
 +    if ((err = (av_set_options_string(mb, args, "=", ":"))) < 0)
 +        return err;
 +    mb->bailout *= mb->bailout;
 +
 +    mb->start_scale /=mb->h;
 +    mb->end_scale /=mb->h;
 +
 +    if (av_parse_video_rate(&rate_q, mb->rate) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: %s\n", mb->rate);
 +        return AVERROR(EINVAL);
 +    }
 +    mb->time_base.num = rate_q.den;
 +    mb->time_base.den = rate_q.num;
 +
 +    mb->cache_allocated = mb->w * mb->h * 3;
 +    mb->cache_used = 0;
 +    mb->point_cache= av_malloc(sizeof(*mb->point_cache)*mb->cache_allocated);
 +    mb-> next_cache= av_malloc(sizeof(*mb-> next_cache)*mb->cache_allocated);
 +    mb-> zyklus    = av_malloc(sizeof(*mb->zyklus) * (mb->maxiter+16));
 +
 +    return 0;
 +}
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    MBContext *mb = ctx->priv;
 +
 +    av_freep(&mb->rate);
 +    av_freep(&mb->point_cache);
 +    av_freep(&mb-> next_cache);
 +    av_freep(&mb->zyklus);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    static const enum PixelFormat pix_fmts[] = {
 +        PIX_FMT_BGR32,
 +        PIX_FMT_NONE
 +    };
 +
 +    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 +    return 0;
 +}
 +
 +static int config_props(AVFilterLink *inlink)
 +{
 +    AVFilterContext *ctx = inlink->src;
 +    MBContext *mb = ctx->priv;
 +
 +    if (av_image_check_size(mb->w, mb->h, 0, ctx) < 0)
 +        return AVERROR(EINVAL);
 +
 +    inlink->w = mb->w;
 +    inlink->h = mb->h;
 +    inlink->time_base = mb->time_base;
 +
 +    return 0;
 +}
 +
 +static void fill_from_cache(AVFilterContext *ctx, uint32_t *color, int *in_cidx, int *out_cidx, double py, double scale){
 +    MBContext *mb = ctx->priv;
 +    for(; *in_cidx < mb->cache_used; (*in_cidx)++){
 +        Point *p= &mb->point_cache[*in_cidx];
 +        int x;
 +        if(p->p[1] > py)
 +            break;
 +        x= round((p->p[0] - mb->start_x) / scale + mb->w/2);
 +        if(x<0 || x >= mb->w)
 +            continue;
 +        if(color) color[x] = p->val;
 +        if(out_cidx && *out_cidx < mb->cache_allocated)
 +            mb->next_cache[(*out_cidx)++]= *p;
 +    }
 +}
 +
 +static int interpol(MBContext *mb, uint32_t *color, int x, int y, int linesize)
 +{
 +    uint32_t a,b,c,d, i;
 +    uint32_t ipol=0xFF000000;
 +    int dist;
 +
 +    if(!x || !y || x+1==mb->w || y+1==mb->h)
 +        return 0;
 +
 +    dist= FFMAX(FFABS(x-(mb->w>>1))*mb->h, FFABS(y-(mb->h>>1))*mb->w);
 +
 +    if(dist<(mb->w*mb->h>>3))
 +        return 0;
 +
 +    a=color[(x+1) + (y+0)*linesize];
 +    b=color[(x-1) + (y+1)*linesize];
 +    c=color[(x+0) + (y+1)*linesize];
 +    d=color[(x+1) + (y+1)*linesize];
 +
 +    if(a&&c){
 +        b= color[(x-1) + (y+0)*linesize];
 +        d= color[(x+0) + (y-1)*linesize];
 +    }else if(b&&d){
 +        a= color[(x+1) + (y-1)*linesize];
 +        c= color[(x-1) + (y-1)*linesize];
 +    }else if(c){
 +        d= color[(x+0) + (y-1)*linesize];
 +        a= color[(x-1) + (y+0)*linesize];
 +        b= color[(x+1) + (y-1)*linesize];
 +    }else if(d){
 +        c= color[(x-1) + (y-1)*linesize];
 +        a= color[(x-1) + (y+0)*linesize];
 +        b= color[(x+1) + (y-1)*linesize];
 +    }else
 +        return 0;
 +
 +    for(i=0; i<3; i++){
 +        int s= 8*i;
 +        uint8_t ac= a>>s;
 +        uint8_t bc= b>>s;
 +        uint8_t cc= c>>s;
 +        uint8_t dc= d>>s;
 +        int ipolab= (ac + bc);
 +        int ipolcd= (cc + dc);
 +        if(FFABS(ipolab - ipolcd) > 5)
 +            return 0;
 +        if(FFABS(ac-bc)+FFABS(cc-dc) > 20)
 +            return 0;
 +        ipol |= ((ipolab + ipolcd + 2)/4)<<s;
 +    }
 +    color[x + y*linesize]= ipol;
 +    return 1;
 +}
 +
 +static void draw_mandelbrot(AVFilterContext *ctx, uint32_t *color, int linesize, int64_t pts)
 +{
 +    MBContext *mb = ctx->priv;
 +    int x,y,i, in_cidx=0, next_cidx=0, tmp_cidx;
 +    double scale= mb->start_scale*pow(mb->end_scale/mb->start_scale, pts/mb->end_pts);
 +    int use_zyklus=0;
 +    fill_from_cache(ctx, NULL, &in_cidx, NULL, mb->start_y+scale*(-mb->h/2-0.5), scale);
 +    tmp_cidx= in_cidx;
 +    memset(color, 0, sizeof(*color)*mb->w);
 +    for(y=0; y<mb->h; y++){
 +        int y1= y+1;
 +        const double ci=mb->start_y+scale*(y-mb->h/2);
 +        fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci, scale);
 +        if(y1<mb->h){
 +            memset(color+linesize*y1, 0, sizeof(*color)*mb->w);
 +            fill_from_cache(ctx, color+linesize*y1, &tmp_cidx, NULL, ci + 3*scale/2, scale);
 +        }
 +
 +        for(x=0; x<mb->w; x++){
 +            float av_uninit(epsilon);
 +            const double cr=mb->start_x+scale*(x-mb->w/2);
 +            double zr=cr;
 +            double zi=ci;
 +            uint32_t c=0;
 +            double dv= mb->dither / (double)(1LL<<32);
 +            mb->dither= mb->dither*1664525+1013904223;
 +
 +            if(color[x + y*linesize] & 0xFF000000)
 +                continue;
 +            if(interpol(mb, color, x, y, linesize)){
 +                if(next_cidx < mb->cache_allocated){
 +                    mb->next_cache[next_cidx  ].p[0]= cr;
 +                    mb->next_cache[next_cidx  ].p[1]= ci;
 +                    mb->next_cache[next_cidx++].val = color[x + y*linesize];
 +                }
 +                continue;
 +            }
 +
 +            use_zyklus= (x==0 || mb->inner!=BLACK ||color[x-1 + y*linesize] == 0xFF000000);
 +            if(use_zyklus)
 +                epsilon= scale*1*sqrt(SQR(x-mb->w/2) + SQR(y-mb->h/2))/mb->w;
 +
 +#define Z_Z2_C(outr,outi,inr,ini)\
 +            outr= inr*inr - ini*ini + cr;\
 +            outi= 2*inr*ini + ci;
 +
 +#define Z_Z2_C_ZYKLUS(outr,outi,inr,ini, Z)\
 +            Z_Z2_C(outr,outi,inr,ini)\
 +            if(use_zyklus){\
 +                if(Z && fabs(mb->zyklus[i>>1][0]-outr)+fabs(mb->zyklus[i>>1][1]-outi) <= epsilon)\
 +                    break;\
 +            }\
 +            mb->zyklus[i][0]= outr;\
 +            mb->zyklus[i][1]= outi;\
 +
 +
 +
 +            for(i=0; i<mb->maxiter-8; i++){
 +                double t;
 +                Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
 +                i++;
 +                Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
 +                i++;
 +                Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
 +                i++;
 +                Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
 +                i++;
 +                Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
 +                i++;
 +                Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
 +                i++;
 +                Z_Z2_C_ZYKLUS(t, zi, zr, zi, 0)
 +                i++;
 +                Z_Z2_C_ZYKLUS(zr, zi, t, zi, 1)
 +                if(zr*zr + zi*zi > mb->bailout){
 +                    i-= FFMIN(7, i);
 +                    for(; i<mb->maxiter; i++){
 +                        zr= mb->zyklus[i][0];
 +                        zi= mb->zyklus[i][1];
 +                        if(zr*zr + zi*zi > mb->bailout){
 +                            switch(mb->outer){
 +                            case            ITERATION_COUNT: zr = i; break;
 +                            case NORMALIZED_ITERATION_COUNT: zr= i + log2(log(mb->bailout) / log(zr*zr + zi*zi)); break;
 +                            }
 +                            c= lrintf((sin(zr)+1)*127) + lrintf((sin(zr/1.234)+1)*127)*256*256 + lrintf((sin(zr/100)+1)*127)*256;
 +                            break;
 +                        }
 +                    }
 +                    break;
 +                }
 +            }
 +            if(!c){
 +                if(mb->inner==PERIOD){
 +                int j;
 +                for(j=i-1; j; j--)
 +                    if(SQR(mb->zyklus[j][0]-zr) + SQR(mb->zyklus[j][1]-zi) < epsilon*epsilon*10)
 +                        break;
 +                if(j){
 +                    c= i-j;
 +                    c= ((c<<5)&0xE0) + ((c<<16)&0xE000) + ((c<<27)&0xE00000);
 +                }
 +                }else if(mb->inner==CONVTIME){
 +                    c= floor(i*255.0/mb->maxiter+dv)*0x010101;
 +                } else if(mb->inner==MINCOL){
 +                    int j;
 +                    double closest=9999;
 +                    int closest_index=0;
 +                    for(j=i-1; j>=0; j--)
 +                        if(SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]) < closest){
 +                            closest= SQR(mb->zyklus[j][0]) + SQR(mb->zyklus[j][1]);
 +                            closest_index= j;
 +                        }
 +                    closest = sqrt(closest);
 +                    c= lrintf((mb->zyklus[closest_index][0]/closest+1)*127+dv) + lrintf((mb->zyklus[closest_index][1]/closest+1)*127+dv)*256;
 +                }
 +            }
 +            c |= 0xFF000000;
 +            color[x + y*linesize]= c;
 +            if(next_cidx < mb->cache_allocated){
 +                mb->next_cache[next_cidx  ].p[0]= cr;
 +                mb->next_cache[next_cidx  ].p[1]= ci;
 +                mb->next_cache[next_cidx++].val = c;
 +            }
 +        }
 +        fill_from_cache(ctx, NULL, &in_cidx, &next_cidx, ci + scale/2, scale);
 +    }
 +    FFSWAP(void*, mb->next_cache, mb->point_cache);
 +    mb->cache_used = next_cidx;
 +    if(mb->cache_used == mb->cache_allocated)
 +        av_log(0, AV_LOG_INFO, "Mandelbrot cache is too small!\n");
 +}
 +
 +static int request_frame(AVFilterLink *link)
 +{
 +    MBContext *mb = link->src->priv;
 +    AVFilterBufferRef *picref = ff_get_video_buffer(link, AV_PERM_WRITE, mb->w, mb->h);
 +    picref->video->sample_aspect_ratio = (AVRational) {1, 1};
 +    picref->pts = mb->pts++;
 +    picref->pos = -1;
 +
 +    ff_start_frame(link, avfilter_ref_buffer(picref, ~0));
 +    draw_mandelbrot(link->src, (uint32_t*)picref->data[0], picref->linesize[0]/4, picref->pts);
 +    ff_draw_slice(link, 0, mb->h, 1);
 +    ff_end_frame(link);
 +    avfilter_unref_buffer(picref);
 +
 +    return 0;
 +}
 +
 +AVFilter avfilter_vsrc_mandelbrot = {
 +    .name        = "mandelbrot",
 +    .description = NULL_IF_CONFIG_SMALL("Render a Mandelbrot fractal."),
 +
 +    .priv_size = sizeof(MBContext),
 +    .init      = init,
 +    .uninit    = uninit,
 +
 +    .query_formats = query_formats,
 +
 +    .inputs    = (const AVFilterPad[]) {{ .name = NULL}},
 +
 +    .outputs   = (const AVFilterPad[]) {{ .name      = "default",
 +                                    .type            = AVMEDIA_TYPE_VIDEO,
 +                                    .request_frame   = request_frame,
 +                                    .config_props    = config_props },
 +                                  { .name = NULL}},
 +};
index 4e312c5,0000000..7089c53
mode 100644,000000..100644
--- /dev/null
@@@ -1,382 -1,0 +1,382 @@@
-     { "dc_luma",     "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_DC_LUMA},     INT_MIN, INT_MAX, 0, "test" },
-     { "dc_chroma",   "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_DC_CHROMA},   INT_MIN, INT_MAX, 0, "test" },
-     { "freq_luma",   "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_FREQ_LUMA},   INT_MIN, INT_MAX, 0, "test" },
-     { "freq_chroma", "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_FREQ_CHROMA}, INT_MIN, INT_MAX, 0, "test" },
-     { "amp_luma",    "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_AMP_LUMA},    INT_MIN, INT_MAX, 0, "test" },
-     { "amp_chroma",  "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_AMP_CHROMA},  INT_MIN, INT_MAX, 0, "test" },
-     { "cbp",         "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_CBP},         INT_MIN, INT_MAX, 0, "test" },
-     { "mv",          "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_MV},          INT_MIN, INT_MAX, 0, "test" },
-     { "ring1",       "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_RING1},       INT_MIN, INT_MAX, 0, "test" },
-     { "ring2",       "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_RING2},       INT_MIN, INT_MAX, 0, "test" },
-     { "all",         "", 0, AV_OPT_TYPE_CONST, {.dbl=TEST_ALL},         INT_MIN, INT_MAX, 0, "test" },
 +/*
 + * Copyright (c) 2002 Michael Niedermayer <michaelni@gmx.at>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or modify
 + * it under the terms of the GNU General Public License as published by
 + * the Free Software Foundation; either version 2 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 General Public License for more details.
 + *
 + * You should have received a copy of the GNU 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
 + * MP test source, ported from MPlayer libmpcodecs/vf_test.c
 + */
 +
 +#include "libavutil/avstring.h"
 +#include "libavutil/opt.h"
 +#include "libavutil/parseutils.h"
 +#include "libavutil/pixdesc.h"
 +#include "avfilter.h"
 +#include "internal.h"
 +#include "formats.h"
 +#include "video.h"
 +
 +#define WIDTH 512
 +#define HEIGHT 512
 +
 +enum test_type {
 +    TEST_DC_LUMA,
 +    TEST_DC_CHROMA,
 +    TEST_FREQ_LUMA,
 +    TEST_FREQ_CHROMA,
 +    TEST_AMP_LUMA,
 +    TEST_AMP_CHROMA,
 +    TEST_CBP,
 +    TEST_MV,
 +    TEST_RING1,
 +    TEST_RING2,
 +    TEST_ALL,
 +    TEST_NB
 +};
 +
 +typedef struct MPTestContext {
 +    const AVClass *class;
 +    unsigned int frame_nb;
 +    AVRational time_base;
 +    int64_t pts, max_pts;
 +    int hsub, vsub;
 +    char *size, *rate, *duration;
 +    enum test_type test;
 +} MPTestContext;
 +
 +#define OFFSET(x) offsetof(MPTestContext, x)
 +
 +static const AVOption mptestsrc_options[]= {
 +    { "rate",     "set video rate",     OFFSET(rate),     AV_OPT_TYPE_STRING, {.str = "25"},      0, 0 },
 +    { "r",        "set video rate",     OFFSET(rate),     AV_OPT_TYPE_STRING, {.str = "25"},      0, 0 },
 +    { "duration", "set video duration", OFFSET(duration), AV_OPT_TYPE_STRING, {.str = NULL},      0, 0 },
 +    { "d",        "set video duration", OFFSET(duration), AV_OPT_TYPE_STRING, {.str = NULL},      0, 0 },
 +
 +    { "test", "set test to perform", OFFSET(test),  AV_OPT_TYPE_INT,   {.dbl=TEST_ALL}, 0, INT_MAX, 0, "test" },
 +    { "t",    "set test to perform", OFFSET(test),  AV_OPT_TYPE_INT,   {.dbl=TEST_ALL}, 0, INT_MAX, 0, "test" },
++    { "dc_luma",     "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_DC_LUMA},     INT_MIN, INT_MAX, 0, "test" },
++    { "dc_chroma",   "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_DC_CHROMA},   INT_MIN, INT_MAX, 0, "test" },
++    { "freq_luma",   "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_FREQ_LUMA},   INT_MIN, INT_MAX, 0, "test" },
++    { "freq_chroma", "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_FREQ_CHROMA}, INT_MIN, INT_MAX, 0, "test" },
++    { "amp_luma",    "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_AMP_LUMA},    INT_MIN, INT_MAX, 0, "test" },
++    { "amp_chroma",  "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_AMP_CHROMA},  INT_MIN, INT_MAX, 0, "test" },
++    { "cbp",         "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_CBP},         INT_MIN, INT_MAX, 0, "test" },
++    { "mv",          "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_MV},          INT_MIN, INT_MAX, 0, "test" },
++    { "ring1",       "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_RING1},       INT_MIN, INT_MAX, 0, "test" },
++    { "ring2",       "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_RING2},       INT_MIN, INT_MAX, 0, "test" },
++    { "all",         "", 0, AV_OPT_TYPE_CONST, {.i64=TEST_ALL},         INT_MIN, INT_MAX, 0, "test" },
 +
 +    { NULL },
 +};
 +
 +AVFILTER_DEFINE_CLASS(mptestsrc);
 +
 +static double c[64];
 +
 +static void init_idct(void)
 +{
 +    int i, j;
 +
 +    for (i = 0; i < 8; i++) {
 +        double s = i == 0 ? sqrt(0.125) : 0.5;
 +
 +        for (j = 0; j < 8; j++)
 +            c[i*8+j] = s*cos((M_PI/8.0)*i*(j+0.5));
 +    }
 +}
 +
 +static void idct(uint8_t *dst, int dst_linesize, int src[64])
 +{
 +    int i, j, k;
 +    double tmp[64];
 +
 +    for (i = 0; i < 8; i++) {
 +        for (j = 0; j < 8; j++) {
 +            double sum = 0.0;
 +
 +            for (k = 0; k < 8; k++)
 +                sum += c[k*8+j] * src[8*i+k];
 +
 +            tmp[8*i+j] = sum;
 +        }
 +    }
 +
 +    for (j = 0; j < 8; j++) {
 +        for (i = 0; i < 8; i++) {
 +            double sum = 0.0;
 +
 +            for (k = 0; k < 8; k++)
 +                sum += c[k*8+i]*tmp[8*k+j];
 +
 +            dst[dst_linesize*i + j] = av_clip((int)floor(sum+0.5), 0, 255);
 +        }
 +    }
 +}
 +
 +static void draw_dc(uint8_t *dst, int dst_linesize, int color, int w, int h)
 +{
 +    int x, y;
 +
 +    for (y = 0; y < h; y++)
 +        for (x = 0; x < w; x++)
 +            dst[x + y*dst_linesize] = color;
 +}
 +
 +static void draw_basis(uint8_t *dst, int dst_linesize, int amp, int freq, int dc)
 +{
 +    int src[64];
 +
 +    memset(src, 0, 64*sizeof(int));
 +    src[0] = dc;
 +    if (amp)
 +        src[freq] = amp;
 +    idct(dst, dst_linesize, src);
 +}
 +
 +static void draw_cbp(uint8_t *dst[3], int dst_linesize[3], int cbp, int amp, int dc)
 +{
 +    if (cbp&1)  draw_basis(dst[0]                    , dst_linesize[0], amp, 1, dc);
 +    if (cbp&2)  draw_basis(dst[0]+8                  , dst_linesize[0], amp, 1, dc);
 +    if (cbp&4)  draw_basis(dst[0]+  8*dst_linesize[0], dst_linesize[0], amp, 1, dc);
 +    if (cbp&8)  draw_basis(dst[0]+8+8*dst_linesize[0], dst_linesize[0], amp, 1, dc);
 +    if (cbp&16) draw_basis(dst[1]                    , dst_linesize[1], amp, 1, dc);
 +    if (cbp&32) draw_basis(dst[2]                    , dst_linesize[2], amp, 1, dc);
 +}
 +
 +static void dc_test(uint8_t *dst, int dst_linesize, int w, int h, int off)
 +{
 +    const int step = FFMAX(256/(w*h/256), 1);
 +    int x, y, color = off;
 +
 +    for (y = 0; y < h; y += 16) {
 +        for (x = 0; x < w; x += 16) {
 +            draw_dc(dst + x + y*dst_linesize, dst_linesize, color, 8, 8);
 +            color += step;
 +        }
 +    }
 +}
 +
 +static void freq_test(uint8_t *dst, int dst_linesize, int off)
 +{
 +    int x, y, freq = 0;
 +
 +    for (y = 0; y < 8*16; y += 16) {
 +        for (x = 0; x < 8*16; x += 16) {
 +            draw_basis(dst + x + y*dst_linesize, dst_linesize, 4*(96+off), freq, 128*8);
 +            freq++;
 +        }
 +    }
 +}
 +
 +static void amp_test(uint8_t *dst, int dst_linesize, int off)
 +{
 +    int x, y, amp = off;
 +
 +    for (y = 0; y < 16*16; y += 16) {
 +        for (x = 0; x < 16*16; x += 16) {
 +            draw_basis(dst + x + y*dst_linesize, dst_linesize, 4*amp, 1, 128*8);
 +            amp++;
 +        }
 +    }
 +}
 +
 +static void cbp_test(uint8_t *dst[3], int dst_linesize[3], int off)
 +{
 +    int x, y, cbp = 0;
 +
 +    for (y = 0; y < 16*8; y += 16) {
 +        for (x = 0; x < 16*8; x += 16) {
 +            uint8_t *dst1[3];
 +            dst1[0] = dst[0] + x*2 + y*2*dst_linesize[0];
 +            dst1[1] = dst[1] + x   + y*  dst_linesize[1];
 +            dst1[2] = dst[2] + x   + y*  dst_linesize[2];
 +
 +            draw_cbp(dst1, dst_linesize, cbp, (64+off)*4, 128*8);
 +            cbp++;
 +        }
 +    }
 +}
 +
 +static void mv_test(uint8_t *dst, int dst_linesize, int off)
 +{
 +    int x, y;
 +
 +    for (y = 0; y < 16*16; y++) {
 +        if (y&16)
 +            continue;
 +        for (x = 0; x < 16*16; x++)
 +            dst[x + y*dst_linesize] = x + off*8/(y/32+1);
 +    }
 +}
 +
 +static void ring1_test(uint8_t *dst, int dst_linesize, int off)
 +{
 +    int x, y, color = 0;
 +
 +    for (y = off; y < 16*16; y += 16) {
 +        for (x = off; x < 16*16; x += 16) {
 +            draw_dc(dst + x + y*dst_linesize, dst_linesize, ((x+y)&16) ? color : -color, 16, 16);
 +            color++;
 +        }
 +    }
 +}
 +
 +static void ring2_test(uint8_t *dst, int dst_linesize, int off)
 +{
 +    int x, y;
 +
 +    for (y = 0; y < 16*16; y++) {
 +        for (x = 0; x < 16*16; x++) {
 +            double d = sqrt((x-8*16)*(x-8*16) + (y-8*16)*(y-8*16));
 +            double r = d/20 - (int)(d/20);
 +            if (r < off/30.0) {
 +                dst[x + y*dst_linesize]     = 255;
 +                dst[x + y*dst_linesize+256] = 0;
 +            } else {
 +                dst[x + y*dst_linesize]     = x;
 +                dst[x + y*dst_linesize+256] = x;
 +            }
 +        }
 +    }
 +}
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args)
 +{
 +    MPTestContext *test = ctx->priv;
 +    AVRational frame_rate_q;
 +    int64_t duration = -1;
 +    int ret;
 +
 +    test->class = &mptestsrc_class;
 +    av_opt_set_defaults(test);
 +
 +    if ((ret = (av_set_options_string(test, args, "=", ":"))) < 0)
 +        return ret;
 +
 +    if ((ret = av_parse_video_rate(&frame_rate_q, test->rate)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: '%s'\n", test->rate);
 +        return ret;
 +    }
 +
 +    if ((test->duration) && (ret = av_parse_time(&duration, test->duration, 1)) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Invalid duration: '%s'\n", test->duration);
 +        return ret;
 +    }
 +
 +    test->time_base.num = frame_rate_q.den;
 +    test->time_base.den = frame_rate_q.num;
 +    test->max_pts = duration >= 0 ?
 +        av_rescale_q(duration, AV_TIME_BASE_Q, test->time_base) : -1;
 +    test->frame_nb = 0;
 +    test->pts = 0;
 +
 +    av_log(ctx, AV_LOG_VERBOSE, "rate:%d/%d duration:%f\n",
 +           frame_rate_q.num, frame_rate_q.den,
 +           duration < 0 ? -1 : test->max_pts * av_q2d(test->time_base));
 +    init_idct();
 +
 +    return 0;
 +}
 +
 +static int config_props(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    MPTestContext *test = ctx->priv;
 +    const AVPixFmtDescriptor *pix_desc = &av_pix_fmt_descriptors[outlink->format];
 +
 +    test->hsub = pix_desc->log2_chroma_w;
 +    test->vsub = pix_desc->log2_chroma_h;
 +
 +    outlink->w = WIDTH;
 +    outlink->h = HEIGHT;
 +    outlink->time_base = test->time_base;
 +
 +    return 0;
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    static const enum PixelFormat pix_fmts[] = {
 +        PIX_FMT_YUV420P, PIX_FMT_NONE
 +    };
 +
 +    ff_set_common_formats(ctx, ff_make_format_list(pix_fmts));
 +    return 0;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    MPTestContext *test = outlink->src->priv;
 +    AVFilterBufferRef *picref;
 +    int w = WIDTH, h = HEIGHT, ch = h>>test->vsub;
 +    unsigned int frame = test->frame_nb;
 +    enum test_type tt = test->test;
 +
 +    if (test->max_pts >= 0 && test->pts > test->max_pts)
 +        return AVERROR_EOF;
 +    picref = ff_get_video_buffer(outlink, AV_PERM_WRITE, w, h);
 +    picref->pts = test->pts++;
 +
 +    // clean image
 +    memset(picref->data[0], 0,   picref->linesize[0] * h);
 +    memset(picref->data[1], 128, picref->linesize[1] * ch);
 +    memset(picref->data[2], 128, picref->linesize[2] * ch);
 +
 +    if (tt == TEST_ALL && frame%30) /* draw a black frame at the beginning of each test */
 +        tt = (frame/30)%(TEST_NB-1);
 +
 +    switch (tt) {
 +    case TEST_DC_LUMA:       dc_test(picref->data[0], picref->linesize[0], 256, 256, frame%30); break;
 +    case TEST_DC_CHROMA:     dc_test(picref->data[1], picref->linesize[1], 256, 256, frame%30); break;
 +    case TEST_FREQ_LUMA:   freq_test(picref->data[0], picref->linesize[0], frame%30); break;
 +    case TEST_FREQ_CHROMA: freq_test(picref->data[1], picref->linesize[1], frame%30); break;
 +    case TEST_AMP_LUMA:     amp_test(picref->data[0], picref->linesize[0], frame%30); break;
 +    case TEST_AMP_CHROMA:   amp_test(picref->data[1], picref->linesize[1], frame%30); break;
 +    case TEST_CBP:          cbp_test(picref->data   , picref->linesize   , frame%30); break;
 +    case TEST_MV:            mv_test(picref->data[0], picref->linesize[0], frame%30); break;
 +    case TEST_RING1:      ring1_test(picref->data[0], picref->linesize[0], frame%30); break;
 +    case TEST_RING2:      ring2_test(picref->data[0], picref->linesize[0], frame%30); break;
 +    }
 +
 +    test->frame_nb++;
 +
 +    ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0));
 +    ff_draw_slice(outlink, 0, picref->video->h, 1);
 +    ff_end_frame(outlink);
 +    avfilter_unref_buffer(picref);
 +
 +    return 0;
 +}
 +
 +AVFilter avfilter_vsrc_mptestsrc = {
 +    .name      = "mptestsrc",
 +    .description = NULL_IF_CONFIG_SMALL("Generate various test pattern."),
 +    .priv_size = sizeof(MPTestContext),
 +    .init      = init,
 +
 +    .query_formats   = query_formats,
 +
 +    .inputs    = (const AVFilterPad[]) {{ .name = NULL}},
 +
 +    .outputs   = (const AVFilterPad[]) {{ .name = "default",
 +                                    .type = AVMEDIA_TYPE_VIDEO,
 +                                    .request_frame = request_frame,
 +                                    .config_props  = config_props, },
 +                                  { .name = NULL }},
 +};
@@@ -412,18 -281,11 +412,18 @@@ static int read_close(struct AVFormatCo
  #define OFFSET(x) offsetof(VideoDemuxData, x)
  #define DEC AV_OPT_FLAG_DECODING_PARAM
  static const AVOption options[] = {
 -    { "pixel_format", "", OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 -    { "video_size",   "", OFFSET(video_size),   AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 -    { "framerate",    "", OFFSET(framerate),    AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
 -    { "loop",         "", OFFSET(loop),         AV_OPT_TYPE_INT,    {.dbl = 0},    0, 1, DEC },
 -    { "start_number", "first number in the sequence", OFFSET(start_number), AV_OPT_TYPE_INT, {.dbl = 1}, 1, INT_MAX, DEC },
 +    { "framerate",    "set the video framerate",             OFFSET(framerate),    AV_OPT_TYPE_STRING, {.str = "25"}, 0, 0, DEC },
 +    { "loop",         "force loop over input file sequence", OFFSET(loop),         AV_OPT_TYPE_INT,    {.dbl = 0},    0, 1, DEC },
 +
 +    { "pattern_type", "set pattern type",                    OFFSET(pattern_type), AV_OPT_TYPE_INT, {.dbl=PT_GLOB_SEQUENCE}, 0, INT_MAX, DEC, "pattern_type"},
-     { "glob_sequence","glob/sequence pattern type",          0, AV_OPT_TYPE_CONST, {.dbl=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
-     { "glob",         "glob pattern type",                   0, AV_OPT_TYPE_CONST, {.dbl=PT_GLOB},          INT_MIN, INT_MAX, DEC, "pattern_type" },
-     { "sequence",     "glob pattern type",                   0, AV_OPT_TYPE_CONST, {.dbl=PT_SEQUENCE},      INT_MIN, INT_MAX, DEC, "pattern_type" },
++    { "glob_sequence","glob/sequence pattern type",          0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB_SEQUENCE}, INT_MIN, INT_MAX, DEC, "pattern_type" },
++    { "glob",         "glob pattern type",                   0, AV_OPT_TYPE_CONST, {.i64=PT_GLOB},          INT_MIN, INT_MAX, DEC, "pattern_type" },
++    { "sequence",     "glob pattern type",                   0, AV_OPT_TYPE_CONST, {.i64=PT_SEQUENCE},      INT_MIN, INT_MAX, DEC, "pattern_type" },
 +
 +    { "pixel_format", "set video pixel format",              OFFSET(pixel_format), AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
 +    { "start_number", "set first number in the sequence",    OFFSET(start_number), AV_OPT_TYPE_INT,    {.dbl = 0},    0, INT_MAX, DEC },
 +    { "start_number_range", "set range for looking at the first sequence number", OFFSET(start_number_range), AV_OPT_TYPE_INT, {.dbl = 5}, 1, INT_MAX, DEC },
 +    { "video_size",   "set video size",                      OFFSET(video_size),   AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, DEC },
      { NULL },
  };
  
  
  static const AVOption options[] = {
      { "movflags", "MOV muxer flags", offsetof(MOVMuxContext, flags), AV_OPT_TYPE_FLAGS, {.dbl = 0}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
-     { "rtphint", "Add RTP hint tracks", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_RTP_HINT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "rtphint", "Add RTP hint tracks", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_RTP_HINT}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
 +    { "moov_size", "maximum moov size so it can be placed at the begin", offsetof(MOVMuxContext, reserved_moov_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, 0 },
-     { "empty_moov", "Make the initial moov atom empty (not supported by QuickTime)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_EMPTY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
-     { "frag_keyframe", "Fragment at video keyframes", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_FRAG_KEYFRAME}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
-     { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
-     { "frag_custom", "Flush fragments on caller requests", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_FRAG_CUSTOM}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
-     { "isml", "Create a live smooth streaming feed (for pushing to a publishing point)", 0, AV_OPT_TYPE_CONST, {.dbl = FF_MOV_FLAG_ISML}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "empty_moov", "Make the initial moov atom empty (not supported by QuickTime)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_EMPTY_MOOV}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "frag_keyframe", "Fragment at video keyframes", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_KEYFRAME}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "separate_moof", "Write separate moof/mdat atoms for each track", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_SEPARATE_MOOF}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "frag_custom", "Flush fragments on caller requests", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_FRAG_CUSTOM}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
+     { "isml", "Create a live smooth streaming feed (for pushing to a publishing point)", 0, AV_OPT_TYPE_CONST, {.i64 = FF_MOV_FLAG_ISML}, INT_MIN, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM, "movflags" },
      FF_RTP_FLAG_OPTS(MOVMuxContext, rtp_flags),
 -    { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.dbl = 0}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
 +    { "skip_iods", "Skip writing iods atom.", offsetof(MOVMuxContext, iods_skip), AV_OPT_TYPE_INT, {.dbl = 1}, 0, 1, AV_OPT_FLAG_ENCODING_PARAM},
      { "iods_audio_profile", "iods audio profile atom.", offsetof(MOVMuxContext, iods_audio_profile), AV_OPT_TYPE_INT, {.dbl = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
      { "iods_video_profile", "iods video profile atom.", offsetof(MOVMuxContext, iods_video_profile), AV_OPT_TYPE_INT, {.dbl = -1}, -1, 255, AV_OPT_FLAG_ENCODING_PARAM},
      { "frag_duration", "Maximum fragment duration", offsetof(MOVMuxContext, max_fragment_duration), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, AV_OPT_FLAG_ENCODING_PARAM},
Simple merge
  #define D AV_OPT_FLAG_DECODING_PARAM
  
  static const AVOption options[]={
- {"direct", "reduce buffering", 0, AV_OPT_TYPE_CONST, {.dbl = AVIO_FLAG_DIRECT }, INT_MIN, INT_MAX, D|E, "avioflags"},
 +{"avioflags", NULL, OFFSET(avio_flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, INT_MIN, INT_MAX, D|E, "avioflags"},
++{"direct", "reduce buffering", 0, AV_OPT_TYPE_CONST, {.i64 = AVIO_FLAG_DIRECT }, INT_MIN, INT_MAX, D|E, "avioflags"},
  {"probesize", "set probing size", OFFSET(probesize), AV_OPT_TYPE_INT, {.dbl = 5000000 }, 32, INT_MAX, D},
  {"packetsize", "set packet size", OFFSET(packet_size), AV_OPT_TYPE_INT, {.dbl = DEFAULT }, 0, INT_MAX, E},
  {"fflags", NULL, OFFSET(flags), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, INT_MIN, INT_MAX, D|E, "fflags"},
- {"ignidx", "ignore index", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_IGNIDX }, INT_MIN, INT_MAX, D, "fflags"},
- {"genpts", "generate pts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_GENPTS }, INT_MIN, INT_MAX, D, "fflags"},
- {"nofillin", "do not fill in missing values that can be exactly calculated", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_NOFILLIN }, INT_MIN, INT_MAX, D, "fflags"},
- {"noparse", "disable AVParsers, this needs nofillin too", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_NOPARSE }, INT_MIN, INT_MAX, D, "fflags"},
- {"igndts", "ignore dts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_IGNDTS }, INT_MIN, INT_MAX, D, "fflags"},
- {"discardcorrupt", "discard corrupted frames", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_DISCARD_CORRUPT }, INT_MIN, INT_MAX, D, "fflags"},
- {"sortdts", "try to interleave outputted packets by dts", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_SORT_DTS }, INT_MIN, INT_MAX, D, "fflags"},
- {"keepside", "dont merge side data", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_KEEP_SIDE_DATA }, INT_MIN, INT_MAX, D, "fflags"},
- {"latm", "enable RTP MP4A-LATM payload", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_MP4A_LATM }, INT_MIN, INT_MAX, E, "fflags"},
- {"nobuffer", "reduce the latency introduced by optional buffering", 0, AV_OPT_TYPE_CONST, {.dbl = AVFMT_FLAG_NOBUFFER }, 0, INT_MAX, D, "fflags"},
+ {"ignidx", "ignore index", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNIDX }, INT_MIN, INT_MAX, D, "fflags"},
+ {"genpts", "generate pts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_GENPTS }, INT_MIN, INT_MAX, D, "fflags"},
+ {"nofillin", "do not fill in missing values that can be exactly calculated", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOFILLIN }, INT_MIN, INT_MAX, D, "fflags"},
+ {"noparse", "disable AVParsers, this needs nofillin too", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOPARSE }, INT_MIN, INT_MAX, D, "fflags"},
+ {"igndts", "ignore dts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_IGNDTS }, INT_MIN, INT_MAX, D, "fflags"},
+ {"discardcorrupt", "discard corrupted frames", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_DISCARD_CORRUPT }, INT_MIN, INT_MAX, D, "fflags"},
++{"sortdts", "try to interleave outputted packets by dts", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_SORT_DTS }, INT_MIN, INT_MAX, D, "fflags"},
++{"keepside", "dont merge side data", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_KEEP_SIDE_DATA }, INT_MIN, INT_MAX, D, "fflags"},
++{"latm", "enable RTP MP4A-LATM payload", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_MP4A_LATM }, INT_MIN, INT_MAX, E, "fflags"},
+ {"nobuffer", "reduce the latency introduced by optional buffering", 0, AV_OPT_TYPE_CONST, {.i64 = AVFMT_FLAG_NOBUFFER }, 0, INT_MAX, D, "fflags"},
  {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), AV_OPT_TYPE_INT, {.dbl = 5*AV_TIME_BASE }, 0, INT_MAX, D},
  {"cryptokey", "decryption key", OFFSET(key), AV_OPT_TYPE_BINARY, {.dbl = 0}, 0, 0, D},
  {"indexmem", "max memory used for timestamp index (per stream)", OFFSET(max_index_size), AV_OPT_TYPE_INT, {.dbl = 1<<20 }, 0, INT_MAX, D},
  {"rtbufsize", "max memory used for buffering real-time frames", OFFSET(max_picture_buffer), AV_OPT_TYPE_INT, {.dbl = 3041280 }, 0, INT_MAX, D}, /* defaults to 1s of 15fps 352x288 YUYV422 video */
  {"fdebug", "print specific debug info", OFFSET(debug), AV_OPT_TYPE_FLAGS, {.dbl = DEFAULT }, 0, INT_MAX, E|D, "fdebug"},
- {"ts", NULL, 0, AV_OPT_TYPE_CONST, {.dbl = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E|D, "fdebug"},
+ {"ts", NULL, 0, AV_OPT_TYPE_CONST, {.i64 = FF_FDEBUG_TS }, INT_MIN, INT_MAX, E|D, "fdebug"},
  {"max_delay", "maximum muxing or demuxing delay in microseconds", OFFSET(max_delay), AV_OPT_TYPE_INT, {.dbl = -1 }, -1, INT_MAX, E|D},
  {"fpsprobesize", "number of frames used to probe fps", OFFSET(fps_probe_size), AV_OPT_TYPE_INT, {.dbl = -1}, -1, INT_MAX-1, D},
 +{"audio_preload", "microseconds by which audio packets should be interleaved earlier", OFFSET(audio_preload), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
 +{"chunk_duration", "microseconds for each chunk", OFFSET(max_chunk_duration), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
 +{"chunk_size", "size in bytes for each chunk", OFFSET(max_chunk_size), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, E},
  /* this is a crutch for avconv, since it cannot deal with identically named options in different contexts.
   * to be removed when avconv is fixed */
  {"f_err_detect", "set error detection flags (deprecated; use err_detect, save via avconv)", OFFSET(error_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
  {"err_detect", "set error detection flags", OFFSET(error_recognition), AV_OPT_TYPE_FLAGS, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
- {"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
- {"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, D, "err_detect"},
- {"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_BUFFER }, INT_MIN, INT_MAX, D, "err_detect"},
- {"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_EXPLODE }, INT_MIN, INT_MAX, D, "err_detect"},
- {"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_CAREFUL }, INT_MIN, INT_MAX, D, "err_detect"},
- {"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, D, "err_detect"},
- {"aggressive", "consider things that a sane encoder shouldnt do as an error", 0, AV_OPT_TYPE_CONST, {.dbl = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"crccheck", "verify embedded CRCs", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CRCCHECK }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"bitstream", "detect bitstream specification deviations", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BITSTREAM }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"buffer", "detect improper bitstream length", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_BUFFER }, INT_MIN, INT_MAX, D, "err_detect"},
+ {"explode", "abort decoding on minor error detection", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_EXPLODE }, INT_MIN, INT_MAX, D, "err_detect"},
++{"careful",    "consider things that violate the spec and have not been seen in the wild as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_CAREFUL }, INT_MIN, INT_MAX, D, "err_detect"},
++{"compliant",  "consider all spec non compliancies as errors", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_COMPLIANT }, INT_MIN, INT_MAX, D, "err_detect"},
++{"aggressive", "consider things that a sane encoder shouldnt do as an error", 0, AV_OPT_TYPE_CONST, {.i64 = AV_EF_AGGRESSIVE }, INT_MIN, INT_MAX, D, "err_detect"},
 +{"use_wallclock_as_timestamps", "use wallclock as timestamps", OFFSET(use_wallclock_as_timestamps), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX-1, D},
  {NULL},
  };
  
Simple merge
Simple merge
Simple merge
@@@ -448,18 -246,11 +448,18 @@@ static int seg_write_trailer(struct AVF
  #define OFFSET(x) offsetof(SegmentContext, x)
  #define E AV_OPT_FLAG_ENCODING_PARAM
  static const AVOption options[] = {
 -    { "segment_format",    "container format used for the segments",  OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 -    { "segment_time",      "segment length in seconds",               OFFSET(time),    AV_OPT_TYPE_FLOAT,  {.dbl = 2},     0, FLT_MAX, E },
 -    { "segment_list",      "output the segment list",                 OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 -    { "segment_list_size", "maximum number of playlist entries",      OFFSET(size),    AV_OPT_TYPE_INT,    {.dbl = 5},     0, INT_MAX, E },
 -    { "segment_wrap",      "number after which the index wraps",      OFFSET(wrap),    AV_OPT_TYPE_INT,    {.dbl = 0},     0, INT_MAX, E },
 +    { "segment_format",    "set container format used for the segments", OFFSET(format),  AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 +    { "segment_list",      "set the segment list filename",              OFFSET(list),    AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 +    { "segment_list_size", "set the maximum number of playlist entries", OFFSET(list_size), AV_OPT_TYPE_INT,  {.dbl = 0},     0, INT_MAX, E },
 +    { "segment_list_type", "set the segment list type",                  OFFSET(list_type), AV_OPT_TYPE_INT,  {.dbl = LIST_TYPE_UNDEFINED}, -1, LIST_TYPE_NB-1, E, "list_type" },
-     { "flat", "flat format",     0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, 0, "list_type" },
-     { "csv",  "csv format",      0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_CSV  }, INT_MIN, INT_MAX, 0, "list_type" },
-     { "ext",  "extended format", 0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_EXT  }, INT_MIN, INT_MAX, 0, "list_type" },
-     { "m3u8", "M3U8 format",     0, AV_OPT_TYPE_CONST, {.dbl=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, 0, "list_type" },
++    { "flat", "flat format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_FLAT }, INT_MIN, INT_MAX, 0, "list_type" },
++    { "csv",  "csv format",      0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_CSV  }, INT_MIN, INT_MAX, 0, "list_type" },
++    { "ext",  "extended format", 0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_EXT  }, INT_MIN, INT_MAX, 0, "list_type" },
++    { "m3u8", "M3U8 format",     0, AV_OPT_TYPE_CONST, {.i64=LIST_TYPE_M3U8 }, INT_MIN, INT_MAX, 0, "list_type" },
 +    { "segment_time",      "set segment duration",                       OFFSET(time_str),AV_OPT_TYPE_STRING, {.str = NULL},  0, 0,       E },
 +    { "segment_time_delta","set approximation value used for the segment times", OFFSET(time_delta_str), AV_OPT_TYPE_STRING, {.str = "0"}, 0, 0, E },
 +    { "segment_times",     "set segment split time points",              OFFSET(times_str),AV_OPT_TYPE_STRING,{.str = NULL},  0, 0,       E },
 +    { "segment_wrap",      "set number after which the index wraps",     OFFSET(segment_idx_wrap), AV_OPT_TYPE_INT, {.dbl = 0}, 0, INT_MAX, E },
      { NULL },
  };
  
Simple merge
diff --cc libavutil/cpu.c
@@@ -111,50 -109,6 +111,50 @@@ int av_parse_cpu_flags(const char *s
      return flags & INT_MAX;
  }
  
-         { "altivec" , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_ALTIVEC  },    .unit = "flags" },
 +int av_parse_cpu_caps(unsigned *flags, const char *s)
 +{
 +        static const AVOption cpuflags_opts[] = {
 +        { "flags"   , NULL, 0, AV_OPT_TYPE_FLAGS, { 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
 +#if   ARCH_PPC
-         { "mmx"     , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_MMX      },    .unit = "flags" },
-         { "mmx2"    , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_MMX2     },    .unit = "flags" },
-         { "mmxext"  , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_MMX2     },    .unit = "flags" },
-         { "sse"     , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE      },    .unit = "flags" },
-         { "sse2"    , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE2     },    .unit = "flags" },
-         { "sse2slow", NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE2SLOW },    .unit = "flags" },
-         { "sse3"    , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE3     },    .unit = "flags" },
-         { "sse3slow", NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE3SLOW },    .unit = "flags" },
-         { "ssse3"   , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSSE3    },    .unit = "flags" },
-         { "atom"    , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_ATOM     },    .unit = "flags" },
-         { "sse4.1"  , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE4     },    .unit = "flags" },
-         { "sse4.2"  , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_SSE42    },    .unit = "flags" },
-         { "avx"     , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_AVX      },    .unit = "flags" },
-         { "xop"     , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_XOP      },    .unit = "flags" },
-         { "fma4"    , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_FMA4     },    .unit = "flags" },
-         { "3dnow"   , NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_3DNOW    },    .unit = "flags" },
-         { "3dnowext", NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_3DNOWEXT },    .unit = "flags" },
++        { "altivec" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ALTIVEC  },    .unit = "flags" },
 +#elif ARCH_X86
-         { "armv5te",  NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_ARMV5TE  },    .unit = "flags" },
-         { "armv6",    NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_ARMV6    },    .unit = "flags" },
-         { "armv6t2",  NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_ARMV6T2  },    .unit = "flags" },
-         { "vfp",      NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_VFP      },    .unit = "flags" },
-         { "vfpv3",    NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_VFPV3    },    .unit = "flags" },
-         { "neon",     NULL, 0, AV_OPT_TYPE_CONST, { AV_CPU_FLAG_NEON     },    .unit = "flags" },
++        { "mmx"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX      },    .unit = "flags" },
++        { "mmx2"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2     },    .unit = "flags" },
++        { "mmxext"  , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_MMX2     },    .unit = "flags" },
++        { "sse"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE      },    .unit = "flags" },
++        { "sse2"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2     },    .unit = "flags" },
++        { "sse2slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE2SLOW },    .unit = "flags" },
++        { "sse3"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3     },    .unit = "flags" },
++        { "sse3slow", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE3SLOW },    .unit = "flags" },
++        { "ssse3"   , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSSE3    },    .unit = "flags" },
++        { "atom"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ATOM     },    .unit = "flags" },
++        { "sse4.1"  , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE4     },    .unit = "flags" },
++        { "sse4.2"  , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_SSE42    },    .unit = "flags" },
++        { "avx"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_AVX      },    .unit = "flags" },
++        { "xop"     , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_XOP      },    .unit = "flags" },
++        { "fma4"    , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_FMA4     },    .unit = "flags" },
++        { "3dnow"   , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOW    },    .unit = "flags" },
++        { "3dnowext", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_3DNOWEXT },    .unit = "flags" },
 +#elif ARCH_ARM
++        { "armv5te",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV5TE  },    .unit = "flags" },
++        { "armv6",    NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6    },    .unit = "flags" },
++        { "armv6t2",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_ARMV6T2  },    .unit = "flags" },
++        { "vfp",      NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFP      },    .unit = "flags" },
++        { "vfpv3",    NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_VFPV3    },    .unit = "flags" },
++        { "neon",     NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_CPU_FLAG_NEON     },    .unit = "flags" },
 +#endif
 +        { NULL },
 +    };
 +    static const AVClass class = {
 +        .class_name = "cpuflags",
 +        .item_name  = av_default_item_name,
 +        .option     = cpuflags_opts,
 +        .version    = LIBAVUTIL_VERSION_INT,
 +    };
 +    const AVClass *pclass = &class;
 +
 +    return av_opt_eval_flags(&pclass, &cpuflags_opts[0], s, flags);
 +}
  #ifdef TEST
  
  #undef printf
diff --cc libavutil/opt.c
@@@ -911,11 -859,9 +912,11 @@@ static const AVOption test_options[]= 
  {"rational", "set rational",   OFFSET(rational), AV_OPT_TYPE_RATIONAL, {0},              0,        10                  },
  {"string",   "set string",     OFFSET(string),   AV_OPT_TYPE_STRING,   {0},              CHAR_MIN, CHAR_MAX            },
  {"flags",    "set flags",      OFFSET(flags),    AV_OPT_TYPE_FLAGS,    {0},              0,        INT_MAX, 0, "flags" },
- {"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
- {"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
- {"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
+ {"cool",     "set cool flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_COOL}, INT_MIN,  INT_MAX, 0, "flags" },
+ {"lame",     "set lame flag ", 0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_LAME}, INT_MIN,  INT_MAX, 0, "flags" },
+ {"mu",       "set mu flag ",   0,                AV_OPT_TYPE_CONST,    {.i64 = TEST_FLAG_MU},   INT_MIN,  INT_MAX, 0, "flags" },
 +{"size",     "set size",       OFFSET(w),        AV_OPT_TYPE_IMAGE_SIZE,{0},             0,        0                   },
 +{"pix_fmt",  "set pixfmt",     OFFSET(pix_fmt),  AV_OPT_TYPE_PIXEL_FMT,{0},              0,        0                   },
  {NULL},
  };
  
index c148747,0000000..dbf94d4
mode 100644,000000..100644
--- /dev/null
@@@ -1,789 -1,0 +1,789 @@@
- {"res"                  , "Force Resampling"            , 0                      , AV_OPT_TYPE_CONST, {.dbl=SWR_FLAG_RESAMPLE     }, INT_MIN, INT_MAX   , PARAM, "flags"},
 +/*
 + * Copyright (C) 2011-2012 Michael Niedermayer (michaelni@gmx.at)
 + *
 + * This file is part of libswresample
 + *
 + * libswresample 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.
 + *
 + * libswresample 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 libswresample; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/opt.h"
 +#include "swresample_internal.h"
 +#include "audioconvert.h"
 +#include "libavutil/avassert.h"
 +#include "libavutil/audioconvert.h"
 +
 +#include <float.h>
 +
 +#define  C30DB  M_SQRT2
 +#define  C15DB  1.189207115
 +#define C__0DB  1.0
 +#define C_15DB  0.840896415
 +#define C_30DB  M_SQRT1_2
 +#define C_45DB  0.594603558
 +#define C_60DB  0.5
 +
 +#define ALIGN 32
 +
 +//TODO split options array out?
 +#define OFFSET(x) offsetof(SwrContext,x)
 +#define PARAM AV_OPT_FLAG_AUDIO_PARAM
 +
 +static const AVOption options[]={
 +{"ich"                  ,  "Input Channel Count"        , OFFSET( in.ch_count   ), AV_OPT_TYPE_INT  , {.dbl=2                     }, 0      , SWR_CH_MAX, PARAM},
 +{"in_channel_count"     ,  "Input Channel Count"        , OFFSET( in.ch_count   ), AV_OPT_TYPE_INT  , {.dbl=2                     }, 0      , SWR_CH_MAX, PARAM},
 +{"och"                  , "Output Channel Count"        , OFFSET(out.ch_count   ), AV_OPT_TYPE_INT  , {.dbl=2                     }, 0      , SWR_CH_MAX, PARAM},
 +{"out_channel_count"    , "Output Channel Count"        , OFFSET(out.ch_count   ), AV_OPT_TYPE_INT  , {.dbl=2                     }, 0      , SWR_CH_MAX, PARAM},
 +{"uch"                  ,   "Used Channel Count"        , OFFSET(used_ch_count  ), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , SWR_CH_MAX, PARAM},
 +{"used_channel_count"   ,   "Used Channel Count"        , OFFSET(used_ch_count  ), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , SWR_CH_MAX, PARAM},
 +{"isr"                  ,  "Input Sample Rate"          , OFFSET( in_sample_rate), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , INT_MAX   , PARAM},
 +{"in_sample_rate"       ,  "Input Sample Rate"          , OFFSET( in_sample_rate), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , INT_MAX   , PARAM},
 +{"osr"                  , "Output Sample Rate"          , OFFSET(out_sample_rate), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , INT_MAX   , PARAM},
 +{"out_sample_rate"      , "Output Sample Rate"          , OFFSET(out_sample_rate), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , INT_MAX   , PARAM},
 +{"isf"                  ,    "Input Sample Format"      , OFFSET( in_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_NB-1+256, PARAM},
 +{"in_sample_fmt"        ,    "Input Sample Format"      , OFFSET( in_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_NB-1+256, PARAM},
 +{"osf"                  ,   "Output Sample Format"      , OFFSET(out_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_NB-1+256, PARAM},
 +{"out_sample_fmt"       ,   "Output Sample Format"      , OFFSET(out_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_NB-1+256, PARAM},
 +{"tsf"                  , "Internal Sample Format"      , OFFSET(int_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_FLTP, PARAM},
 +{"internal_sample_fmt"  , "Internal Sample Format"      , OFFSET(int_sample_fmt ), AV_OPT_TYPE_INT  , {.dbl=AV_SAMPLE_FMT_NONE    }, -1     , AV_SAMPLE_FMT_FLTP, PARAM},
 +{"icl"                  ,   "Input Channel Layout"      , OFFSET( in_ch_layout  ), AV_OPT_TYPE_INT64, {.i64=0                     }, 0      , INT64_MAX , PARAM, "channel_layout"},
 +{"in_channel_layout"    ,   "Input Channel Layout"      , OFFSET( in_ch_layout  ), AV_OPT_TYPE_INT64, {.i64=0                     }, 0      , INT64_MAX , PARAM, "channel_layout"},
 +{"ocl"                  ,  "Output Channel Layout"      , OFFSET(out_ch_layout  ), AV_OPT_TYPE_INT64, {.i64=0                     }, 0      , INT64_MAX , PARAM, "channel_layout"},
 +{"out_channel_layout"   ,  "Output Channel Layout"      , OFFSET(out_ch_layout  ), AV_OPT_TYPE_INT64, {.i64=0                     }, 0      , INT64_MAX , PARAM, "channel_layout"},
 +{"clev"                 ,    "Center Mix Level"         , OFFSET(clev           ), AV_OPT_TYPE_FLOAT, {.dbl=C_30DB                }, -32    , 32        , PARAM},
 +{"center_mix_level"     ,    "Center Mix Level"         , OFFSET(clev           ), AV_OPT_TYPE_FLOAT, {.dbl=C_30DB                }, -32    , 32        , PARAM},
 +{"slev"                 , "Sourround Mix Level"         , OFFSET(slev           ), AV_OPT_TYPE_FLOAT, {.dbl=C_30DB                }, -32    , 32        , PARAM},
 +{"surround_mix_level"   , "Sourround Mix Level"         , OFFSET(slev           ), AV_OPT_TYPE_FLOAT, {.dbl=C_30DB                }, -32    , 32        , PARAM},
 +{"lfe_mix_level"        , "LFE Mix Level"               , OFFSET(lfe_mix_level  ), AV_OPT_TYPE_FLOAT, {.dbl=0                     }, -32    , 32        , PARAM},
 +{"rmvol"                , "Rematrix Volume"             , OFFSET(rematrix_volume), AV_OPT_TYPE_FLOAT, {.dbl=1.0                   }, -1000  , 1000      , PARAM},
 +{"rematrix_volume"      , "Rematrix Volume"             , OFFSET(rematrix_volume), AV_OPT_TYPE_FLOAT, {.dbl=1.0                   }, -1000  , 1000      , PARAM},
 +{"flags"                , NULL                          , OFFSET(flags          ), AV_OPT_TYPE_FLAGS, {.dbl=0                     }, 0      , UINT_MAX  , PARAM, "flags"},
 +{"swr_flags"            , NULL                          , OFFSET(flags          ), AV_OPT_TYPE_FLAGS, {.dbl=0                     }, 0      , UINT_MAX  , PARAM, "flags"},
- {"rectangular"          , "Rectangular Dither"          , 0                      , AV_OPT_TYPE_CONST, {.dbl=SWR_DITHER_RECTANGULAR}, INT_MIN, INT_MAX   , PARAM, "dither_method"},
- {"triangular"           ,  "Triangular Dither"          , 0                      , AV_OPT_TYPE_CONST, {.dbl=SWR_DITHER_TRIANGULAR }, INT_MIN, INT_MAX   , PARAM, "dither_method"},
- {"triangular_hp"        , "Triangular Dither With High Pass" , 0                 , AV_OPT_TYPE_CONST, {.dbl=SWR_DITHER_TRIANGULAR_HIGHPASS }, INT_MIN, INT_MAX, PARAM, "dither_method"},
++{"res"                  , "Force Resampling"            , 0                      , AV_OPT_TYPE_CONST, {.i64=SWR_FLAG_RESAMPLE     }, INT_MIN, INT_MAX   , PARAM, "flags"},
 +{"dither_scale"         , "Dither Scale"                , OFFSET(dither_scale   ), AV_OPT_TYPE_FLOAT, {.dbl=1                     }, 0      , INT_MAX   , PARAM},
 +{"dither_method"        , "Dither Method"               , OFFSET(dither_method  ), AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , SWR_DITHER_NB-1, PARAM, "dither_method"},
-     { "cubic"           , "Cubic"                       , 0                      , AV_OPT_TYPE_CONST, { SWR_FILTER_TYPE_CUBIC            }, INT_MIN, INT_MAX, PARAM, "filter_type" },
-     { "blackman_nuttall", "Blackman Nuttall Windowed Sinc", 0                    , AV_OPT_TYPE_CONST, { SWR_FILTER_TYPE_BLACKMAN_NUTTALL }, INT_MIN, INT_MAX, PARAM, "filter_type" },
-     { "kaiser"          , "Kaiser Windowed Sinc"        , 0                      , AV_OPT_TYPE_CONST, { SWR_FILTER_TYPE_KAISER           }, INT_MIN, INT_MAX, PARAM, "filter_type" },
++{"rectangular"          , "Rectangular Dither"          , 0                      , AV_OPT_TYPE_CONST, {.i64=SWR_DITHER_RECTANGULAR}, INT_MIN, INT_MAX   , PARAM, "dither_method"},
++{"triangular"           ,  "Triangular Dither"          , 0                      , AV_OPT_TYPE_CONST, {.i64=SWR_DITHER_TRIANGULAR }, INT_MIN, INT_MAX   , PARAM, "dither_method"},
++{"triangular_hp"        , "Triangular Dither With High Pass" , 0                 , AV_OPT_TYPE_CONST, {.i64=SWR_DITHER_TRIANGULAR_HIGHPASS }, INT_MIN, INT_MAX, PARAM, "dither_method"},
 +{"filter_size"          , "Resampling Filter Size"      , OFFSET(filter_size)    , AV_OPT_TYPE_INT  , {.dbl=16                    }, 0      , INT_MAX   , PARAM },
 +{"phase_shift"          , "Resampling Phase Shift"      , OFFSET(phase_shift)    , AV_OPT_TYPE_INT  , {.dbl=10                    }, 0      , 30        , PARAM },
 +{"linear_interp"        , "Use Linear Interpolation"    , OFFSET(linear_interp)  , AV_OPT_TYPE_INT  , {.dbl=0                     }, 0      , 1         , PARAM },
 +{"cutoff"               , "Cutoff Frequency Ratio"      , OFFSET(cutoff)         , AV_OPT_TYPE_DOUBLE,{.dbl=0.8                   }, 0      , 1         , PARAM },
 +{"min_comp"             , "Minimum difference between timestamps and audio data (in seconds) below which no timestamp compensation of either kind is applied"
 +                                                        , OFFSET(min_compensation),AV_OPT_TYPE_FLOAT ,{.dbl=FLT_MAX               }, 0      , FLT_MAX   , PARAM },
 +{"min_hard_comp"        , "Minimum difference between timestamps and audio data (in seconds) to trigger padding/trimming the data."
 +                                                   , OFFSET(min_hard_compensation),AV_OPT_TYPE_FLOAT ,{.dbl=0.1                   }, 0      , INT_MAX   , PARAM },
 +{"comp_duration"        , "Duration (in seconds) over which data is stretched/squeezed to make it match the timestamps."
 +                                              , OFFSET(soft_compensation_duration),AV_OPT_TYPE_FLOAT ,{.dbl=1                     }, 0      , INT_MAX   , PARAM },
 +{"max_soft_comp"        , "Maximum factor by which data is stretched/squeezed to make it match the timestamps."
 +                                                   , OFFSET(max_soft_compensation),AV_OPT_TYPE_FLOAT ,{.dbl=0                     }, INT_MIN, INT_MAX   , PARAM },
 +{ "filter_type"         , "Filter Type"                 , OFFSET(filter_type)    , AV_OPT_TYPE_INT  , { SWR_FILTER_TYPE_KAISER }, SWR_FILTER_TYPE_CUBIC, SWR_FILTER_TYPE_KAISER, PARAM, "filter_type" },
++    { "cubic"           , "Cubic"                       , 0                      , AV_OPT_TYPE_CONST, { .i64 = SWR_FILTER_TYPE_CUBIC            }, INT_MIN, INT_MAX, PARAM, "filter_type" },
++    { "blackman_nuttall", "Blackman Nuttall Windowed Sinc", 0                    , AV_OPT_TYPE_CONST, { .i64 = SWR_FILTER_TYPE_BLACKMAN_NUTTALL }, INT_MIN, INT_MAX, PARAM, "filter_type" },
++    { "kaiser"          , "Kaiser Windowed Sinc"        , 0                      , AV_OPT_TYPE_CONST, { .i64 = SWR_FILTER_TYPE_KAISER           }, INT_MIN, INT_MAX, PARAM, "filter_type" },
 +{ "kaiser_beta"         , "Kaiser Window Beta"          ,OFFSET(kaiser_beta)     , AV_OPT_TYPE_INT  , {.dbl=9                     }, 2      , 16        , PARAM },
 +
 +{0}
 +};
 +
 +static const char* context_to_name(void* ptr) {
 +    return "SWR";
 +}
 +
 +static const AVClass av_class = {
 +    .class_name                = "SWResampler",
 +    .item_name                 = context_to_name,
 +    .option                    = options,
 +    .version                   = LIBAVUTIL_VERSION_INT,
 +    .log_level_offset_offset   = OFFSET(log_level_offset),
 +    .parent_log_context_offset = OFFSET(log_ctx),
 +    .category                  = AV_CLASS_CATEGORY_SWRESAMPLER,
 +};
 +
 +unsigned swresample_version(void)
 +{
 +    av_assert0(LIBSWRESAMPLE_VERSION_MICRO >= 100);
 +    return LIBSWRESAMPLE_VERSION_INT;
 +}
 +
 +const char *swresample_configuration(void)
 +{
 +    return FFMPEG_CONFIGURATION;
 +}
 +
 +const char *swresample_license(void)
 +{
 +#define LICENSE_PREFIX "libswresample license: "
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +}
 +
 +int swr_set_channel_mapping(struct SwrContext *s, const int *channel_map){
 +    if(!s || s->in_convert) // s needs to be allocated but not initialized
 +        return AVERROR(EINVAL);
 +    s->channel_map = channel_map;
 +    return 0;
 +}
 +
 +const AVClass *swr_get_class(void)
 +{
 +    return &av_class;
 +}
 +
 +struct SwrContext *swr_alloc(void){
 +    SwrContext *s= av_mallocz(sizeof(SwrContext));
 +    if(s){
 +        s->av_class= &av_class;
 +        av_opt_set_defaults(s);
 +    }
 +    return s;
 +}
 +
 +struct SwrContext *swr_alloc_set_opts(struct SwrContext *s,
 +                                      int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int out_sample_rate,
 +                                      int64_t  in_ch_layout, enum AVSampleFormat  in_sample_fmt, int  in_sample_rate,
 +                                      int log_offset, void *log_ctx){
 +    if(!s) s= swr_alloc();
 +    if(!s) return NULL;
 +
 +    s->log_level_offset= log_offset;
 +    s->log_ctx= log_ctx;
 +
 +    av_opt_set_int(s, "ocl", out_ch_layout,   0);
 +    av_opt_set_int(s, "osf", out_sample_fmt,  0);
 +    av_opt_set_int(s, "osr", out_sample_rate, 0);
 +    av_opt_set_int(s, "icl", in_ch_layout,    0);
 +    av_opt_set_int(s, "isf", in_sample_fmt,   0);
 +    av_opt_set_int(s, "isr", in_sample_rate,  0);
 +    av_opt_set_int(s, "tsf", AV_SAMPLE_FMT_NONE,   0);
 +    av_opt_set_int(s, "ich", av_get_channel_layout_nb_channels(s-> in_ch_layout), 0);
 +    av_opt_set_int(s, "och", av_get_channel_layout_nb_channels(s->out_ch_layout), 0);
 +    av_opt_set_int(s, "uch", 0, 0);
 +    return s;
 +}
 +
 +static void set_audiodata_fmt(AudioData *a, enum AVSampleFormat fmt){
 +    a->fmt   = fmt;
 +    a->bps   = av_get_bytes_per_sample(fmt);
 +    a->planar= av_sample_fmt_is_planar(fmt);
 +}
 +
 +static void free_temp(AudioData *a){
 +    av_free(a->data);
 +    memset(a, 0, sizeof(*a));
 +}
 +
 +void swr_free(SwrContext **ss){
 +    SwrContext *s= *ss;
 +    if(s){
 +        free_temp(&s->postin);
 +        free_temp(&s->midbuf);
 +        free_temp(&s->preout);
 +        free_temp(&s->in_buffer);
 +        free_temp(&s->dither);
 +        swri_audio_convert_free(&s-> in_convert);
 +        swri_audio_convert_free(&s->out_convert);
 +        swri_audio_convert_free(&s->full_convert);
 +        swri_resample_free(&s->resample);
 +        swri_rematrix_free(s);
 +    }
 +
 +    av_freep(ss);
 +}
 +
 +int swr_init(struct SwrContext *s){
 +    s->in_buffer_index= 0;
 +    s->in_buffer_count= 0;
 +    s->resample_in_constraint= 0;
 +    free_temp(&s->postin);
 +    free_temp(&s->midbuf);
 +    free_temp(&s->preout);
 +    free_temp(&s->in_buffer);
 +    free_temp(&s->dither);
 +    swri_audio_convert_free(&s-> in_convert);
 +    swri_audio_convert_free(&s->out_convert);
 +    swri_audio_convert_free(&s->full_convert);
 +    swri_rematrix_free(s);
 +
 +    s->flushed = 0;
 +
 +    if(s-> in_sample_fmt >= AV_SAMPLE_FMT_NB){
 +        av_log(s, AV_LOG_ERROR, "Requested input sample format %d is invalid\n", s->in_sample_fmt);
 +        return AVERROR(EINVAL);
 +    }
 +    if(s->out_sample_fmt >= AV_SAMPLE_FMT_NB){
 +        av_log(s, AV_LOG_ERROR, "Requested output sample format %d is invalid\n", s->out_sample_fmt);
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if(s->int_sample_fmt == AV_SAMPLE_FMT_NONE){
 +        if(av_get_planar_sample_fmt(s->in_sample_fmt) <= AV_SAMPLE_FMT_S16P){
 +            s->int_sample_fmt= AV_SAMPLE_FMT_S16P;
 +        }else if(av_get_planar_sample_fmt(s->in_sample_fmt) <= AV_SAMPLE_FMT_FLTP){
 +            s->int_sample_fmt= AV_SAMPLE_FMT_FLTP;
 +        }else{
 +            av_log(s, AV_LOG_DEBUG, "Using double precision mode\n");
 +            s->int_sample_fmt= AV_SAMPLE_FMT_DBLP;
 +        }
 +    }
 +
 +    if(   s->int_sample_fmt != AV_SAMPLE_FMT_S16P
 +        &&s->int_sample_fmt != AV_SAMPLE_FMT_S32P
 +        &&s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
 +        &&s->int_sample_fmt != AV_SAMPLE_FMT_DBLP){
 +        av_log(s, AV_LOG_ERROR, "Requested sample format %s is not supported internally, S16/S32/FLT/DBL is supported\n", av_get_sample_fmt_name(s->int_sample_fmt));
 +        return AVERROR(EINVAL);
 +    }
 +
 +    set_audiodata_fmt(&s-> in, s-> in_sample_fmt);
 +    set_audiodata_fmt(&s->out, s->out_sample_fmt);
 +
 +    if (s->out_sample_rate!=s->in_sample_rate || (s->flags & SWR_FLAG_RESAMPLE)){
 +        s->resample = swri_resample_init(s->resample, s->out_sample_rate, s->in_sample_rate, s->filter_size, s->phase_shift, s->linear_interp, s->cutoff, s->int_sample_fmt, s->filter_type, s->kaiser_beta);
 +    }else
 +        swri_resample_free(&s->resample);
 +    if(    s->int_sample_fmt != AV_SAMPLE_FMT_S16P
 +        && s->int_sample_fmt != AV_SAMPLE_FMT_S32P
 +        && s->int_sample_fmt != AV_SAMPLE_FMT_FLTP
 +        && s->int_sample_fmt != AV_SAMPLE_FMT_DBLP
 +        && s->resample){
 +        av_log(s, AV_LOG_ERROR, "Resampling only supported with internal s16/s32/flt/dbl\n");
 +        return -1;
 +    }
 +
 +    if(!s->used_ch_count)
 +        s->used_ch_count= s->in.ch_count;
 +
 +    if(s->used_ch_count && s-> in_ch_layout && s->used_ch_count != av_get_channel_layout_nb_channels(s-> in_ch_layout)){
 +        av_log(s, AV_LOG_WARNING, "Input channel layout has a different number of channels than the number of used channels, ignoring layout\n");
 +        s-> in_ch_layout= 0;
 +    }
 +
 +    if(!s-> in_ch_layout)
 +        s-> in_ch_layout= av_get_default_channel_layout(s->used_ch_count);
 +    if(!s->out_ch_layout)
 +        s->out_ch_layout= av_get_default_channel_layout(s->out.ch_count);
 +
 +    s->rematrix= s->out_ch_layout  !=s->in_ch_layout || s->rematrix_volume!=1.0 ||
 +                 s->rematrix_custom;
 +
 +#define RSC 1 //FIXME finetune
 +    if(!s-> in.ch_count)
 +        s-> in.ch_count= av_get_channel_layout_nb_channels(s-> in_ch_layout);
 +    if(!s->used_ch_count)
 +        s->used_ch_count= s->in.ch_count;
 +    if(!s->out.ch_count)
 +        s->out.ch_count= av_get_channel_layout_nb_channels(s->out_ch_layout);
 +
 +    if(!s-> in.ch_count){
 +        av_assert0(!s->in_ch_layout);
 +        av_log(s, AV_LOG_ERROR, "Input channel count and layout are unset\n");
 +        return -1;
 +    }
 +
 +    if ((!s->out_ch_layout || !s->in_ch_layout) && s->used_ch_count != s->out.ch_count && !s->rematrix_custom) {
 +        av_log(s, AV_LOG_ERROR, "Rematrix is needed but there is not enough information to do it\n");
 +        return -1;
 +    }
 +
 +av_assert0(s->used_ch_count);
 +av_assert0(s->out.ch_count);
 +    s->resample_first= RSC*s->out.ch_count/s->in.ch_count - RSC < s->out_sample_rate/(float)s-> in_sample_rate - 1.0;
 +
 +    s->in_buffer= s->in;
 +
 +    if(!s->resample && !s->rematrix && !s->channel_map && !s->dither_method){
 +        s->full_convert = swri_audio_convert_alloc(s->out_sample_fmt,
 +                                                   s-> in_sample_fmt, s-> in.ch_count, NULL, 0);
 +        return 0;
 +    }
 +
 +    s->in_convert = swri_audio_convert_alloc(s->int_sample_fmt,
 +                                             s-> in_sample_fmt, s->used_ch_count, s->channel_map, 0);
 +    s->out_convert= swri_audio_convert_alloc(s->out_sample_fmt,
 +                                             s->int_sample_fmt, s->out.ch_count, NULL, 0);
 +
 +
 +    s->postin= s->in;
 +    s->preout= s->out;
 +    s->midbuf= s->in;
 +
 +    if(s->channel_map){
 +        s->postin.ch_count=
 +        s->midbuf.ch_count= s->used_ch_count;
 +        if(s->resample)
 +            s->in_buffer.ch_count= s->used_ch_count;
 +    }
 +    if(!s->resample_first){
 +        s->midbuf.ch_count= s->out.ch_count;
 +        if(s->resample)
 +            s->in_buffer.ch_count = s->out.ch_count;
 +    }
 +
 +    set_audiodata_fmt(&s->postin, s->int_sample_fmt);
 +    set_audiodata_fmt(&s->midbuf, s->int_sample_fmt);
 +    set_audiodata_fmt(&s->preout, s->int_sample_fmt);
 +
 +    if(s->resample){
 +        set_audiodata_fmt(&s->in_buffer, s->int_sample_fmt);
 +    }
 +
 +    s->dither = s->preout;
 +
 +    if(s->rematrix || s->dither_method)
 +        return swri_rematrix_init(s);
 +
 +    return 0;
 +}
 +
 +static int realloc_audio(AudioData *a, int count){
 +    int i, countb;
 +    AudioData old;
 +
 +    if(count < 0 || count > INT_MAX/2/a->bps/a->ch_count)
 +        return AVERROR(EINVAL);
 +
 +    if(a->count >= count)
 +        return 0;
 +
 +    count*=2;
 +
 +    countb= FFALIGN(count*a->bps, ALIGN);
 +    old= *a;
 +
 +    av_assert0(a->bps);
 +    av_assert0(a->ch_count);
 +
 +    a->data= av_mallocz(countb*a->ch_count);
 +    if(!a->data)
 +        return AVERROR(ENOMEM);
 +    for(i=0; i<a->ch_count; i++){
 +        a->ch[i]= a->data + i*(a->planar ? countb : a->bps);
 +        if(a->planar) memcpy(a->ch[i], old.ch[i], a->count*a->bps);
 +    }
 +    if(!a->planar) memcpy(a->ch[0], old.ch[0], a->count*a->ch_count*a->bps);
 +    av_free(old.data);
 +    a->count= count;
 +
 +    return 1;
 +}
 +
 +static void copy(AudioData *out, AudioData *in,
 +                 int count){
 +    av_assert0(out->planar == in->planar);
 +    av_assert0(out->bps == in->bps);
 +    av_assert0(out->ch_count == in->ch_count);
 +    if(out->planar){
 +        int ch;
 +        for(ch=0; ch<out->ch_count; ch++)
 +            memcpy(out->ch[ch], in->ch[ch], count*out->bps);
 +    }else
 +        memcpy(out->ch[0], in->ch[0], count*out->ch_count*out->bps);
 +}
 +
 +static void fill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
 +    int i;
 +    if(!in_arg){
 +        memset(out->ch, 0, sizeof(out->ch));
 +    }else if(out->planar){
 +        for(i=0; i<out->ch_count; i++)
 +            out->ch[i]= in_arg[i];
 +    }else{
 +        for(i=0; i<out->ch_count; i++)
 +            out->ch[i]= in_arg[0] + i*out->bps;
 +    }
 +}
 +
 +static void reversefill_audiodata(AudioData *out, uint8_t *in_arg [SWR_CH_MAX]){
 +    int i;
 +    if(out->planar){
 +        for(i=0; i<out->ch_count; i++)
 +            in_arg[i]= out->ch[i];
 +    }else{
 +        in_arg[0]= out->ch[0];
 +    }
 +}
 +
 +/**
 + *
 + * out may be equal in.
 + */
 +static void buf_set(AudioData *out, AudioData *in, int count){
 +    int ch;
 +    if(in->planar){
 +        for(ch=0; ch<out->ch_count; ch++)
 +            out->ch[ch]= in->ch[ch] + count*out->bps;
 +    }else{
 +        for(ch=out->ch_count-1; ch>=0; ch--)
 +            out->ch[ch]= in->ch[0] + (ch + count*out->ch_count) * out->bps;
 +    }
 +}
 +
 +/**
 + *
 + * @return number of samples output per channel
 + */
 +static int resample(SwrContext *s, AudioData *out_param, int out_count,
 +                             const AudioData * in_param, int in_count){
 +    AudioData in, out, tmp;
 +    int ret_sum=0;
 +    int border=0;
 +
 +    av_assert1(s->in_buffer.ch_count == in_param->ch_count);
 +    av_assert1(s->in_buffer.planar   == in_param->planar);
 +    av_assert1(s->in_buffer.fmt      == in_param->fmt);
 +
 +    tmp=out=*out_param;
 +    in =  *in_param;
 +
 +    do{
 +        int ret, size, consumed;
 +        if(!s->resample_in_constraint && s->in_buffer_count){
 +            buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
 +            ret= swri_multiple_resample(s->resample, &out, out_count, &tmp, s->in_buffer_count, &consumed);
 +            out_count -= ret;
 +            ret_sum += ret;
 +            buf_set(&out, &out, ret);
 +            s->in_buffer_count -= consumed;
 +            s->in_buffer_index += consumed;
 +
 +            if(!in_count)
 +                break;
 +            if(s->in_buffer_count <= border){
 +                buf_set(&in, &in, -s->in_buffer_count);
 +                in_count += s->in_buffer_count;
 +                s->in_buffer_count=0;
 +                s->in_buffer_index=0;
 +                border = 0;
 +            }
 +        }
 +
 +        if(in_count && !s->in_buffer_count){
 +            s->in_buffer_index=0;
 +            ret= swri_multiple_resample(s->resample, &out, out_count, &in, in_count, &consumed);
 +            out_count -= ret;
 +            ret_sum += ret;
 +            buf_set(&out, &out, ret);
 +            in_count -= consumed;
 +            buf_set(&in, &in, consumed);
 +        }
 +
 +        //TODO is this check sane considering the advanced copy avoidance below
 +        size= s->in_buffer_index + s->in_buffer_count + in_count;
 +        if(   size > s->in_buffer.count
 +           && s->in_buffer_count + in_count <= s->in_buffer_index){
 +            buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
 +            copy(&s->in_buffer, &tmp, s->in_buffer_count);
 +            s->in_buffer_index=0;
 +        }else
 +            if((ret=realloc_audio(&s->in_buffer, size)) < 0)
 +                return ret;
 +
 +        if(in_count){
 +            int count= in_count;
 +            if(s->in_buffer_count && s->in_buffer_count+2 < count && out_count) count= s->in_buffer_count+2;
 +
 +            buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
 +            copy(&tmp, &in, /*in_*/count);
 +            s->in_buffer_count += count;
 +            in_count -= count;
 +            border += count;
 +            buf_set(&in, &in, count);
 +            s->resample_in_constraint= 0;
 +            if(s->in_buffer_count != count || in_count)
 +                continue;
 +        }
 +        break;
 +    }while(1);
 +
 +    s->resample_in_constraint= !!out_count;
 +
 +    return ret_sum;
 +}
 +
 +static int swr_convert_internal(struct SwrContext *s, AudioData *out, int out_count,
 +                                                      AudioData *in , int  in_count){
 +    AudioData *postin, *midbuf, *preout;
 +    int ret/*, in_max*/;
 +    AudioData preout_tmp, midbuf_tmp;
 +
 +    if(s->full_convert){
 +        av_assert0(!s->resample);
 +        swri_audio_convert(s->full_convert, out, in, in_count);
 +        return out_count;
 +    }
 +
 +//     in_max= out_count*(int64_t)s->in_sample_rate / s->out_sample_rate + resample_filter_taps;
 +//     in_count= FFMIN(in_count, in_in + 2 - s->hist_buffer_count);
 +
 +    if((ret=realloc_audio(&s->postin, in_count))<0)
 +        return ret;
 +    if(s->resample_first){
 +        av_assert0(s->midbuf.ch_count == s->used_ch_count);
 +        if((ret=realloc_audio(&s->midbuf, out_count))<0)
 +            return ret;
 +    }else{
 +        av_assert0(s->midbuf.ch_count ==  s->out.ch_count);
 +        if((ret=realloc_audio(&s->midbuf,  in_count))<0)
 +            return ret;
 +    }
 +    if((ret=realloc_audio(&s->preout, out_count))<0)
 +        return ret;
 +
 +    postin= &s->postin;
 +
 +    midbuf_tmp= s->midbuf;
 +    midbuf= &midbuf_tmp;
 +    preout_tmp= s->preout;
 +    preout= &preout_tmp;
 +
 +    if(s->int_sample_fmt == s-> in_sample_fmt && s->in.planar && !s->channel_map)
 +        postin= in;
 +
 +    if(s->resample_first ? !s->resample : !s->rematrix)
 +        midbuf= postin;
 +
 +    if(s->resample_first ? !s->rematrix : !s->resample)
 +        preout= midbuf;
 +
 +    if(s->int_sample_fmt == s->out_sample_fmt && s->out.planar){
 +        if(preout==in){
 +            out_count= FFMIN(out_count, in_count); //TODO check at the end if this is needed or redundant
 +            av_assert0(s->in.planar); //we only support planar internally so it has to be, we support copying non planar though
 +            copy(out, in, out_count);
 +            return out_count;
 +        }
 +        else if(preout==postin) preout= midbuf= postin= out;
 +        else if(preout==midbuf) preout= midbuf= out;
 +        else                    preout= out;
 +    }
 +
 +    if(in != postin){
 +        swri_audio_convert(s->in_convert, postin, in, in_count);
 +    }
 +
 +    if(s->resample_first){
 +        if(postin != midbuf)
 +            out_count= resample(s, midbuf, out_count, postin, in_count);
 +        if(midbuf != preout)
 +            swri_rematrix(s, preout, midbuf, out_count, preout==out);
 +    }else{
 +        if(postin != midbuf)
 +            swri_rematrix(s, midbuf, postin, in_count, midbuf==out);
 +        if(midbuf != preout)
 +            out_count= resample(s, preout, out_count, midbuf, in_count);
 +    }
 +
 +    if(preout != out && out_count){
 +        if(s->dither_method){
 +            int ch;
 +            int dither_count= FFMAX(out_count, 1<<16);
 +            av_assert0(preout != in);
 +
 +            if((ret=realloc_audio(&s->dither, dither_count))<0)
 +                return ret;
 +            if(ret)
 +                for(ch=0; ch<s->dither.ch_count; ch++)
 +                    swri_get_dither(s, s->dither.ch[ch], s->dither.count, 12345678913579<<ch, s->out_sample_fmt, s->int_sample_fmt);
 +            av_assert0(s->dither.ch_count == preout->ch_count);
 +
 +            if(s->dither_pos + out_count > s->dither.count)
 +                s->dither_pos = 0;
 +
 +            for(ch=0; ch<preout->ch_count; ch++)
 +                s->mix_2_1_f(preout->ch[ch], preout->ch[ch], s->dither.ch[ch] + s->dither.bps * s->dither_pos, s->native_one, 0, 0, out_count);
 +
 +            s->dither_pos += out_count;
 +        }
 +//FIXME packed doesnt need more than 1 chan here!
 +        swri_audio_convert(s->out_convert, out, preout, out_count);
 +    }
 +    return out_count;
 +}
 +
 +int swr_convert(struct SwrContext *s, uint8_t *out_arg[SWR_CH_MAX], int out_count,
 +                                const uint8_t *in_arg [SWR_CH_MAX], int  in_count){
 +    AudioData * in= &s->in;
 +    AudioData *out= &s->out;
 +
 +    if(s->drop_output > 0){
 +        int ret;
 +        AudioData tmp = s->out;
 +        uint8_t *tmp_arg[SWR_CH_MAX];
 +        tmp.count = 0;
 +        tmp.data  = NULL;
 +        if((ret=realloc_audio(&tmp, s->drop_output))<0)
 +            return ret;
 +
 +        reversefill_audiodata(&tmp, tmp_arg);
 +        s->drop_output *= -1; //FIXME find a less hackish solution
 +        ret = swr_convert(s, tmp_arg, -s->drop_output, in_arg, in_count); //FIXME optimize but this is as good as never called so maybe it doesnt matter
 +        s->drop_output *= -1;
 +        if(ret>0)
 +            s->drop_output -= ret;
 +
 +        av_freep(&tmp.data);
 +        if(s->drop_output || !out_arg)
 +            return 0;
 +        in_count = 0;
 +    }
 +
 +    if(!in_arg){
 +        if(s->in_buffer_count){
 +            if (s->resample && !s->flushed) {
 +                AudioData *a= &s->in_buffer;
 +                int i, j, ret;
 +                if((ret=realloc_audio(a, s->in_buffer_index + 2*s->in_buffer_count)) < 0)
 +                    return ret;
 +                av_assert0(a->planar);
 +                for(i=0; i<a->ch_count; i++){
 +                    for(j=0; j<s->in_buffer_count; j++){
 +                        memcpy(a->ch[i] + (s->in_buffer_index+s->in_buffer_count+j  )*a->bps,
 +                            a->ch[i] + (s->in_buffer_index+s->in_buffer_count-j-1)*a->bps, a->bps);
 +                    }
 +                }
 +                s->in_buffer_count += (s->in_buffer_count+1)/2;
 +                s->resample_in_constraint = 0;
 +                s->flushed = 1;
 +            }
 +        }else{
 +            return 0;
 +        }
 +    }else
 +        fill_audiodata(in ,  (void*)in_arg);
 +
 +    fill_audiodata(out, out_arg);
 +
 +    if(s->resample){
 +        int ret = swr_convert_internal(s, out, out_count, in, in_count);
 +        if(ret>0 && !s->drop_output)
 +            s->outpts += ret * (int64_t)s->in_sample_rate;
 +        return ret;
 +    }else{
 +        AudioData tmp= *in;
 +        int ret2=0;
 +        int ret, size;
 +        size = FFMIN(out_count, s->in_buffer_count);
 +        if(size){
 +            buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
 +            ret= swr_convert_internal(s, out, size, &tmp, size);
 +            if(ret<0)
 +                return ret;
 +            ret2= ret;
 +            s->in_buffer_count -= ret;
 +            s->in_buffer_index += ret;
 +            buf_set(out, out, ret);
 +            out_count -= ret;
 +            if(!s->in_buffer_count)
 +                s->in_buffer_index = 0;
 +        }
 +
 +        if(in_count){
 +            size= s->in_buffer_index + s->in_buffer_count + in_count - out_count;
 +
 +            if(in_count > out_count) { //FIXME move after swr_convert_internal
 +                if(   size > s->in_buffer.count
 +                && s->in_buffer_count + in_count - out_count <= s->in_buffer_index){
 +                    buf_set(&tmp, &s->in_buffer, s->in_buffer_index);
 +                    copy(&s->in_buffer, &tmp, s->in_buffer_count);
 +                    s->in_buffer_index=0;
 +                }else
 +                    if((ret=realloc_audio(&s->in_buffer, size)) < 0)
 +                        return ret;
 +            }
 +
 +            if(out_count){
 +                size = FFMIN(in_count, out_count);
 +                ret= swr_convert_internal(s, out, size, in, size);
 +                if(ret<0)
 +                    return ret;
 +                buf_set(in, in, ret);
 +                in_count -= ret;
 +                ret2 += ret;
 +            }
 +            if(in_count){
 +                buf_set(&tmp, &s->in_buffer, s->in_buffer_index + s->in_buffer_count);
 +                copy(&tmp, in, in_count);
 +                s->in_buffer_count += in_count;
 +            }
 +        }
 +        if(ret2>0 && !s->drop_output)
 +            s->outpts += ret2 * (int64_t)s->in_sample_rate;
 +        return ret2;
 +    }
 +}
 +
 +int swr_drop_output(struct SwrContext *s, int count){
 +    s->drop_output += count;
 +
 +    if(s->drop_output <= 0)
 +        return 0;
 +
 +    av_log(s, AV_LOG_VERBOSE, "discarding %d audio samples\n", count);
 +    return swr_convert(s, NULL, s->drop_output, NULL, 0);
 +}
 +
 +int swr_inject_silence(struct SwrContext *s, int count){
 +    int ret, i;
 +    AudioData silence = s->in;
 +    uint8_t *tmp_arg[SWR_CH_MAX];
 +
 +    if(count <= 0)
 +        return 0;
 +
 +    silence.count = 0;
 +    silence.data  = NULL;
 +    if((ret=realloc_audio(&silence, count))<0)
 +        return ret;
 +
 +    if(silence.planar) for(i=0; i<silence.ch_count; i++) {
 +        memset(silence.ch[i], silence.bps==1 ? 0x80 : 0, count*silence.bps);
 +    } else
 +        memset(silence.ch[0], silence.bps==1 ? 0x80 : 0, count*silence.bps*silence.ch_count);
 +
 +    reversefill_audiodata(&silence, tmp_arg);
 +    av_log(s, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", count);
 +    ret = swr_convert(s, NULL, 0, (const uint8_t**)tmp_arg, count);
 +    av_freep(&silence.data);
 +    return ret;
 +}
 +
 +int64_t swr_next_pts(struct SwrContext *s, int64_t pts){
 +    if(pts == INT64_MIN)
 +        return s->outpts;
 +    if(s->min_compensation >= FLT_MAX) {
 +        return (s->outpts = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate));
 +    } else {
 +        int64_t delta = pts - swr_get_delay(s, s->in_sample_rate * (int64_t)s->out_sample_rate) - s->outpts;
 +        double fdelta = delta /(double)(s->in_sample_rate * (int64_t)s->out_sample_rate);
 +
 +        if(fabs(fdelta) > s->min_compensation) {
 +            if(!s->outpts || fabs(fdelta) > s->min_hard_compensation){
 +                int ret;
 +                if(delta > 0) ret = swr_inject_silence(s,  delta / s->out_sample_rate);
 +                else          ret = swr_drop_output   (s, -delta / s-> in_sample_rate);
 +                if(ret<0){
 +                    av_log(s, AV_LOG_ERROR, "Failed to compensate for timestamp delta of %f\n", fdelta);
 +                }
 +            } else if(s->soft_compensation_duration && s->max_soft_compensation) {
 +                int duration = s->out_sample_rate * s->soft_compensation_duration;
 +                double max_soft_compensation = s->max_soft_compensation / (s->max_soft_compensation < 0 ? -s->in_sample_rate : 1);
 +                int comp = av_clipf(fdelta, -max_soft_compensation, max_soft_compensation) * duration ;
 +                av_log(s, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n", fdelta, comp, duration);
 +                swr_set_compensation(s, comp, duration);
 +            }
 +        }
 +
 +        return s->outpts;
 +    }
 +}
Simple merge