Merge commit '41ed7ab45fc693f7d7fc35664c0233f4c32d69bb'

* commit '41ed7ab45fc693f7d7fc35664c0233f4c32d69bb':
  cosmetics: Fix spelling mistakes

Merged-by: Clément Bœsch <u@pkh.me>

diff --cc Changelog
index 49bb557,54b52a1..f6016f4
--- 1/Changelog
--- 2/Changelog
+++ b/Changelog
@@@ -906,39 -463,7 +906,39 @@@ version 0.8
  - AAC encoding via libvo-aacenc
  - AMR-WB encoding via libvo-amrwbenc
  - xWMA demuxer
 -- fieldorder video filter added
 +- Mobotix MxPEG decoder
 +- VP8 frame-multithreading
 +- NEON optimizations for VP8
 +- Lots of deprecated API cruft removed
 +- fft and imdct optimizations for AVX (Sandy Bridge) processors
 +- showinfo filter added
 +- SMPTE 302M AES3 audio decoder
 +- Apple Core Audio Format muxer
- - 9bit and 10bit per sample support in the H.264 decoder
- - 9bit and 10bit FFV1 encoding / decoding
++- 9 bits and 10 bits per sample support in the H.264 decoder
++- 9 bits and 10 bits FFV1 encoding / decoding
 +- split filter added
 +- select filter added
 +- sdl output device added
 +- libmpcodecs video filter support (3 times as many filters than before)
 +- mpeg2 aspect ratio dection fixed
 +- libxvid aspect pickiness fixed
 +- Frame multithreaded decoding
 +- E-AC-3 audio encoder
 +- ac3enc: add channel coupling support
 +- floating-point sample format support to the ac3, eac3, dca, aac, and vorbis decoders.
 +- H264/MPEG frame-level multi-threading
 +- All av_metadata_* functions renamed to av_dict_* and moved to libavutil
 +- 4:4:4 H.264 decoding support
 +- 10-bit H.264 optimizations for x86
 +- lut, lutrgb, and lutyuv filters added
 +- buffersink libavfilter sink added
 +- Bump libswscale for recently reported ABI break
 +- New J2K encoder (via OpenJPEG)
 +
 +
 +version 0.7:
 +
 +- all the changes for 0.8, but keeping API/ABI compatibility with the 0.6 release
  
  
  version 0.6:

diff --cc doc/APIchanges
Simple merge

diff --cc doc/examples/decoding_encoding.c
index 06a98a6,0000000..43a64c2
mode 100644,000000..100644
--- 1/doc/examples/decoding_encoding.c
--- /dev/null
+++ b/doc/examples/decoding_encoding.c
@@@ -1,665 -1,0 +1,665 @@@
-  * Note that libavcodec only handles codecs (mpeg, mpeg4, etc...),
-  * not file formats (avi, vob, mp4, mov, mkv, mxf, flv, mpegts, mpegps, etc...). See library 'libavformat' for the
-  * format handling
 +/*
 + * Copyright (c) 2001 Fabrice Bellard
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * libavcodec API use example.
 + *
 + * @example decoding_encoding.c
-     /* find the mpeg audio decoder */
++ * Note that libavcodec only handles codecs (MPEG, MPEG-4, etc...),
++ * not file formats (AVI, VOB, MP4, MOV, MKV, MXF, FLV, MPEG-TS, MPEG-PS, etc...).
++ * See library 'libavformat' for the format handling
 + */
 +
 +#include <math.h>
 +
 +#include <libavutil/opt.h>
 +#include <libavcodec/avcodec.h>
 +#include <libavutil/channel_layout.h>
 +#include <libavutil/common.h>
 +#include <libavutil/imgutils.h>
 +#include <libavutil/mathematics.h>
 +#include <libavutil/samplefmt.h>
 +
 +#define INBUF_SIZE 4096
 +#define AUDIO_INBUF_SIZE 20480
 +#define AUDIO_REFILL_THRESH 4096
 +
 +/* check that a given sample format is supported by the encoder */
 +static int check_sample_fmt(AVCodec *codec, enum AVSampleFormat sample_fmt)
 +{
 +    const enum AVSampleFormat *p = codec->sample_fmts;
 +
 +    while (*p != AV_SAMPLE_FMT_NONE) {
 +        if (*p == sample_fmt)
 +            return 1;
 +        p++;
 +    }
 +    return 0;
 +}
 +
 +/* just pick the highest supported samplerate */
 +static int select_sample_rate(AVCodec *codec)
 +{
 +    const int *p;
 +    int best_samplerate = 0;
 +
 +    if (!codec->supported_samplerates)
 +        return 44100;
 +
 +    p = codec->supported_samplerates;
 +    while (*p) {
 +        best_samplerate = FFMAX(*p, best_samplerate);
 +        p++;
 +    }
 +    return best_samplerate;
 +}
 +
 +/* select layout with the highest channel count */
 +static int select_channel_layout(AVCodec *codec)
 +{
 +    const uint64_t *p;
 +    uint64_t best_ch_layout = 0;
 +    int best_nb_channels   = 0;
 +
 +    if (!codec->channel_layouts)
 +        return AV_CH_LAYOUT_STEREO;
 +
 +    p = codec->channel_layouts;
 +    while (*p) {
 +        int nb_channels = av_get_channel_layout_nb_channels(*p);
 +
 +        if (nb_channels > best_nb_channels) {
 +            best_ch_layout    = *p;
 +            best_nb_channels = nb_channels;
 +        }
 +        p++;
 +    }
 +    return best_ch_layout;
 +}
 +
 +/*
 + * Audio encoding example
 + */
 +static void audio_encode_example(const char *filename)
 +{
 +    AVCodec *codec;
 +    AVCodecContext *c= NULL;
 +    AVFrame *frame;
 +    AVPacket pkt;
 +    int i, j, k, ret, got_output;
 +    int buffer_size;
 +    FILE *f;
 +    uint16_t *samples;
 +    float t, tincr;
 +
 +    printf("Encode audio file %s\n", filename);
 +
 +    /* find the MP2 encoder */
 +    codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
 +    if (!codec) {
 +        fprintf(stderr, "Codec not found\n");
 +        exit(1);
 +    }
 +
 +    c = avcodec_alloc_context3(codec);
 +    if (!c) {
 +        fprintf(stderr, "Could not allocate audio codec context\n");
 +        exit(1);
 +    }
 +
 +    /* put sample parameters */
 +    c->bit_rate = 64000;
 +
 +    /* check that the encoder supports s16 pcm input */
 +    c->sample_fmt = AV_SAMPLE_FMT_S16;
 +    if (!check_sample_fmt(codec, c->sample_fmt)) {
 +        fprintf(stderr, "Encoder does not support sample format %s",
 +                av_get_sample_fmt_name(c->sample_fmt));
 +        exit(1);
 +    }
 +
 +    /* select other audio parameters supported by the encoder */
 +    c->sample_rate    = select_sample_rate(codec);
 +    c->channel_layout = select_channel_layout(codec);
 +    c->channels       = av_get_channel_layout_nb_channels(c->channel_layout);
 +
 +    /* open it */
 +    if (avcodec_open2(c, codec, NULL) < 0) {
 +        fprintf(stderr, "Could not open codec\n");
 +        exit(1);
 +    }
 +
 +    f = fopen(filename, "wb");
 +    if (!f) {
 +        fprintf(stderr, "Could not open %s\n", filename);
 +        exit(1);
 +    }
 +
 +    /* frame containing input raw audio */
 +    frame = av_frame_alloc();
 +    if (!frame) {
 +        fprintf(stderr, "Could not allocate audio frame\n");
 +        exit(1);
 +    }
 +
 +    frame->nb_samples     = c->frame_size;
 +    frame->format         = c->sample_fmt;
 +    frame->channel_layout = c->channel_layout;
 +
 +    /* the codec gives us the frame size, in samples,
 +     * we calculate the size of the samples buffer in bytes */
 +    buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
 +                                             c->sample_fmt, 0);
 +    if (buffer_size < 0) {
 +        fprintf(stderr, "Could not get sample buffer size\n");
 +        exit(1);
 +    }
 +    samples = av_malloc(buffer_size);
 +    if (!samples) {
 +        fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
 +                buffer_size);
 +        exit(1);
 +    }
 +    /* setup the data pointers in the AVFrame */
 +    ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
 +                                   (const uint8_t*)samples, buffer_size, 0);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not setup audio frame\n");
 +        exit(1);
 +    }
 +
 +    /* encode a single tone sound */
 +    t = 0;
 +    tincr = 2 * M_PI * 440.0 / c->sample_rate;
 +    for (i = 0; i < 200; i++) {
 +        av_init_packet(&pkt);
 +        pkt.data = NULL; // packet data will be allocated by the encoder
 +        pkt.size = 0;
 +
 +        for (j = 0; j < c->frame_size; j++) {
 +            samples[2*j] = (int)(sin(t) * 10000);
 +
 +            for (k = 1; k < c->channels; k++)
 +                samples[2*j + k] = samples[2*j];
 +            t += tincr;
 +        }
 +        /* encode the samples */
 +        ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error encoding audio frame\n");
 +            exit(1);
 +        }
 +        if (got_output) {
 +            fwrite(pkt.data, 1, pkt.size, f);
 +            av_packet_unref(&pkt);
 +        }
 +    }
 +
 +    /* get the delayed frames */
 +    for (got_output = 1; got_output; i++) {
 +        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error encoding frame\n");
 +            exit(1);
 +        }
 +
 +        if (got_output) {
 +            fwrite(pkt.data, 1, pkt.size, f);
 +            av_packet_unref(&pkt);
 +        }
 +    }
 +    fclose(f);
 +
 +    av_freep(&samples);
 +    av_frame_free(&frame);
 +    avcodec_close(c);
 +    av_free(c);
 +}
 +
 +/*
 + * Audio decoding.
 + */
 +static void audio_decode_example(const char *outfilename, const char *filename)
 +{
 +    AVCodec *codec;
 +    AVCodecContext *c= NULL;
 +    int len;
 +    FILE *f, *outfile;
 +    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
 +    AVPacket avpkt;
 +    AVFrame *decoded_frame = NULL;
 +
 +    av_init_packet(&avpkt);
 +
 +    printf("Decode audio file %s to %s\n", filename, outfilename);
 +
-     /* find the mpeg1 video encoder */
++    /* find the MPEG audio decoder */
 +    codec = avcodec_find_decoder(AV_CODEC_ID_MP2);
 +    if (!codec) {
 +        fprintf(stderr, "Codec not found\n");
 +        exit(1);
 +    }
 +
 +    c = avcodec_alloc_context3(codec);
 +    if (!c) {
 +        fprintf(stderr, "Could not allocate audio codec context\n");
 +        exit(1);
 +    }
 +
 +    /* open it */
 +    if (avcodec_open2(c, codec, NULL) < 0) {
 +        fprintf(stderr, "Could not open codec\n");
 +        exit(1);
 +    }
 +
 +    f = fopen(filename, "rb");
 +    if (!f) {
 +        fprintf(stderr, "Could not open %s\n", filename);
 +        exit(1);
 +    }
 +    outfile = fopen(outfilename, "wb");
 +    if (!outfile) {
 +        av_free(c);
 +        exit(1);
 +    }
 +
 +    /* decode until eof */
 +    avpkt.data = inbuf;
 +    avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);
 +
 +    while (avpkt.size > 0) {
 +        int i, ch;
 +        int got_frame = 0;
 +
 +        if (!decoded_frame) {
 +            if (!(decoded_frame = av_frame_alloc())) {
 +                fprintf(stderr, "Could not allocate audio frame\n");
 +                exit(1);
 +            }
 +        }
 +
 +        len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
 +        if (len < 0) {
 +            fprintf(stderr, "Error while decoding\n");
 +            exit(1);
 +        }
 +        if (got_frame) {
 +            /* if a frame has been decoded, output it */
 +            int data_size = av_get_bytes_per_sample(c->sample_fmt);
 +            if (data_size < 0) {
 +                /* This should not occur, checking just for paranoia */
 +                fprintf(stderr, "Failed to calculate data size\n");
 +                exit(1);
 +            }
 +            for (i=0; i<decoded_frame->nb_samples; i++)
 +                for (ch=0; ch<c->channels; ch++)
 +                    fwrite(decoded_frame->data[ch] + data_size*i, 1, data_size, outfile);
 +        }
 +        avpkt.size -= len;
 +        avpkt.data += len;
 +        avpkt.dts =
 +        avpkt.pts = AV_NOPTS_VALUE;
 +        if (avpkt.size < AUDIO_REFILL_THRESH) {
 +            /* Refill the input buffer, to avoid trying to decode
 +             * incomplete frames. Instead of this, one could also use
 +             * a parser, or use a proper container format through
 +             * libavformat. */
 +            memmove(inbuf, avpkt.data, avpkt.size);
 +            avpkt.data = inbuf;
 +            len = fread(avpkt.data + avpkt.size, 1,
 +                        AUDIO_INBUF_SIZE - avpkt.size, f);
 +            if (len > 0)
 +                avpkt.size += len;
 +        }
 +    }
 +
 +    fclose(outfile);
 +    fclose(f);
 +
 +    avcodec_close(c);
 +    av_free(c);
 +    av_frame_free(&decoded_frame);
 +}
 +
 +/*
 + * Video encoding example
 + */
 +static void video_encode_example(const char *filename, int codec_id)
 +{
 +    AVCodec *codec;
 +    AVCodecContext *c= NULL;
 +    int i, ret, x, y, got_output;
 +    FILE *f;
 +    AVFrame *frame;
 +    AVPacket pkt;
 +    uint8_t endcode[] = { 0, 0, 1, 0xb7 };
 +
 +    printf("Encode video file %s\n", filename);
 +
-     /* add sequence end code to have a real mpeg file */
++    /* find the video encoder */
 +    codec = avcodec_find_encoder(codec_id);
 +    if (!codec) {
 +        fprintf(stderr, "Codec not found\n");
 +        exit(1);
 +    }
 +
 +    c = avcodec_alloc_context3(codec);
 +    if (!c) {
 +        fprintf(stderr, "Could not allocate video codec context\n");
 +        exit(1);
 +    }
 +
 +    /* put sample parameters */
 +    c->bit_rate = 400000;
 +    /* resolution must be a multiple of two */
 +    c->width = 352;
 +    c->height = 288;
 +    /* frames per second */
 +    c->time_base = (AVRational){1,25};
 +    /* emit one intra frame every ten frames
 +     * check frame pict_type before passing frame
 +     * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
 +     * then gop_size is ignored and the output of encoder
 +     * will always be I frame irrespective to gop_size
 +     */
 +    c->gop_size = 10;
 +    c->max_b_frames = 1;
 +    c->pix_fmt = AV_PIX_FMT_YUV420P;
 +
 +    if (codec_id == AV_CODEC_ID_H264)
 +        av_opt_set(c->priv_data, "preset", "slow", 0);
 +
 +    /* open it */
 +    if (avcodec_open2(c, codec, NULL) < 0) {
 +        fprintf(stderr, "Could not open codec\n");
 +        exit(1);
 +    }
 +
 +    f = fopen(filename, "wb");
 +    if (!f) {
 +        fprintf(stderr, "Could not open %s\n", filename);
 +        exit(1);
 +    }
 +
 +    frame = av_frame_alloc();
 +    if (!frame) {
 +        fprintf(stderr, "Could not allocate video frame\n");
 +        exit(1);
 +    }
 +    frame->format = c->pix_fmt;
 +    frame->width  = c->width;
 +    frame->height = c->height;
 +
 +    /* the image can be allocated by any means and av_image_alloc() is
 +     * just the most convenient way if av_malloc() is to be used */
 +    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
 +                         c->pix_fmt, 32);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not allocate raw picture buffer\n");
 +        exit(1);
 +    }
 +
 +    /* encode 1 second of video */
 +    for (i = 0; i < 25; i++) {
 +        av_init_packet(&pkt);
 +        pkt.data = NULL;    // packet data will be allocated by the encoder
 +        pkt.size = 0;
 +
 +        fflush(stdout);
 +        /* prepare a dummy image */
 +        /* Y */
 +        for (y = 0; y < c->height; y++) {
 +            for (x = 0; x < c->width; x++) {
 +                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
 +            }
 +        }
 +
 +        /* Cb and Cr */
 +        for (y = 0; y < c->height/2; y++) {
 +            for (x = 0; x < c->width/2; x++) {
 +                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
 +                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
 +            }
 +        }
 +
 +        frame->pts = i;
 +
 +        /* encode the image */
 +        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error encoding frame\n");
 +            exit(1);
 +        }
 +
 +        if (got_output) {
 +            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
 +            fwrite(pkt.data, 1, pkt.size, f);
 +            av_packet_unref(&pkt);
 +        }
 +    }
 +
 +    /* get the delayed frames */
 +    for (got_output = 1; got_output; i++) {
 +        fflush(stdout);
 +
 +        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error encoding frame\n");
 +            exit(1);
 +        }
 +
 +        if (got_output) {
 +            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
 +            fwrite(pkt.data, 1, pkt.size, f);
 +            av_packet_unref(&pkt);
 +        }
 +    }
 +
-     /* set end of buffer to 0 (this ensures that no overreading happens for damaged mpeg streams) */
++    /* add sequence end code to have a real MPEG file */
 +    fwrite(endcode, 1, sizeof(endcode), f);
 +    fclose(f);
 +
 +    avcodec_close(c);
 +    av_free(c);
 +    av_freep(&frame->data[0]);
 +    av_frame_free(&frame);
 +    printf("\n");
 +}
 +
 +/*
 + * Video decoding example
 + */
 +
 +static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
 +                     char *filename)
 +{
 +    FILE *f;
 +    int i;
 +
 +    f = fopen(filename,"w");
 +    fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
 +    for (i = 0; i < ysize; i++)
 +        fwrite(buf + i * wrap, 1, xsize, f);
 +    fclose(f);
 +}
 +
 +static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
 +                              AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
 +{
 +    int len, got_frame;
 +    char buf[1024];
 +
 +    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
 +    if (len < 0) {
 +        fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
 +        return len;
 +    }
 +    if (got_frame) {
 +        printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
 +        fflush(stdout);
 +
 +        /* the picture is allocated by the decoder, no need to free it */
 +        snprintf(buf, sizeof(buf), outfilename, *frame_count);
 +        pgm_save(frame->data[0], frame->linesize[0],
 +                 frame->width, frame->height, buf);
 +        (*frame_count)++;
 +    }
 +    if (pkt->data) {
 +        pkt->size -= len;
 +        pkt->data += len;
 +    }
 +    return 0;
 +}
 +
 +static void video_decode_example(const char *outfilename, const char *filename)
 +{
 +    AVCodec *codec;
 +    AVCodecContext *c= NULL;
 +    int frame_count;
 +    FILE *f;
 +    AVFrame *frame;
 +    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
 +    AVPacket avpkt;
 +
 +    av_init_packet(&avpkt);
 +
-     /* find the mpeg1 video decoder */
++    /* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
 +    memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 +
 +    printf("Decode video file %s to %s\n", filename, outfilename);
 +
-     /* some codecs, such as MPEG, transmit the I and P frame with a
++    /* find the MPEG-1 video decoder */
 +    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
 +    if (!codec) {
 +        fprintf(stderr, "Codec not found\n");
 +        exit(1);
 +    }
 +
 +    c = avcodec_alloc_context3(codec);
 +    if (!c) {
 +        fprintf(stderr, "Could not allocate video codec context\n");
 +        exit(1);
 +    }
 +
 +    if (codec->capabilities & AV_CODEC_CAP_TRUNCATED)
 +        c->flags |= AV_CODEC_FLAG_TRUNCATED; // we do not send complete frames
 +
 +    /* For some codecs, such as msmpeg4 and mpeg4, width and height
 +       MUST be initialized there because this information is not
 +       available in the bitstream. */
 +
 +    /* open it */
 +    if (avcodec_open2(c, codec, NULL) < 0) {
 +        fprintf(stderr, "Could not open codec\n");
 +        exit(1);
 +    }
 +
 +    f = fopen(filename, "rb");
 +    if (!f) {
 +        fprintf(stderr, "Could not open %s\n", filename);
 +        exit(1);
 +    }
 +
 +    frame = av_frame_alloc();
 +    if (!frame) {
 +        fprintf(stderr, "Could not allocate video frame\n");
 +        exit(1);
 +    }
 +
 +    frame_count = 0;
 +    for (;;) {
 +        avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
 +        if (avpkt.size == 0)
 +            break;
 +
 +        /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
 +           and this is the only method to use them because you cannot
 +           know the compressed data size before analysing it.
 +
 +           BUT some other codecs (msmpeg4, mpeg4) are inherently frame
 +           based, so you must call them with all the data for one
 +           frame exactly. You must also initialize 'width' and
 +           'height' before initializing them. */
 +
 +        /* NOTE2: some codecs allow the raw parameters (frame size,
 +           sample rate) to be changed at any frame. We handle this, so
 +           you should also take care of it */
 +
 +        /* here, we use a stream based decoder (mpeg1video), so we
 +           feed decoder and see if it could decode a frame */
 +        avpkt.data = inbuf;
 +        while (avpkt.size > 0)
 +            if (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
 +                exit(1);
 +    }
 +
-        chance to get the last frame of the video */
++    /* Some codecs, such as MPEG, transmit the I- and P-frame with a
 +       latency of one frame. You must do the following to have a
++       chance to get the last frame of the video. */
 +    avpkt.data = NULL;
 +    avpkt.size = 0;
 +    decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 1);
 +
 +    fclose(f);
 +
 +    avcodec_close(c);
 +    av_free(c);
 +    av_frame_free(&frame);
 +    printf("\n");
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    const char *output_type;
 +
 +    /* register all the codecs */
 +    avcodec_register_all();
 +
 +    if (argc < 2) {
 +        printf("usage: %s output_type\n"
 +               "API example program to decode/encode a media stream with libavcodec.\n"
 +               "This program generates a synthetic stream and encodes it to a file\n"
 +               "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
 +               "The encoded stream is then decoded and written to a raw data output.\n"
 +               "output_type must be chosen between 'h264', 'mp2', 'mpg'.\n",
 +               argv[0]);
 +        return 1;
 +    }
 +    output_type = argv[1];
 +
 +    if (!strcmp(output_type, "h264")) {
 +        video_encode_example("test.h264", AV_CODEC_ID_H264);
 +    } else if (!strcmp(output_type, "mp2")) {
 +        audio_encode_example("test.mp2");
 +        audio_decode_example("test.pcm", "test.mp2");
 +    } else if (!strcmp(output_type, "mpg")) {
 +        video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
 +        video_decode_example("test%02d.pgm", "test.mpg");
 +    } else {
 +        fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
 +                output_type);
 +        return 1;
 +    }
 +
 +    return 0;
 +}

diff --cc doc/examples/muxing.c
index 2fc6f71,0000000..f1f5bb8
mode 100644,000000..100644
--- 1/doc/examples/muxing.c
--- /dev/null
+++ b/doc/examples/muxing.c
@@@ -1,673 -1,0 +1,673 @@@
-             /* just for testing, we also add B frames */
 +/*
 + * Copyright (c) 2003 Fabrice Bellard
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
 +/**
 + * @file
 + * libavformat API example.
 + *
 + * Output a media file in any supported libavformat format. The default
 + * codecs are used.
 + * @example muxing.c
 + */
 +
 +#include <stdlib.h>
 +#include <stdio.h>
 +#include <string.h>
 +#include <math.h>
 +
 +#include <libavutil/avassert.h>
 +#include <libavutil/channel_layout.h>
 +#include <libavutil/opt.h>
 +#include <libavutil/mathematics.h>
 +#include <libavutil/timestamp.h>
 +#include <libavformat/avformat.h>
 +#include <libswscale/swscale.h>
 +#include <libswresample/swresample.h>
 +
 +#define STREAM_DURATION   10.0
 +#define STREAM_FRAME_RATE 25 /* 25 images/s */
 +#define STREAM_PIX_FMT    AV_PIX_FMT_YUV420P /* default pix_fmt */
 +
 +#define SCALE_FLAGS SWS_BICUBIC
 +
 +// a wrapper around a single output AVStream
 +typedef struct OutputStream {
 +    AVStream *st;
 +    AVCodecContext *enc;
 +
 +    /* pts of the next frame that will be generated */
 +    int64_t next_pts;
 +    int samples_count;
 +
 +    AVFrame *frame;
 +    AVFrame *tmp_frame;
 +
 +    float t, tincr, tincr2;
 +
 +    struct SwsContext *sws_ctx;
 +    struct SwrContext *swr_ctx;
 +} OutputStream;
 +
 +static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt)
 +{
 +    AVRational *time_base = &fmt_ctx->streams[pkt->stream_index]->time_base;
 +
 +    printf("pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
 +           av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),
 +           av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),
 +           av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),
 +           pkt->stream_index);
 +}
 +
 +static int write_frame(AVFormatContext *fmt_ctx, const AVRational *time_base, AVStream *st, AVPacket *pkt)
 +{
 +    /* rescale output packet timestamp values from codec to stream timebase */
 +    av_packet_rescale_ts(pkt, *time_base, st->time_base);
 +    pkt->stream_index = st->index;
 +
 +    /* Write the compressed frame to the media file. */
 +    log_packet(fmt_ctx, pkt);
 +    return av_interleaved_write_frame(fmt_ctx, pkt);
 +}
 +
 +/* Add an output stream. */
 +static void add_stream(OutputStream *ost, AVFormatContext *oc,
 +                       AVCodec **codec,
 +                       enum AVCodecID codec_id)
 +{
 +    AVCodecContext *c;
 +    int i;
 +
 +    /* find the encoder */
 +    *codec = avcodec_find_encoder(codec_id);
 +    if (!(*codec)) {
 +        fprintf(stderr, "Could not find encoder for '%s'\n",
 +                avcodec_get_name(codec_id));
 +        exit(1);
 +    }
 +
 +    ost->st = avformat_new_stream(oc, NULL);
 +    if (!ost->st) {
 +        fprintf(stderr, "Could not allocate stream\n");
 +        exit(1);
 +    }
 +    ost->st->id = oc->nb_streams-1;
 +    c = avcodec_alloc_context3(*codec);
 +    if (!c) {
 +        fprintf(stderr, "Could not alloc an encoding context\n");
 +        exit(1);
 +    }
 +    ost->enc = c;
 +
 +    switch ((*codec)->type) {
 +    case AVMEDIA_TYPE_AUDIO:
 +        c->sample_fmt  = (*codec)->sample_fmts ?
 +            (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
 +        c->bit_rate    = 64000;
 +        c->sample_rate = 44100;
 +        if ((*codec)->supported_samplerates) {
 +            c->sample_rate = (*codec)->supported_samplerates[0];
 +            for (i = 0; (*codec)->supported_samplerates[i]; i++) {
 +                if ((*codec)->supported_samplerates[i] == 44100)
 +                    c->sample_rate = 44100;
 +            }
 +        }
 +        c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);
 +        c->channel_layout = AV_CH_LAYOUT_STEREO;
 +        if ((*codec)->channel_layouts) {
 +            c->channel_layout = (*codec)->channel_layouts[0];
 +            for (i = 0; (*codec)->channel_layouts[i]; i++) {
 +                if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
 +                    c->channel_layout = AV_CH_LAYOUT_STEREO;
 +            }
 +        }
 +        c->channels        = av_get_channel_layout_nb_channels(c->channel_layout);
 +        ost->st->time_base = (AVRational){ 1, c->sample_rate };
 +        break;
 +
 +    case AVMEDIA_TYPE_VIDEO:
 +        c->codec_id = codec_id;
 +
 +        c->bit_rate = 400000;
 +        /* Resolution must be a multiple of two. */
 +        c->width    = 352;
 +        c->height   = 288;
 +        /* timebase: This is the fundamental unit of time (in seconds) in terms
 +         * of which frame timestamps are represented. For fixed-fps content,
 +         * timebase should be 1/framerate and timestamp increments should be
 +         * identical to 1. */
 +        ost->st->time_base = (AVRational){ 1, STREAM_FRAME_RATE };
 +        c->time_base       = ost->st->time_base;
 +
 +        c->gop_size      = 12; /* emit one intra frame every twelve frames at most */
 +        c->pix_fmt       = STREAM_PIX_FMT;
 +        if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
++            /* just for testing, we also add B-frames */
 +            c->max_b_frames = 2;
 +        }
 +        if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
 +            /* Needed to avoid using macroblocks in which some coeffs overflow.
 +             * This does not happen with normal video, it just happens here as
 +             * the motion of the chroma plane does not match the luma plane. */
 +            c->mb_decision = 2;
 +        }
 +    break;
 +
 +    default:
 +        break;
 +    }
 +
 +    /* Some formats want stream headers to be separate. */
 +    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 +        c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 +}
 +
 +/**************************************************************/
 +/* audio output */
 +
 +static AVFrame *alloc_audio_frame(enum AVSampleFormat sample_fmt,
 +                                  uint64_t channel_layout,
 +                                  int sample_rate, int nb_samples)
 +{
 +    AVFrame *frame = av_frame_alloc();
 +    int ret;
 +
 +    if (!frame) {
 +        fprintf(stderr, "Error allocating an audio frame\n");
 +        exit(1);
 +    }
 +
 +    frame->format = sample_fmt;
 +    frame->channel_layout = channel_layout;
 +    frame->sample_rate = sample_rate;
 +    frame->nb_samples = nb_samples;
 +
 +    if (nb_samples) {
 +        ret = av_frame_get_buffer(frame, 0);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error allocating an audio buffer\n");
 +            exit(1);
 +        }
 +    }
 +
 +    return frame;
 +}
 +
 +static void open_audio(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)
 +{
 +    AVCodecContext *c;
 +    int nb_samples;
 +    int ret;
 +    AVDictionary *opt = NULL;
 +
 +    c = ost->enc;
 +
 +    /* open it */
 +    av_dict_copy(&opt, opt_arg, 0);
 +    ret = avcodec_open2(c, codec, &opt);
 +    av_dict_free(&opt);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not open audio codec: %s\n", av_err2str(ret));
 +        exit(1);
 +    }
 +
 +    /* init signal generator */
 +    ost->t     = 0;
 +    ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;
 +    /* increment frequency by 110 Hz per second */
 +    ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
 +
 +    if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
 +        nb_samples = 10000;
 +    else
 +        nb_samples = c->frame_size;
 +
 +    ost->frame     = alloc_audio_frame(c->sample_fmt, c->channel_layout,
 +                                       c->sample_rate, nb_samples);
 +    ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,
 +                                       c->sample_rate, nb_samples);
 +
 +    /* copy the stream parameters to the muxer */
 +    ret = avcodec_parameters_from_context(ost->st->codecpar, c);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not copy the stream parameters\n");
 +        exit(1);
 +    }
 +
 +    /* create resampler context */
 +        ost->swr_ctx = swr_alloc();
 +        if (!ost->swr_ctx) {
 +            fprintf(stderr, "Could not allocate resampler context\n");
 +            exit(1);
 +        }
 +
 +        /* set options */
 +        av_opt_set_int       (ost->swr_ctx, "in_channel_count",   c->channels,       0);
 +        av_opt_set_int       (ost->swr_ctx, "in_sample_rate",     c->sample_rate,    0);
 +        av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt",      AV_SAMPLE_FMT_S16, 0);
 +        av_opt_set_int       (ost->swr_ctx, "out_channel_count",  c->channels,       0);
 +        av_opt_set_int       (ost->swr_ctx, "out_sample_rate",    c->sample_rate,    0);
 +        av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt",     c->sample_fmt,     0);
 +
 +        /* initialize the resampling context */
 +        if ((ret = swr_init(ost->swr_ctx)) < 0) {
 +            fprintf(stderr, "Failed to initialize the resampling context\n");
 +            exit(1);
 +        }
 +}
 +
 +/* Prepare a 16 bit dummy audio frame of 'frame_size' samples and
 + * 'nb_channels' channels. */
 +static AVFrame *get_audio_frame(OutputStream *ost)
 +{
 +    AVFrame *frame = ost->tmp_frame;
 +    int j, i, v;
 +    int16_t *q = (int16_t*)frame->data[0];
 +
 +    /* check if we want to generate more frames */
 +    if (av_compare_ts(ost->next_pts, ost->enc->time_base,
 +                      STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)
 +        return NULL;
 +
 +    for (j = 0; j <frame->nb_samples; j++) {
 +        v = (int)(sin(ost->t) * 10000);
 +        for (i = 0; i < ost->enc->channels; i++)
 +            *q++ = v;
 +        ost->t     += ost->tincr;
 +        ost->tincr += ost->tincr2;
 +    }
 +
 +    frame->pts = ost->next_pts;
 +    ost->next_pts  += frame->nb_samples;
 +
 +    return frame;
 +}
 +
 +/*
 + * encode one audio frame and send it to the muxer
 + * return 1 when encoding is finished, 0 otherwise
 + */
 +static int write_audio_frame(AVFormatContext *oc, OutputStream *ost)
 +{
 +    AVCodecContext *c;
 +    AVPacket pkt = { 0 }; // data and size must be 0;
 +    AVFrame *frame;
 +    int ret;
 +    int got_packet;
 +    int dst_nb_samples;
 +
 +    av_init_packet(&pkt);
 +    c = ost->enc;
 +
 +    frame = get_audio_frame(ost);
 +
 +    if (frame) {
 +        /* convert samples from native format to destination codec format, using the resampler */
 +            /* compute destination number of samples */
 +            dst_nb_samples = av_rescale_rnd(swr_get_delay(ost->swr_ctx, c->sample_rate) + frame->nb_samples,
 +                                            c->sample_rate, c->sample_rate, AV_ROUND_UP);
 +            av_assert0(dst_nb_samples == frame->nb_samples);
 +
 +        /* when we pass a frame to the encoder, it may keep a reference to it
 +         * internally;
 +         * make sure we do not overwrite it here
 +         */
 +        ret = av_frame_make_writable(ost->frame);
 +        if (ret < 0)
 +            exit(1);
 +
 +            /* convert to destination format */
 +            ret = swr_convert(ost->swr_ctx,
 +                              ost->frame->data, dst_nb_samples,
 +                              (const uint8_t **)frame->data, frame->nb_samples);
 +            if (ret < 0) {
 +                fprintf(stderr, "Error while converting\n");
 +                exit(1);
 +            }
 +            frame = ost->frame;
 +
 +        frame->pts = av_rescale_q(ost->samples_count, (AVRational){1, c->sample_rate}, c->time_base);
 +        ost->samples_count += dst_nb_samples;
 +    }
 +
 +    ret = avcodec_encode_audio2(c, &pkt, frame, &got_packet);
 +    if (ret < 0) {
 +        fprintf(stderr, "Error encoding audio frame: %s\n", av_err2str(ret));
 +        exit(1);
 +    }
 +
 +    if (got_packet) {
 +        ret = write_frame(oc, &c->time_base, ost->st, &pkt);
 +        if (ret < 0) {
 +            fprintf(stderr, "Error while writing audio frame: %s\n",
 +                    av_err2str(ret));
 +            exit(1);
 +        }
 +    }
 +
 +    return (frame || got_packet) ? 0 : 1;
 +}
 +
 +/**************************************************************/
 +/* video output */
 +
 +static AVFrame *alloc_picture(enum AVPixelFormat pix_fmt, int width, int height)
 +{
 +    AVFrame *picture;
 +    int ret;
 +
 +    picture = av_frame_alloc();
 +    if (!picture)
 +        return NULL;
 +
 +    picture->format = pix_fmt;
 +    picture->width  = width;
 +    picture->height = height;
 +
 +    /* allocate the buffers for the frame data */
 +    ret = av_frame_get_buffer(picture, 32);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not allocate frame data.\n");
 +        exit(1);
 +    }
 +
 +    return picture;
 +}
 +
 +static void open_video(AVFormatContext *oc, AVCodec *codec, OutputStream *ost, AVDictionary *opt_arg)
 +{
 +    int ret;
 +    AVCodecContext *c = ost->enc;
 +    AVDictionary *opt = NULL;
 +
 +    av_dict_copy(&opt, opt_arg, 0);
 +
 +    /* open the codec */
 +    ret = avcodec_open2(c, codec, &opt);
 +    av_dict_free(&opt);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not open video codec: %s\n", av_err2str(ret));
 +        exit(1);
 +    }
 +
 +    /* allocate and init a re-usable frame */
 +    ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
 +    if (!ost->frame) {
 +        fprintf(stderr, "Could not allocate video frame\n");
 +        exit(1);
 +    }
 +
 +    /* If the output format is not YUV420P, then a temporary YUV420P
 +     * picture is needed too. It is then converted to the required
 +     * output format. */
 +    ost->tmp_frame = NULL;
 +    if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 +        ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
 +        if (!ost->tmp_frame) {
 +            fprintf(stderr, "Could not allocate temporary picture\n");
 +            exit(1);
 +        }
 +    }
 +
 +    /* copy the stream parameters to the muxer */
 +    ret = avcodec_parameters_from_context(ost->st->codecpar, c);
 +    if (ret < 0) {
 +        fprintf(stderr, "Could not copy the stream parameters\n");
 +        exit(1);
 +    }
 +}
 +
 +/* Prepare a dummy image. */
 +static void fill_yuv_image(AVFrame *pict, int frame_index,
 +                           int width, int height)
 +{
 +    int x, y, i, ret;
 +
 +    /* when we pass a frame to the encoder, it may keep a reference to it
 +     * internally;
 +     * make sure we do not overwrite it here
 +     */
 +    ret = av_frame_make_writable(pict);
 +    if (ret < 0)
 +        exit(1);
 +
 +    i = frame_index;
 +
 +    /* Y */
 +    for (y = 0; y < height; y++)
 +        for (x = 0; x < width; x++)
 +            pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;
 +
 +    /* Cb and Cr */
 +    for (y = 0; y < height / 2; y++) {
 +        for (x = 0; x < width / 2; x++) {
 +            pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
 +            pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
 +        }
 +    }
 +}
 +
 +static AVFrame *get_video_frame(OutputStream *ost)
 +{
 +    AVCodecContext *c = ost->enc;
 +
 +    /* check if we want to generate more frames */
 +    if (av_compare_ts(ost->next_pts, c->time_base,
 +                      STREAM_DURATION, (AVRational){ 1, 1 }) >= 0)
 +        return NULL;
 +
 +    if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 +        /* as we only generate a YUV420P picture, we must convert it
 +         * to the codec pixel format if needed */
 +        if (!ost->sws_ctx) {
 +            ost->sws_ctx = sws_getContext(c->width, c->height,
 +                                          AV_PIX_FMT_YUV420P,
 +                                          c->width, c->height,
 +                                          c->pix_fmt,
 +                                          SCALE_FLAGS, NULL, NULL, NULL);
 +            if (!ost->sws_ctx) {
 +                fprintf(stderr,
 +                        "Could not initialize the conversion context\n");
 +                exit(1);
 +            }
 +        }
 +        fill_yuv_image(ost->tmp_frame, ost->next_pts, c->width, c->height);
 +        sws_scale(ost->sws_ctx,
 +                  (const uint8_t * const *)ost->tmp_frame->data, ost->tmp_frame->linesize,
 +                  0, c->height, ost->frame->data, ost->frame->linesize);
 +    } else {
 +        fill_yuv_image(ost->frame, ost->next_pts, c->width, c->height);
 +    }
 +
 +    ost->frame->pts = ost->next_pts++;
 +
 +    return ost->frame;
 +}
 +
 +/*
 + * encode one video frame and send it to the muxer
 + * return 1 when encoding is finished, 0 otherwise
 + */
 +static int write_video_frame(AVFormatContext *oc, OutputStream *ost)
 +{
 +    int ret;
 +    AVCodecContext *c;
 +    AVFrame *frame;
 +    int got_packet = 0;
 +    AVPacket pkt = { 0 };
 +
 +    c = ost->enc;
 +
 +    frame = get_video_frame(ost);
 +
 +    av_init_packet(&pkt);
 +
 +    /* encode the image */
 +    ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
 +    if (ret < 0) {
 +        fprintf(stderr, "Error encoding video frame: %s\n", av_err2str(ret));
 +        exit(1);
 +    }
 +
 +    if (got_packet) {
 +        ret = write_frame(oc, &c->time_base, ost->st, &pkt);
 +    } else {
 +        ret = 0;
 +    }
 +
 +    if (ret < 0) {
 +        fprintf(stderr, "Error while writing video frame: %s\n", av_err2str(ret));
 +        exit(1);
 +    }
 +
 +    return (frame || got_packet) ? 0 : 1;
 +}
 +
 +static void close_stream(AVFormatContext *oc, OutputStream *ost)
 +{
 +    avcodec_free_context(&ost->enc);
 +    av_frame_free(&ost->frame);
 +    av_frame_free(&ost->tmp_frame);
 +    sws_freeContext(ost->sws_ctx);
 +    swr_free(&ost->swr_ctx);
 +}
 +
 +/**************************************************************/
 +/* media file output */
 +
 +int main(int argc, char **argv)
 +{
 +    OutputStream video_st = { 0 }, audio_st = { 0 };
 +    const char *filename;
 +    AVOutputFormat *fmt;
 +    AVFormatContext *oc;
 +    AVCodec *audio_codec, *video_codec;
 +    int ret;
 +    int have_video = 0, have_audio = 0;
 +    int encode_video = 0, encode_audio = 0;
 +    AVDictionary *opt = NULL;
 +    int i;
 +
 +    /* Initialize libavcodec, and register all codecs and formats. */
 +    av_register_all();
 +
 +    if (argc < 2) {
 +        printf("usage: %s output_file\n"
 +               "API example program to output a media file with libavformat.\n"
 +               "This program generates a synthetic audio and video stream, encodes and\n"
 +               "muxes them into a file named output_file.\n"
 +               "The output format is automatically guessed according to the file extension.\n"
 +               "Raw images can also be output by using '%%d' in the filename.\n"
 +               "\n", argv[0]);
 +        return 1;
 +    }
 +
 +    filename = argv[1];
 +    for (i = 2; i+1 < argc; i+=2) {
 +        if (!strcmp(argv[i], "-flags") || !strcmp(argv[i], "-fflags"))
 +            av_dict_set(&opt, argv[i]+1, argv[i+1], 0);
 +    }
 +
 +    /* allocate the output media context */
 +    avformat_alloc_output_context2(&oc, NULL, NULL, filename);
 +    if (!oc) {
 +        printf("Could not deduce output format from file extension: using MPEG.\n");
 +        avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
 +    }
 +    if (!oc)
 +        return 1;
 +
 +    fmt = oc->oformat;
 +
 +    /* Add the audio and video streams using the default format codecs
 +     * and initialize the codecs. */
 +    if (fmt->video_codec != AV_CODEC_ID_NONE) {
 +        add_stream(&video_st, oc, &video_codec, fmt->video_codec);
 +        have_video = 1;
 +        encode_video = 1;
 +    }
 +    if (fmt->audio_codec != AV_CODEC_ID_NONE) {
 +        add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec);
 +        have_audio = 1;
 +        encode_audio = 1;
 +    }
 +
 +    /* Now that all the parameters are set, we can open the audio and
 +     * video codecs and allocate the necessary encode buffers. */
 +    if (have_video)
 +        open_video(oc, video_codec, &video_st, opt);
 +
 +    if (have_audio)
 +        open_audio(oc, audio_codec, &audio_st, opt);
 +
 +    av_dump_format(oc, 0, filename, 1);
 +
 +    /* open the output file, if needed */
 +    if (!(fmt->flags & AVFMT_NOFILE)) {
 +        ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
 +        if (ret < 0) {
 +            fprintf(stderr, "Could not open '%s': %s\n", filename,
 +                    av_err2str(ret));
 +            return 1;
 +        }
 +    }
 +
 +    /* Write the stream header, if any. */
 +    ret = avformat_write_header(oc, &opt);
 +    if (ret < 0) {
 +        fprintf(stderr, "Error occurred when opening output file: %s\n",
 +                av_err2str(ret));
 +        return 1;
 +    }
 +
 +    while (encode_video || encode_audio) {
 +        /* select the stream to encode */
 +        if (encode_video &&
 +            (!encode_audio || av_compare_ts(video_st.next_pts, video_st.enc->time_base,
 +                                            audio_st.next_pts, audio_st.enc->time_base) <= 0)) {
 +            encode_video = !write_video_frame(oc, &video_st);
 +        } else {
 +            encode_audio = !write_audio_frame(oc, &audio_st);
 +        }
 +    }
 +
 +    /* Write the trailer, if any. The trailer must be written before you
 +     * close the CodecContexts open when you wrote the header; otherwise
 +     * av_write_trailer() may try to use memory that was freed on
 +     * av_codec_close(). */
 +    av_write_trailer(oc);
 +
 +    /* Close each codec. */
 +    if (have_video)
 +        close_stream(oc, &video_st);
 +    if (have_audio)
 +        close_stream(oc, &audio_st);
 +
 +    if (!(fmt->flags & AVFMT_NOFILE))
 +        /* Close the output file. */
 +        avio_closep(&oc->pb);
 +
 +    /* free the stream */
 +    avformat_free_context(oc);
 +
 +    return 0;
 +}

diff --cc doc/ffmpeg.texi
index e02807c,0000000..7368cdb
mode 100644,000000..100644
--- 1/doc/ffmpeg.texi
--- /dev/null
+++ b/doc/ffmpeg.texi
@@@ -1,1621 -1,0 +1,1621 @@@
- For QSV, this option corresponds to the valus of MFX_IMPL_* . Allowed values
 +\input texinfo @c -*- texinfo -*-
 +@documentencoding UTF-8
 +
 +@settitle ffmpeg Documentation
 +@titlepage
 +@center @titlefont{ffmpeg Documentation}
 +@end titlepage
 +
 +@top
 +
 +@contents
 +
 +@chapter Synopsis
 +
 +ffmpeg [@var{global_options}] @{[@var{input_file_options}] -i @file{input_file}@} ... @{[@var{output_file_options}] @file{output_file}@} ...
 +
 +@chapter Description
 +@c man begin DESCRIPTION
 +
 +@command{ffmpeg} is a very fast video and audio converter that can also grab from
 +a live audio/video source. It can also convert between arbitrary sample
 +rates and resize video on the fly with a high quality polyphase filter.
 +
 +@command{ffmpeg} reads from an arbitrary number of input "files" (which can be regular
 +files, pipes, network streams, grabbing devices, etc.), specified by the
 +@code{-i} option, and writes to an arbitrary number of output "files", which are
 +specified by a plain output filename. Anything found on the command line which
 +cannot be interpreted as an option is considered to be an output filename.
 +
 +Each input or output file can, in principle, contain any number of streams of
 +different types (video/audio/subtitle/attachment/data). The allowed number and/or
 +types of streams may be limited by the container format. Selecting which
 +streams from which inputs will go into which output is either done automatically
 +or with the @code{-map} option (see the Stream selection chapter).
 +
 +To refer to input files in options, you must use their indices (0-based). E.g.
 +the first input file is @code{0}, the second is @code{1}, etc. Similarly, streams
 +within a file are referred to by their indices. E.g. @code{2:3} refers to the
 +fourth stream in the third input file. Also see the Stream specifiers chapter.
 +
 +As a general rule, options are applied to the next specified
 +file. Therefore, order is important, and you can have the same
 +option on the command line multiple times. Each occurrence is
 +then applied to the next input or output file.
 +Exceptions from this rule are the global options (e.g. verbosity level),
 +which should be specified first.
 +
 +Do not mix input and output files -- first specify all input files, then all
 +output files. Also do not mix options which belong to different files. All
 +options apply ONLY to the next input or output file and are reset between files.
 +
 +@itemize
 +@item
 +To set the video bitrate of the output file to 64 kbit/s:
 +@example
 +ffmpeg -i input.avi -b:v 64k -bufsize 64k output.avi
 +@end example
 +
 +@item
 +To force the frame rate of the output file to 24 fps:
 +@example
 +ffmpeg -i input.avi -r 24 output.avi
 +@end example
 +
 +@item
 +To force the frame rate of the input file (valid for raw formats only)
 +to 1 fps and the frame rate of the output file to 24 fps:
 +@example
 +ffmpeg -r 1 -i input.m2v -r 24 output.avi
 +@end example
 +@end itemize
 +
 +The format option may be needed for raw input files.
 +
 +@c man end DESCRIPTION
 +
 +@chapter Detailed description
 +@c man begin DETAILED DESCRIPTION
 +
 +The transcoding process in @command{ffmpeg} for each output can be described by
 +the following diagram:
 +
 +@verbatim
 + _______              ______________
 +|       |            |              |
 +| input |  demuxer   | encoded data |   decoder
 +| file  | ---------> | packets      | -----+
 +|_______|            |______________|      |
 +                                           v
 +                                       _________
 +                                      |         |
 +                                      | decoded |
 +                                      | frames  |
 +                                      |_________|
 + ________             ______________       |
 +|        |           |              |      |
 +| output | <-------- | encoded data | <----+
 +| file   |   muxer   | packets      |   encoder
 +|________|           |______________|
 +
 +
 +@end verbatim
 +
 +@command{ffmpeg} calls the libavformat library (containing demuxers) to read
 +input files and get packets containing encoded data from them. When there are
 +multiple input files, @command{ffmpeg} tries to keep them synchronized by
 +tracking lowest timestamp on any active input stream.
 +
 +Encoded packets are then passed to the decoder (unless streamcopy is selected
 +for the stream, see further for a description). The decoder produces
 +uncompressed frames (raw video/PCM audio/...) which can be processed further by
 +filtering (see next section). After filtering, the frames are passed to the
 +encoder, which encodes them and outputs encoded packets. Finally those are
 +passed to the muxer, which writes the encoded packets to the output file.
 +
 +@section Filtering
 +Before encoding, @command{ffmpeg} can process raw audio and video frames using
 +filters from the libavfilter library. Several chained filters form a filter
 +graph. @command{ffmpeg} distinguishes between two types of filtergraphs:
 +simple and complex.
 +
 +@subsection Simple filtergraphs
 +Simple filtergraphs are those that have exactly one input and output, both of
 +the same type. In the above diagram they can be represented by simply inserting
 +an additional step between decoding and encoding:
 +
 +@verbatim
 + _________                        ______________
 +|         |                      |              |
 +| decoded |                      | encoded data |
 +| frames  |\                   _ | packets      |
 +|_________| \                  /||______________|
 +             \   __________   /
 +  simple     _\||          | /  encoder
 +  filtergraph   | filtered |/
 +                | frames   |
 +                |__________|
 +
 +@end verbatim
 +
 +Simple filtergraphs are configured with the per-stream @option{-filter} option
 +(with @option{-vf} and @option{-af} aliases for video and audio respectively).
 +A simple filtergraph for video can look for example like this:
 +
 +@verbatim
 + _______        _____________        _______        ________
 +|       |      |             |      |       |      |        |
 +| input | ---> | deinterlace | ---> | scale | ---> | output |
 +|_______|      |_____________|      |_______|      |________|
 +
 +@end verbatim
 +
 +Note that some filters change frame properties but not frame contents. E.g. the
 +@code{fps} filter in the example above changes number of frames, but does not
 +touch the frame contents. Another example is the @code{setpts} filter, which
 +only sets timestamps and otherwise passes the frames unchanged.
 +
 +@subsection Complex filtergraphs
 +Complex filtergraphs are those which cannot be described as simply a linear
 +processing chain applied to one stream. This is the case, for example, when the graph has
 +more than one input and/or output, or when output stream type is different from
 +input. They can be represented with the following diagram:
 +
 +@verbatim
 + _________
 +|         |
 +| input 0 |\                    __________
 +|_________| \                  |          |
 +             \   _________    /| output 0 |
 +              \ |         |  / |__________|
 + _________     \| complex | /
 +|         |     |         |/
 +| input 1 |---->| filter  |\
 +|_________|     |         | \   __________
 +               /| graph   |  \ |          |
 +              / |         |   \| output 1 |
 + _________   /  |_________|    |__________|
 +|         | /
 +| input 2 |/
 +|_________|
 +
 +@end verbatim
 +
 +Complex filtergraphs are configured with the @option{-filter_complex} option.
 +Note that this option is global, since a complex filtergraph, by its nature,
 +cannot be unambiguously associated with a single stream or file.
 +
 +The @option{-lavfi} option is equivalent to @option{-filter_complex}.
 +
 +A trivial example of a complex filtergraph is the @code{overlay} filter, which
 +has two video inputs and one video output, containing one video overlaid on top
 +of the other. Its audio counterpart is the @code{amix} filter.
 +
 +@section Stream copy
 +Stream copy is a mode selected by supplying the @code{copy} parameter to the
 +@option{-codec} option. It makes @command{ffmpeg} omit the decoding and encoding
 +step for the specified stream, so it does only demuxing and muxing. It is useful
 +for changing the container format or modifying container-level metadata. The
 +diagram above will, in this case, simplify to this:
 +
 +@verbatim
 + _______              ______________            ________
 +|       |            |              |          |        |
 +| input |  demuxer   | encoded data |  muxer   | output |
 +| file  | ---------> | packets      | -------> | file   |
 +|_______|            |______________|          |________|
 +
 +@end verbatim
 +
 +Since there is no decoding or encoding, it is very fast and there is no quality
 +loss. However, it might not work in some cases because of many factors. Applying
 +filters is obviously also impossible, since filters work on uncompressed data.
 +
 +@c man end DETAILED DESCRIPTION
 +
 +@chapter Stream selection
 +@c man begin STREAM SELECTION
 +
 +By default, @command{ffmpeg} includes only one stream of each type (video, audio, subtitle)
 +present in the input files and adds them to each output file.  It picks the
 +"best" of each based upon the following criteria: for video, it is the stream
 +with the highest resolution, for audio, it is the stream with the most channels, for
 +subtitles, it is the first subtitle stream. In the case where several streams of
 +the same type rate equally, the stream with the lowest index is chosen.
 +
 +You can disable some of those defaults by using the @code{-vn/-an/-sn} options. For
 +full manual control, use the @code{-map} option, which disables the defaults just
 +described.
 +
 +@c man end STREAM SELECTION
 +
 +@chapter Options
 +@c man begin OPTIONS
 +
 +@include fftools-common-opts.texi
 +
 +@section Main options
 +
 +@table @option
 +
 +@item -f @var{fmt} (@emph{input/output})
 +Force input or output file format. The format is normally auto detected for input
 +files and guessed from the file extension for output files, so this option is not
 +needed in most cases.
 +
 +@item -i @var{filename} (@emph{input})
 +input file name
 +
 +@item -y (@emph{global})
 +Overwrite output files without asking.
 +
 +@item -n (@emph{global})
 +Do not overwrite output files, and exit immediately if a specified
 +output file already exists.
 +
 +@item -stream_loop @var{number} (@emph{input})
 +Set number of times input stream shall be looped. Loop 0 means no loop,
 +loop -1 means infinite loop.
 +
 +@item -c[:@var{stream_specifier}] @var{codec} (@emph{input/output,per-stream})
 +@itemx -codec[:@var{stream_specifier}] @var{codec} (@emph{input/output,per-stream})
 +Select an encoder (when used before an output file) or a decoder (when used
 +before an input file) for one or more streams. @var{codec} is the name of a
 +decoder/encoder or a special value @code{copy} (output only) to indicate that
 +the stream is not to be re-encoded.
 +
 +For example
 +@example
 +ffmpeg -i INPUT -map 0 -c:v libx264 -c:a copy OUTPUT
 +@end example
 +encodes all video streams with libx264 and copies all audio streams.
 +
 +For each stream, the last matching @code{c} option is applied, so
 +@example
 +ffmpeg -i INPUT -map 0 -c copy -c:v:1 libx264 -c:a:137 libvorbis OUTPUT
 +@end example
 +will copy all the streams except the second video, which will be encoded with
 +libx264, and the 138th audio, which will be encoded with libvorbis.
 +
 +@item -t @var{duration} (@emph{input/output})
 +When used as an input option (before @code{-i}), limit the @var{duration} of
 +data read from the input file.
 +
 +When used as an output option (before an output filename), stop writing the
 +output after its duration reaches @var{duration}.
 +
 +@var{duration} must be a time duration specification,
 +see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 +
 +-to and -t are mutually exclusive and -t has priority.
 +
 +@item -to @var{position} (@emph{output})
 +Stop writing the output at @var{position}.
 +@var{position} must be a time duration specification,
 +see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 +
 +-to and -t are mutually exclusive and -t has priority.
 +
 +@item -fs @var{limit_size} (@emph{output})
 +Set the file size limit, expressed in bytes. No further chunk of bytes is written
 +after the limit is exceeded. The size of the output file is slightly more than the
 +requested file size.
 +
 +@item -ss @var{position} (@emph{input/output})
 +When used as an input option (before @code{-i}), seeks in this input file to
 +@var{position}. Note that in most formats it is not possible to seek exactly,
 +so @command{ffmpeg} will seek to the closest seek point before @var{position}.
 +When transcoding and @option{-accurate_seek} is enabled (the default), this
 +extra segment between the seek point and @var{position} will be decoded and
 +discarded. When doing stream copy or when @option{-noaccurate_seek} is used, it
 +will be preserved.
 +
 +When used as an output option (before an output filename), decodes but discards
 +input until the timestamps reach @var{position}.
 +
 +@var{position} must be a time duration specification,
 +see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 +
 +@item -sseof @var{position} (@emph{input/output})
 +
 +Like the @code{-ss} option but relative to the "end of file". That is negative
 +values are earlier in the file, 0 is at EOF.
 +
 +@item -itsoffset @var{offset} (@emph{input})
 +Set the input time offset.
 +
 +@var{offset} must be a time duration specification,
 +see @ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 +
 +The offset is added to the timestamps of the input files. Specifying
 +a positive offset means that the corresponding streams are delayed by
 +the time duration specified in @var{offset}.
 +
 +@item -timestamp @var{date} (@emph{output})
 +Set the recording timestamp in the container.
 +
 +@var{date} must be a date specification,
 +see @ref{date syntax,,the Date section in the ffmpeg-utils(1) manual,ffmpeg-utils}.
 +
 +@item -metadata[:metadata_specifier] @var{key}=@var{value} (@emph{output,per-metadata})
 +Set a metadata key/value pair.
 +
 +An optional @var{metadata_specifier} may be given to set metadata
 +on streams, chapters or programs. See @code{-map_metadata}
 +documentation for details.
 +
 +This option overrides metadata set with @code{-map_metadata}. It is
 +also possible to delete metadata by using an empty value.
 +
 +For example, for setting the title in the output file:
 +@example
 +ffmpeg -i in.avi -metadata title="my title" out.flv
 +@end example
 +
 +To set the language of the first audio stream:
 +@example
 +ffmpeg -i INPUT -metadata:s:a:0 language=eng OUTPUT
 +@end example
 +
 +@item -program [title=@var{title}:][program_num=@var{program_num}:]st=@var{stream}[:st=@var{stream}...] (@emph{output})
 +
 +Creates a program with the specified @var{title}, @var{program_num} and adds the specified
 +@var{stream}(s) to it.
 +
 +@item -target @var{type} (@emph{output})
 +Specify target file type (@code{vcd}, @code{svcd}, @code{dvd}, @code{dv},
 +@code{dv50}). @var{type} may be prefixed with @code{pal-}, @code{ntsc-} or
 +@code{film-} to use the corresponding standard. All the format options
 +(bitrate, codecs, buffer sizes) are then set automatically. You can just type:
 +
 +@example
 +ffmpeg -i myfile.avi -target vcd /tmp/vcd.mpg
 +@end example
 +
 +Nevertheless you can specify additional options as long as you know
 +they do not conflict with the standard, as in:
 +
 +@example
 +ffmpeg -i myfile.avi -target vcd -bf 2 /tmp/vcd.mpg
 +@end example
 +
 +@item -dframes @var{number} (@emph{output})
 +Set the number of data frames to output. This is an alias for @code{-frames:d}.
 +
 +@item -frames[:@var{stream_specifier}] @var{framecount} (@emph{output,per-stream})
 +Stop writing to the stream after @var{framecount} frames.
 +
 +@item -q[:@var{stream_specifier}] @var{q} (@emph{output,per-stream})
 +@itemx -qscale[:@var{stream_specifier}] @var{q} (@emph{output,per-stream})
 +Use fixed quality scale (VBR). The meaning of @var{q}/@var{qscale} is
 +codec-dependent.
 +If @var{qscale} is used without a @var{stream_specifier} then it applies only
 +to the video stream, this is to maintain compatibility with previous behavior
 +and as specifying the same codec specific value to 2 different codecs that is
 +audio and video generally is not what is intended when no stream_specifier is
 +used.
 +
 +@anchor{filter_option}
 +@item -filter[:@var{stream_specifier}] @var{filtergraph} (@emph{output,per-stream})
 +Create the filtergraph specified by @var{filtergraph} and use it to
 +filter the stream.
 +
 +@var{filtergraph} is a description of the filtergraph to apply to
 +the stream, and must have a single input and a single output of the
 +same type of the stream. In the filtergraph, the input is associated
 +to the label @code{in}, and the output to the label @code{out}. See
 +the ffmpeg-filters manual for more information about the filtergraph
 +syntax.
 +
 +See the @ref{filter_complex_option,,-filter_complex option} if you
 +want to create filtergraphs with multiple inputs and/or outputs.
 +
 +@item -filter_script[:@var{stream_specifier}] @var{filename} (@emph{output,per-stream})
 +This option is similar to @option{-filter}, the only difference is that its
 +argument is the name of the file from which a filtergraph description is to be
 +read.
 +
 +@item -pre[:@var{stream_specifier}] @var{preset_name} (@emph{output,per-stream})
 +Specify the preset for matching stream(s).
 +
 +@item -stats (@emph{global})
 +Print encoding progress/statistics. It is on by default, to explicitly
 +disable it you need to specify @code{-nostats}.
 +
 +@item -progress @var{url} (@emph{global})
 +Send program-friendly progress information to @var{url}.
 +
 +Progress information is written approximately every second and at the end of
 +the encoding process. It is made of "@var{key}=@var{value}" lines. @var{key}
 +consists of only alphanumeric characters. The last key of a sequence of
 +progress information is always "progress".
 +
 +@item -stdin
 +Enable interaction on standard input. On by default unless standard input is
 +used as an input. To explicitly disable interaction you need to specify
 +@code{-nostdin}.
 +
 +Disabling interaction on standard input is useful, for example, if
 +ffmpeg is in the background process group. Roughly the same result can
 +be achieved with @code{ffmpeg ... < /dev/null} but it requires a
 +shell.
 +
 +@item -debug_ts (@emph{global})
 +Print timestamp information. It is off by default. This option is
 +mostly useful for testing and debugging purposes, and the output
 +format may change from one version to another, so it should not be
 +employed by portable scripts.
 +
 +See also the option @code{-fdebug ts}.
 +
 +@item -attach @var{filename} (@emph{output})
 +Add an attachment to the output file. This is supported by a few formats
 +like Matroska for e.g. fonts used in rendering subtitles. Attachments
 +are implemented as a specific type of stream, so this option will add
 +a new stream to the file. It is then possible to use per-stream options
 +on this stream in the usual way. Attachment streams created with this
 +option will be created after all the other streams (i.e. those created
 +with @code{-map} or automatic mappings).
 +
 +Note that for Matroska you also have to set the mimetype metadata tag:
 +@example
 +ffmpeg -i INPUT -attach DejaVuSans.ttf -metadata:s:2 mimetype=application/x-truetype-font out.mkv
 +@end example
 +(assuming that the attachment stream will be third in the output file).
 +
 +@item -dump_attachment[:@var{stream_specifier}] @var{filename} (@emph{input,per-stream})
 +Extract the matching attachment stream into a file named @var{filename}. If
 +@var{filename} is empty, then the value of the @code{filename} metadata tag
 +will be used.
 +
 +E.g. to extract the first attachment to a file named 'out.ttf':
 +@example
 +ffmpeg -dump_attachment:t:0 out.ttf -i INPUT
 +@end example
 +To extract all attachments to files determined by the @code{filename} tag:
 +@example
 +ffmpeg -dump_attachment:t "" -i INPUT
 +@end example
 +
 +Technical note -- attachments are implemented as codec extradata, so this
 +option can actually be used to extract extradata from any stream, not just
 +attachments.
 +
 +@item -noautorotate
 +Disable automatically rotating video based on file metadata.
 +
 +@end table
 +
 +@section Video Options
 +
 +@table @option
 +@item -vframes @var{number} (@emph{output})
 +Set the number of video frames to output. This is an alias for @code{-frames:v}.
 +@item -r[:@var{stream_specifier}] @var{fps} (@emph{input/output,per-stream})
 +Set frame rate (Hz value, fraction or abbreviation).
 +
 +As an input option, ignore any timestamps stored in the file and instead
 +generate timestamps assuming constant frame rate @var{fps}.
 +This is not the same as the @option{-framerate} option used for some input formats
 +like image2 or v4l2 (it used to be the same in older versions of FFmpeg).
 +If in doubt use @option{-framerate} instead of the input option @option{-r}.
 +
 +As an output option, duplicate or drop input frames to achieve constant output
 +frame rate @var{fps}.
 +
 +@item -s[:@var{stream_specifier}] @var{size} (@emph{input/output,per-stream})
 +Set frame size.
 +
 +As an input option, this is a shortcut for the @option{video_size} private
 +option, recognized by some demuxers for which the frame size is either not
 +stored in the file or is configurable -- e.g. raw video or video grabbers.
 +
 +As an output option, this inserts the @code{scale} video filter to the
 +@emph{end} of the corresponding filtergraph. Please use the @code{scale} filter
 +directly to insert it at the beginning or some other place.
 +
 +The format is @samp{wxh} (default - same as source).
 +
 +@item -aspect[:@var{stream_specifier}] @var{aspect} (@emph{output,per-stream})
 +Set the video display aspect ratio specified by @var{aspect}.
 +
 +@var{aspect} can be a floating point number string, or a string of the
 +form @var{num}:@var{den}, where @var{num} and @var{den} are the
 +numerator and denominator of the aspect ratio. For example "4:3",
 +"16:9", "1.3333", and "1.7777" are valid argument values.
 +
 +If used together with @option{-vcodec copy}, it will affect the aspect ratio
 +stored at container level, but not the aspect ratio stored in encoded
 +frames, if it exists.
 +
 +@item -vn (@emph{output})
 +Disable video recording.
 +
 +@item -vcodec @var{codec} (@emph{output})
 +Set the video codec. This is an alias for @code{-codec:v}.
 +
 +@item -pass[:@var{stream_specifier}] @var{n} (@emph{output,per-stream})
 +Select the pass number (1 or 2). It is used to do two-pass
 +video encoding. The statistics of the video are recorded in the first
 +pass into a log file (see also the option -passlogfile),
 +and in the second pass that log file is used to generate the video
 +at the exact requested bitrate.
 +On pass 1, you may just deactivate audio and set output to null,
 +examples for Windows and Unix:
 +@example
 +ffmpeg -i foo.mov -c:v libxvid -pass 1 -an -f rawvideo -y NUL
 +ffmpeg -i foo.mov -c:v libxvid -pass 1 -an -f rawvideo -y /dev/null
 +@end example
 +
 +@item -passlogfile[:@var{stream_specifier}] @var{prefix} (@emph{output,per-stream})
 +Set two-pass log file name prefix to @var{prefix}, the default file name
 +prefix is ``ffmpeg2pass''. The complete file name will be
 +@file{PREFIX-N.log}, where N is a number specific to the output
 +stream
 +
 +@item -vf @var{filtergraph} (@emph{output})
 +Create the filtergraph specified by @var{filtergraph} and use it to
 +filter the stream.
 +
 +This is an alias for @code{-filter:v}, see the @ref{filter_option,,-filter option}.
 +@end table
 +
 +@section Advanced Video options
 +
 +@table @option
 +@item -pix_fmt[:@var{stream_specifier}] @var{format} (@emph{input/output,per-stream})
 +Set pixel format. Use @code{-pix_fmts} to show all the supported
 +pixel formats.
 +If the selected pixel format can not be selected, ffmpeg will print a
 +warning and select the best pixel format supported by the encoder.
 +If @var{pix_fmt} is prefixed by a @code{+}, ffmpeg will exit with an error
 +if the requested pixel format can not be selected, and automatic conversions
 +inside filtergraphs are disabled.
 +If @var{pix_fmt} is a single @code{+}, ffmpeg selects the same pixel format
 +as the input (or graph output) and automatic conversions are disabled.
 +
 +@item -sws_flags @var{flags} (@emph{input/output})
 +Set SwScaler flags.
 +@item -vdt @var{n}
 +Discard threshold.
 +
 +@item -rc_override[:@var{stream_specifier}] @var{override} (@emph{output,per-stream})
 +Rate control override for specific intervals, formatted as "int,int,int"
 +list separated with slashes. Two first values are the beginning and
 +end frame numbers, last one is quantizer to use if positive, or quality
 +factor if negative.
 +
 +@item -ilme
 +Force interlacing support in encoder (MPEG-2 and MPEG-4 only).
 +Use this option if your input file is interlaced and you want
 +to keep the interlaced format for minimum losses.
 +The alternative is to deinterlace the input stream with
 +@option{-deinterlace}, but deinterlacing introduces losses.
 +@item -psnr
 +Calculate PSNR of compressed frames.
 +@item -vstats
 +Dump video coding statistics to @file{vstats_HHMMSS.log}.
 +@item -vstats_file @var{file}
 +Dump video coding statistics to @var{file}.
 +@item -top[:@var{stream_specifier}] @var{n} (@emph{output,per-stream})
 +top=1/bottom=0/auto=-1 field first
 +@item -dc @var{precision}
 +Intra_dc_precision.
 +@item -vtag @var{fourcc/tag} (@emph{output})
 +Force video tag/fourcc. This is an alias for @code{-tag:v}.
 +@item -qphist (@emph{global})
 +Show QP histogram
 +@item -vbsf @var{bitstream_filter}
 +Deprecated see -bsf
 +
 +@item -force_key_frames[:@var{stream_specifier}] @var{time}[,@var{time}...] (@emph{output,per-stream})
 +@item -force_key_frames[:@var{stream_specifier}] expr:@var{expr} (@emph{output,per-stream})
 +Force key frames at the specified timestamps, more precisely at the first
 +frames after each specified time.
 +
 +If the argument is prefixed with @code{expr:}, the string @var{expr}
 +is interpreted like an expression and is evaluated for each frame. A
 +key frame is forced in case the evaluation is non-zero.
 +
 +If one of the times is "@code{chapters}[@var{delta}]", it is expanded into
 +the time of the beginning of all chapters in the file, shifted by
 +@var{delta}, expressed as a time in seconds.
 +This option can be useful to ensure that a seek point is present at a
 +chapter mark or any other designated place in the output file.
 +
 +For example, to insert a key frame at 5 minutes, plus key frames 0.1 second
 +before the beginning of every chapter:
 +@example
 +-force_key_frames 0:05:00,chapters-0.1
 +@end example
 +
 +The expression in @var{expr} can contain the following constants:
 +@table @option
 +@item n
 +the number of current processed frame, starting from 0
 +@item n_forced
 +the number of forced frames
 +@item prev_forced_n
 +the number of the previous forced frame, it is @code{NAN} when no
 +keyframe was forced yet
 +@item prev_forced_t
 +the time of the previous forced frame, it is @code{NAN} when no
 +keyframe was forced yet
 +@item t
 +the time of the current processed frame
 +@end table
 +
 +For example to force a key frame every 5 seconds, you can specify:
 +@example
 +-force_key_frames expr:gte(t,n_forced*5)
 +@end example
 +
 +To force a key frame 5 seconds after the time of the last forced one,
 +starting from second 13:
 +@example
 +-force_key_frames expr:if(isnan(prev_forced_t),gte(t,13),gte(t,prev_forced_t+5))
 +@end example
 +
 +Note that forcing too many keyframes is very harmful for the lookahead
 +algorithms of certain encoders: using fixed-GOP options or similar
 +would be more efficient.
 +
 +@item -copyinkf[:@var{stream_specifier}] (@emph{output,per-stream})
 +When doing stream copy, copy also non-key frames found at the
 +beginning.
 +
 +@item -hwaccel[:@var{stream_specifier}] @var{hwaccel} (@emph{input,per-stream})
 +Use hardware acceleration to decode the matching stream(s). The allowed values
 +of @var{hwaccel} are:
 +@table @option
 +@item none
 +Do not use any hardware acceleration (the default).
 +
 +@item auto
 +Automatically select the hardware acceleration method.
 +
 +@item vda
 +Use Apple VDA hardware acceleration.
 +
 +@item vdpau
 +Use VDPAU (Video Decode and Presentation API for Unix) hardware acceleration.
 +
 +@item dxva2
 +Use DXVA2 (DirectX Video Acceleration) hardware acceleration.
 +
 +@item qsv
 +Use the Intel QuickSync Video acceleration for video transcoding.
 +
 +Unlike most other values, this option does not enable accelerated decoding (that
 +is used automatically whenever a qsv decoder is selected), but accelerated
 +transcoding, without copying the frames into the system memory.
 +
 +For it to work, both the decoder and the encoder must support QSV acceleration
 +and no filters must be used.
 +@end table
 +
 +This option has no effect if the selected hwaccel is not available or not
 +supported by the chosen decoder.
 +
 +Note that most acceleration methods are intended for playback and will not be
 +faster than software decoding on modern CPUs. Additionally, @command{ffmpeg}
 +will usually need to copy the decoded frames from the GPU memory into the system
 +memory, resulting in further performance loss. This option is thus mainly
 +useful for testing.
 +
 +@item -hwaccel_device[:@var{stream_specifier}] @var{hwaccel_device} (@emph{input,per-stream})
 +Select a device to use for hardware acceleration.
 +
 +This option only makes sense when the @option{-hwaccel} option is also
 +specified. Its exact meaning depends on the specific hardware acceleration
 +method chosen.
 +
 +@table @option
 +@item vdpau
 +For VDPAU, this option specifies the X11 display/screen to use. If this option
 +is not specified, the value of the @var{DISPLAY} environment variable is used
 +
 +@item dxva2
 +For DXVA2, this option should contain the number of the display adapter to use.
 +If this option is not specified, the default adapter is used.
 +
 +@item qsv
++For QSV, this option corresponds to the values of MFX_IMPL_* . Allowed values
 +are:
 +@table @option
 +@item auto
 +@item sw
 +@item hw
 +@item auto_any
 +@item hw_any
 +@item hw2
 +@item hw3
 +@item hw4
 +@end table
 +@end table
 +
 +@item -hwaccels
 +List all hardware acceleration methods supported in this build of ffmpeg.
 +
 +@end table
 +
 +@section Audio Options
 +
 +@table @option
 +@item -aframes @var{number} (@emph{output})
 +Set the number of audio frames to output. This is an alias for @code{-frames:a}.
 +@item -ar[:@var{stream_specifier}] @var{freq} (@emph{input/output,per-stream})
 +Set the audio sampling frequency. For output streams it is set by
 +default to the frequency of the corresponding input stream. For input
 +streams this option only makes sense for audio grabbing devices and raw
 +demuxers and is mapped to the corresponding demuxer options.
 +@item -aq @var{q} (@emph{output})
 +Set the audio quality (codec-specific, VBR). This is an alias for -q:a.
 +@item -ac[:@var{stream_specifier}] @var{channels} (@emph{input/output,per-stream})
 +Set the number of audio channels. For output streams it is set by
 +default to the number of input audio channels. For input streams
 +this option only makes sense for audio grabbing devices and raw demuxers
 +and is mapped to the corresponding demuxer options.
 +@item -an (@emph{output})
 +Disable audio recording.
 +@item -acodec @var{codec} (@emph{input/output})
 +Set the audio codec. This is an alias for @code{-codec:a}.
 +@item -sample_fmt[:@var{stream_specifier}] @var{sample_fmt} (@emph{output,per-stream})
 +Set the audio sample format. Use @code{-sample_fmts} to get a list
 +of supported sample formats.
 +
 +@item -af @var{filtergraph} (@emph{output})
 +Create the filtergraph specified by @var{filtergraph} and use it to
 +filter the stream.
 +
 +This is an alias for @code{-filter:a}, see the @ref{filter_option,,-filter option}.
 +@end table
 +
 +@section Advanced Audio options
 +
 +@table @option
 +@item -atag @var{fourcc/tag} (@emph{output})
 +Force audio tag/fourcc. This is an alias for @code{-tag:a}.
 +@item -absf @var{bitstream_filter}
 +Deprecated, see -bsf
 +@item -guess_layout_max @var{channels} (@emph{input,per-stream})
 +If some input channel layout is not known, try to guess only if it
 +corresponds to at most the specified number of channels. For example, 2
 +tells to @command{ffmpeg} to recognize 1 channel as mono and 2 channels as
 +stereo but not 6 channels as 5.1. The default is to always try to guess. Use
 +0 to disable all guessing.
 +@end table
 +
 +@section Subtitle options
 +
 +@table @option
 +@item -scodec @var{codec} (@emph{input/output})
 +Set the subtitle codec. This is an alias for @code{-codec:s}.
 +@item -sn (@emph{output})
 +Disable subtitle recording.
 +@item -sbsf @var{bitstream_filter}
 +Deprecated, see -bsf
 +@end table
 +
 +@section Advanced Subtitle options
 +
 +@table @option
 +
 +@item -fix_sub_duration
 +Fix subtitles durations. For each subtitle, wait for the next packet in the
 +same stream and adjust the duration of the first to avoid overlap. This is
 +necessary with some subtitles codecs, especially DVB subtitles, because the
 +duration in the original packet is only a rough estimate and the end is
 +actually marked by an empty subtitle frame. Failing to use this option when
 +necessary can result in exaggerated durations or muxing failures due to
 +non-monotonic timestamps.
 +
 +Note that this option will delay the output of all data until the next
 +subtitle packet is decoded: it may increase memory consumption and latency a
 +lot.
 +
 +@item -canvas_size @var{size}
 +Set the size of the canvas used to render subtitles.
 +
 +@end table
 +
 +@section Advanced options
 +
 +@table @option
 +@item -map [-]@var{input_file_id}[:@var{stream_specifier}][,@var{sync_file_id}[:@var{stream_specifier}]] | @var{[linklabel]} (@emph{output})
 +
 +Designate one or more input streams as a source for the output file. Each input
 +stream is identified by the input file index @var{input_file_id} and
 +the input stream index @var{input_stream_id} within the input
 +file. Both indices start at 0. If specified,
 +@var{sync_file_id}:@var{stream_specifier} sets which input stream
 +is used as a presentation sync reference.
 +
 +The first @code{-map} option on the command line specifies the
 +source for output stream 0, the second @code{-map} option specifies
 +the source for output stream 1, etc.
 +
 +A @code{-} character before the stream identifier creates a "negative" mapping.
 +It disables matching streams from already created mappings.
 +
 +An alternative @var{[linklabel]} form will map outputs from complex filter
 +graphs (see the @option{-filter_complex} option) to the output file.
 +@var{linklabel} must correspond to a defined output link label in the graph.
 +
 +For example, to map ALL streams from the first input file to output
 +@example
 +ffmpeg -i INPUT -map 0 output
 +@end example
 +
 +For example, if you have two audio streams in the first input file,
 +these streams are identified by "0:0" and "0:1". You can use
 +@code{-map} to select which streams to place in an output file. For
 +example:
 +@example
 +ffmpeg -i INPUT -map 0:1 out.wav
 +@end example
 +will map the input stream in @file{INPUT} identified by "0:1" to
 +the (single) output stream in @file{out.wav}.
 +
 +For example, to select the stream with index 2 from input file
 +@file{a.mov} (specified by the identifier "0:2"), and stream with
 +index 6 from input @file{b.mov} (specified by the identifier "1:6"),
 +and copy them to the output file @file{out.mov}:
 +@example
 +ffmpeg -i a.mov -i b.mov -c copy -map 0:2 -map 1:6 out.mov
 +@end example
 +
 +To select all video and the third audio stream from an input file:
 +@example
 +ffmpeg -i INPUT -map 0:v -map 0:a:2 OUTPUT
 +@end example
 +
 +To map all the streams except the second audio, use negative mappings
 +@example
 +ffmpeg -i INPUT -map 0 -map -0:a:1 OUTPUT
 +@end example
 +
 +To pick the English audio stream:
 +@example
 +ffmpeg -i INPUT -map 0:m:language:eng OUTPUT
 +@end example
 +
 +Note that using this option disables the default mappings for this output file.
 +
 +@item -ignore_unknown
 +Ignore input streams with unknown type instead of failing if copying
 +such streams is attempted.
 +
 +@item -copy_unknown
 +Allow input streams with unknown type to be copied instead of failing if copying
 +such streams is attempted.
 +
 +@item -map_channel [@var{input_file_id}.@var{stream_specifier}.@var{channel_id}|-1][:@var{output_file_id}.@var{stream_specifier}]
 +Map an audio channel from a given input to an output. If
 +@var{output_file_id}.@var{stream_specifier} is not set, the audio channel will
 +be mapped on all the audio streams.
 +
 +Using "-1" instead of
 +@var{input_file_id}.@var{stream_specifier}.@var{channel_id} will map a muted
 +channel.
 +
 +For example, assuming @var{INPUT} is a stereo audio file, you can switch the
 +two audio channels with the following command:
 +@example
 +ffmpeg -i INPUT -map_channel 0.0.1 -map_channel 0.0.0 OUTPUT
 +@end example
 +
 +If you want to mute the first channel and keep the second:
 +@example
 +ffmpeg -i INPUT -map_channel -1 -map_channel 0.0.1 OUTPUT
 +@end example
 +
 +The order of the "-map_channel" option specifies the order of the channels in
 +the output stream. The output channel layout is guessed from the number of
 +channels mapped (mono if one "-map_channel", stereo if two, etc.). Using "-ac"
 +in combination of "-map_channel" makes the channel gain levels to be updated if
 +input and output channel layouts don't match (for instance two "-map_channel"
 +options and "-ac 6").
 +
 +You can also extract each channel of an input to specific outputs; the following
 +command extracts two channels of the @var{INPUT} audio stream (file 0, stream 0)
 +to the respective @var{OUTPUT_CH0} and @var{OUTPUT_CH1} outputs:
 +@example
 +ffmpeg -i INPUT -map_channel 0.0.0 OUTPUT_CH0 -map_channel 0.0.1 OUTPUT_CH1
 +@end example
 +
 +The following example splits the channels of a stereo input into two separate
 +streams, which are put into the same output file:
 +@example
 +ffmpeg -i stereo.wav -map 0:0 -map 0:0 -map_channel 0.0.0:0.0 -map_channel 0.0.1:0.1 -y out.ogg
 +@end example
 +
 +Note that currently each output stream can only contain channels from a single
 +input stream; you can't for example use "-map_channel" to pick multiple input
 +audio channels contained in different streams (from the same or different files)
 +and merge them into a single output stream. It is therefore not currently
 +possible, for example, to turn two separate mono streams into a single stereo
 +stream. However splitting a stereo stream into two single channel mono streams
 +is possible.
 +
 +If you need this feature, a possible workaround is to use the @emph{amerge}
 +filter. For example, if you need to merge a media (here @file{input.mkv}) with 2
 +mono audio streams into one single stereo channel audio stream (and keep the
 +video stream), you can use the following command:
 +@example
 +ffmpeg -i input.mkv -filter_complex "[0:1] [0:2] amerge" -c:a pcm_s16le -c:v copy output.mkv
 +@end example
 +
 +@item -map_metadata[:@var{metadata_spec_out}] @var{infile}[:@var{metadata_spec_in}] (@emph{output,per-metadata})
 +Set metadata information of the next output file from @var{infile}. Note that
 +those are file indices (zero-based), not filenames.
 +Optional @var{metadata_spec_in/out} parameters specify, which metadata to copy.
 +A metadata specifier can have the following forms:
 +@table @option
 +@item @var{g}
 +global metadata, i.e. metadata that applies to the whole file
 +
 +@item @var{s}[:@var{stream_spec}]
 +per-stream metadata. @var{stream_spec} is a stream specifier as described
 +in the @ref{Stream specifiers} chapter. In an input metadata specifier, the first
 +matching stream is copied from. In an output metadata specifier, all matching
 +streams are copied to.
 +
 +@item @var{c}:@var{chapter_index}
 +per-chapter metadata. @var{chapter_index} is the zero-based chapter index.
 +
 +@item @var{p}:@var{program_index}
 +per-program metadata. @var{program_index} is the zero-based program index.
 +@end table
 +If metadata specifier is omitted, it defaults to global.
 +
 +By default, global metadata is copied from the first input file,
 +per-stream and per-chapter metadata is copied along with streams/chapters. These
 +default mappings are disabled by creating any mapping of the relevant type. A negative
 +file index can be used to create a dummy mapping that just disables automatic copying.
 +
 +For example to copy metadata from the first stream of the input file to global metadata
 +of the output file:
 +@example
 +ffmpeg -i in.ogg -map_metadata 0:s:0 out.mp3
 +@end example
 +
 +To do the reverse, i.e. copy global metadata to all audio streams:
 +@example
 +ffmpeg -i in.mkv -map_metadata:s:a 0:g out.mkv
 +@end example
 +Note that simple @code{0} would work as well in this example, since global
 +metadata is assumed by default.
 +
 +@item -map_chapters @var{input_file_index} (@emph{output})
 +Copy chapters from input file with index @var{input_file_index} to the next
 +output file. If no chapter mapping is specified, then chapters are copied from
 +the first input file with at least one chapter. Use a negative file index to
 +disable any chapter copying.
 +
 +@item -benchmark (@emph{global})
 +Show benchmarking information at the end of an encode.
 +Shows CPU time used and maximum memory consumption.
 +Maximum memory consumption is not supported on all systems,
 +it will usually display as 0 if not supported.
 +@item -benchmark_all (@emph{global})
 +Show benchmarking information during the encode.
 +Shows CPU time used in various steps (audio/video encode/decode).
 +@item -timelimit @var{duration} (@emph{global})
 +Exit after ffmpeg has been running for @var{duration} seconds.
 +@item -dump (@emph{global})
 +Dump each input packet to stderr.
 +@item -hex (@emph{global})
 +When dumping packets, also dump the payload.
 +@item -re (@emph{input})
 +Read input at native frame rate. Mainly used to simulate a grab device.
 +or live input stream (e.g. when reading from a file). Should not be used
 +with actual grab devices or live input streams (where it can cause packet
 +loss).
 +By default @command{ffmpeg} attempts to read the input(s) as fast as possible.
 +This option will slow down the reading of the input(s) to the native frame rate
 +of the input(s). It is useful for real-time output (e.g. live streaming).
 +@item -loop_input
 +Loop over the input stream. Currently it works only for image
 +streams. This option is used for automatic FFserver testing.
 +This option is deprecated, use -loop 1.
 +@item -loop_output @var{number_of_times}
 +Repeatedly loop output for formats that support looping such as animated GIF
 +(0 will loop the output infinitely).
 +This option is deprecated, use -loop.
 +@item -vsync @var{parameter}
 +Video sync method.
 +For compatibility reasons old values can be specified as numbers.
 +Newly added values will have to be specified as strings always.
 +
 +@table @option
 +@item 0, passthrough
 +Each frame is passed with its timestamp from the demuxer to the muxer.
 +@item 1, cfr
 +Frames will be duplicated and dropped to achieve exactly the requested
 +constant frame rate.
 +@item 2, vfr
 +Frames are passed through with their timestamp or dropped so as to
 +prevent 2 frames from having the same timestamp.
 +@item drop
 +As passthrough but destroys all timestamps, making the muxer generate
 +fresh timestamps based on frame-rate.
 +@item -1, auto
 +Chooses between 1 and 2 depending on muxer capabilities. This is the
 +default method.
 +@end table
 +
 +Note that the timestamps may be further modified by the muxer, after this.
 +For example, in the case that the format option @option{avoid_negative_ts}
 +is enabled.
 +
 +With -map you can select from which stream the timestamps should be
 +taken. You can leave either video or audio unchanged and sync the
 +remaining stream(s) to the unchanged one.
 +
 +@item -frame_drop_threshold @var{parameter}
 +Frame drop threshold, which specifies how much behind video frames can
 +be before they are dropped. In frame rate units, so 1.0 is one frame.
 +The default is -1.1. One possible usecase is to avoid framedrops in case
 +of noisy timestamps or to increase frame drop precision in case of exact
 +timestamps.
 +
 +@item -async @var{samples_per_second}
 +Audio sync method. "Stretches/squeezes" the audio stream to match the timestamps,
 +the parameter is the maximum samples per second by which the audio is changed.
 +-async 1 is a special case where only the start of the audio stream is corrected
 +without any later correction.
 +
 +Note that the timestamps may be further modified by the muxer, after this.
 +For example, in the case that the format option @option{avoid_negative_ts}
 +is enabled.
 +
 +This option has been deprecated. Use the @code{aresample} audio filter instead.
 +
 +@item -copyts
 +Do not process input timestamps, but keep their values without trying
 +to sanitize them. In particular, do not remove the initial start time
 +offset value.
 +
 +Note that, depending on the @option{vsync} option or on specific muxer
 +processing (e.g. in case the format option @option{avoid_negative_ts}
 +is enabled) the output timestamps may mismatch with the input
 +timestamps even when this option is selected.
 +
 +@item -start_at_zero
 +When used with @option{copyts}, shift input timestamps so they start at zero.
 +
 +This means that using e.g. @code{-ss 50} will make output timestamps start at
 +50 seconds, regardless of what timestamp the input file started at.
 +
 +@item -copytb @var{mode}
 +Specify how to set the encoder timebase when stream copying.  @var{mode} is an
 +integer numeric value, and can assume one of the following values:
 +
 +@table @option
 +@item 1
 +Use the demuxer timebase.
 +
 +The time base is copied to the output encoder from the corresponding input
 +demuxer. This is sometimes required to avoid non monotonically increasing
 +timestamps when copying video streams with variable frame rate.
 +
 +@item 0
 +Use the decoder timebase.
 +
 +The time base is copied to the output encoder from the corresponding input
 +decoder.
 +
 +@item -1
 +Try to make the choice automatically, in order to generate a sane output.
 +@end table
 +
 +Default value is -1.
 +
 +@item -shortest (@emph{output})
 +Finish encoding when the shortest input stream ends.
 +@item -dts_delta_threshold
 +Timestamp discontinuity delta threshold.
 +@item -muxdelay @var{seconds} (@emph{input})
 +Set the maximum demux-decode delay.
 +@item -muxpreload @var{seconds} (@emph{input})
 +Set the initial demux-decode delay.
 +@item -streamid @var{output-stream-index}:@var{new-value} (@emph{output})
 +Assign a new stream-id value to an output stream. This option should be
 +specified prior to the output filename to which it applies.
 +For the situation where multiple output files exist, a streamid
 +may be reassigned to a different value.
 +
 +For example, to set the stream 0 PID to 33 and the stream 1 PID to 36 for
 +an output mpegts file:
 +@example
 +ffmpeg -i infile -streamid 0:33 -streamid 1:36 out.ts
 +@end example
 +
 +@item -bsf[:@var{stream_specifier}] @var{bitstream_filters} (@emph{output,per-stream})
 +Set bitstream filters for matching streams. @var{bitstream_filters} is
 +a comma-separated list of bitstream filters. Use the @code{-bsfs} option
 +to get the list of bitstream filters.
 +@example
 +ffmpeg -i h264.mp4 -c:v copy -bsf:v h264_mp4toannexb -an out.h264
 +@end example
 +@example
 +ffmpeg -i file.mov -an -vn -bsf:s mov2textsub -c:s copy -f rawvideo sub.txt
 +@end example
 +
 +@item -tag[:@var{stream_specifier}] @var{codec_tag} (@emph{input/output,per-stream})
 +Force a tag/fourcc for matching streams.
 +
 +@item -timecode @var{hh}:@var{mm}:@var{ss}SEP@var{ff}
 +Specify Timecode for writing. @var{SEP} is ':' for non drop timecode and ';'
 +(or '.') for drop.
 +@example
 +ffmpeg -i input.mpg -timecode 01:02:03.04 -r 30000/1001 -s ntsc output.mpg
 +@end example
 +
 +@anchor{filter_complex_option}
 +@item -filter_complex @var{filtergraph} (@emph{global})
 +Define a complex filtergraph, i.e. one with arbitrary number of inputs and/or
 +outputs. For simple graphs -- those with one input and one output of the same
 +type -- see the @option{-filter} options. @var{filtergraph} is a description of
 +the filtergraph, as described in the ``Filtergraph syntax'' section of the
 +ffmpeg-filters manual.
 +
 +Input link labels must refer to input streams using the
 +@code{[file_index:stream_specifier]} syntax (i.e. the same as @option{-map}
 +uses). If @var{stream_specifier} matches multiple streams, the first one will be
 +used. An unlabeled input will be connected to the first unused input stream of
 +the matching type.
 +
 +Output link labels are referred to with @option{-map}. Unlabeled outputs are
 +added to the first output file.
 +
 +Note that with this option it is possible to use only lavfi sources without
 +normal input files.
 +
 +For example, to overlay an image over video
 +@example
 +ffmpeg -i video.mkv -i image.png -filter_complex '[0:v][1:v]overlay[out]' -map
 +'[out]' out.mkv
 +@end example
 +Here @code{[0:v]} refers to the first video stream in the first input file,
 +which is linked to the first (main) input of the overlay filter. Similarly the
 +first video stream in the second input is linked to the second (overlay) input
 +of overlay.
 +
 +Assuming there is only one video stream in each input file, we can omit input
 +labels, so the above is equivalent to
 +@example
 +ffmpeg -i video.mkv -i image.png -filter_complex 'overlay[out]' -map
 +'[out]' out.mkv
 +@end example
 +
 +Furthermore we can omit the output label and the single output from the filter
 +graph will be added to the output file automatically, so we can simply write
 +@example
 +ffmpeg -i video.mkv -i image.png -filter_complex 'overlay' out.mkv
 +@end example
 +
 +To generate 5 seconds of pure red video using lavfi @code{color} source:
 +@example
 +ffmpeg -filter_complex 'color=c=red' -t 5 out.mkv
 +@end example
 +
 +@item -lavfi @var{filtergraph} (@emph{global})
 +Define a complex filtergraph, i.e. one with arbitrary number of inputs and/or
 +outputs. Equivalent to @option{-filter_complex}.
 +
 +@item -filter_complex_script @var{filename} (@emph{global})
 +This option is similar to @option{-filter_complex}, the only difference is that
 +its argument is the name of the file from which a complex filtergraph
 +description is to be read.
 +
 +@item -accurate_seek (@emph{input})
 +This option enables or disables accurate seeking in input files with the
 +@option{-ss} option. It is enabled by default, so seeking is accurate when
 +transcoding. Use @option{-noaccurate_seek} to disable it, which may be useful
 +e.g. when copying some streams and transcoding the others.
 +
 +@item -seek_timestamp (@emph{input})
 +This option enables or disables seeking by timestamp in input files with the
 +@option{-ss} option. It is disabled by default. If enabled, the argument
 +to the @option{-ss} option is considered an actual timestamp, and is not
 +offset by the start time of the file. This matters only for files which do
 +not start from timestamp 0, such as transport streams.
 +
 +@item -thread_queue_size @var{size} (@emph{input})
 +This option sets the maximum number of queued packets when reading from the
 +file or device. With low latency / high rate live streams, packets may be
 +discarded if they are not read in a timely manner; raising this value can
 +avoid it.
 +
 +@item -override_ffserver (@emph{global})
 +Overrides the input specifications from @command{ffserver}. Using this
 +option you can map any input stream to @command{ffserver} and control
 +many aspects of the encoding from @command{ffmpeg}. Without this
 +option @command{ffmpeg} will transmit to @command{ffserver} what is
 +requested by @command{ffserver}.
 +
 +The option is intended for cases where features are needed that cannot be
 +specified to @command{ffserver} but can be to @command{ffmpeg}.
 +
 +@item -sdp_file @var{file} (@emph{global})
 +Print sdp information for an output stream to @var{file}.
 +This allows dumping sdp information when at least one output isn't an
 +rtp stream. (Requires at least one of the output formats to be rtp).
 +
 +@item -discard (@emph{input})
 +Allows discarding specific streams or frames of streams at the demuxer.
 +Not all demuxers support this.
 +
 +@table @option
 +@item none
 +Discard no frame.
 +
 +@item default
 +Default, which discards no frames.
 +
 +@item noref
 +Discard all non-reference frames.
 +
 +@item bidir
 +Discard all bidirectional frames.
 +
 +@item nokey
 +Discard all frames excepts keyframes.
 +
 +@item all
 +Discard all frames.
 +@end table
 +
 +@item -abort_on @var{flags} (@emph{global})
 +Stop and abort on various conditions. The following flags are available:
 +
 +@table @option
 +@item empty_output
 +No packets were passed to the muxer, the output is empty.
 +@end table
 +
 +@item -xerror (@emph{global})
 +Stop and exit on error
 +
 +@end table
 +
 +As a special exception, you can use a bitmap subtitle stream as input: it
 +will be converted into a video with the same size as the largest video in
 +the file, or 720x576 if no video is present. Note that this is an
 +experimental and temporary solution. It will be removed once libavfilter has
 +proper support for subtitles.
 +
 +For example, to hardcode subtitles on top of a DVB-T recording stored in
 +MPEG-TS format, delaying the subtitles by 1 second:
 +@example
 +ffmpeg -i input.ts -filter_complex \
 +  '[#0x2ef] setpts=PTS+1/TB [sub] ; [#0x2d0] [sub] overlay' \
 +  -sn -map '#0x2dc' output.mkv
 +@end example
 +(0x2d0, 0x2dc and 0x2ef are the MPEG-TS PIDs of respectively the video,
 +audio and subtitles streams; 0:0, 0:3 and 0:7 would have worked too)
 +
 +@section Preset files
 +A preset file contains a sequence of @var{option}=@var{value} pairs,
 +one for each line, specifying a sequence of options which would be
 +awkward to specify on the command line. Lines starting with the hash
 +('#') character are ignored and are used to provide comments. Check
 +the @file{presets} directory in the FFmpeg source tree for examples.
 +
 +There are two types of preset files: ffpreset and avpreset files.
 +
 +@subsection ffpreset files
 +ffpreset files are specified with the @code{vpre}, @code{apre},
 +@code{spre}, and @code{fpre} options. The @code{fpre} option takes the
 +filename of the preset instead of a preset name as input and can be
 +used for any kind of codec. For the @code{vpre}, @code{apre}, and
 +@code{spre} options, the options specified in a preset file are
 +applied to the currently selected codec of the same type as the preset
 +option.
 +
 +The argument passed to the @code{vpre}, @code{apre}, and @code{spre}
 +preset options identifies the preset file to use according to the
 +following rules:
 +
 +First ffmpeg searches for a file named @var{arg}.ffpreset in the
 +directories @file{$FFMPEG_DATADIR} (if set), and @file{$HOME/.ffmpeg}, and in
 +the datadir defined at configuration time (usually @file{PREFIX/share/ffmpeg})
 +or in a @file{ffpresets} folder along the executable on win32,
 +in that order. For example, if the argument is @code{libvpx-1080p}, it will
 +search for the file @file{libvpx-1080p.ffpreset}.
 +
 +If no such file is found, then ffmpeg will search for a file named
 +@var{codec_name}-@var{arg}.ffpreset in the above-mentioned
 +directories, where @var{codec_name} is the name of the codec to which
 +the preset file options will be applied. For example, if you select
 +the video codec with @code{-vcodec libvpx} and use @code{-vpre 1080p},
 +then it will search for the file @file{libvpx-1080p.ffpreset}.
 +
 +@subsection avpreset files
 +avpreset files are specified with the @code{pre} option. They work similar to
 +ffpreset files, but they only allow encoder- specific options. Therefore, an
 +@var{option}=@var{value} pair specifying an encoder cannot be used.
 +
 +When the @code{pre} option is specified, ffmpeg will look for files with the
 +suffix .avpreset in the directories @file{$AVCONV_DATADIR} (if set), and
 +@file{$HOME/.avconv}, and in the datadir defined at configuration time (usually
 +@file{PREFIX/share/ffmpeg}), in that order.
 +
 +First ffmpeg searches for a file named @var{codec_name}-@var{arg}.avpreset in
 +the above-mentioned directories, where @var{codec_name} is the name of the codec
 +to which the preset file options will be applied. For example, if you select the
 +video codec with @code{-vcodec libvpx} and use @code{-pre 1080p}, then it will
 +search for the file @file{libvpx-1080p.avpreset}.
 +
 +If no such file is found, then ffmpeg will search for a file named
 +@var{arg}.avpreset in the same directories.
 +
 +@c man end OPTIONS
 +
 +@chapter Examples
 +@c man begin EXAMPLES
 +
 +@section Video and Audio grabbing
 +
 +If you specify the input format and device then ffmpeg can grab video
 +and audio directly.
 +
 +@example
 +ffmpeg -f oss -i /dev/dsp -f video4linux2 -i /dev/video0 /tmp/out.mpg
 +@end example
 +
 +Or with an ALSA audio source (mono input, card id 1) instead of OSS:
 +@example
 +ffmpeg -f alsa -ac 1 -i hw:1 -f video4linux2 -i /dev/video0 /tmp/out.mpg
 +@end example
 +
 +Note that you must activate the right video source and channel before
 +launching ffmpeg with any TV viewer such as
 +@uref{http://linux.bytesex.org/xawtv/, xawtv} by Gerd Knorr. You also
 +have to set the audio recording levels correctly with a
 +standard mixer.
 +
 +@section X11 grabbing
 +
 +Grab the X11 display with ffmpeg via
 +
 +@example
 +ffmpeg -f x11grab -video_size cif -framerate 25 -i :0.0 /tmp/out.mpg
 +@end example
 +
 +0.0 is display.screen number of your X11 server, same as
 +the DISPLAY environment variable.
 +
 +@example
 +ffmpeg -f x11grab -video_size cif -framerate 25 -i :0.0+10,20 /tmp/out.mpg
 +@end example
 +
 +0.0 is display.screen number of your X11 server, same as the DISPLAY environment
 +variable. 10 is the x-offset and 20 the y-offset for the grabbing.
 +
 +@section Video and Audio file format conversion
 +
 +Any supported file format and protocol can serve as input to ffmpeg:
 +
 +Examples:
 +@itemize
 +@item
 +You can use YUV files as input:
 +
 +@example
 +ffmpeg -i /tmp/test%d.Y /tmp/out.mpg
 +@end example
 +
 +It will use the files:
 +@example
 +/tmp/test0.Y, /tmp/test0.U, /tmp/test0.V,
 +/tmp/test1.Y, /tmp/test1.U, /tmp/test1.V, etc...
 +@end example
 +
 +The Y files use twice the resolution of the U and V files. They are
 +raw files, without header. They can be generated by all decent video
 +decoders. You must specify the size of the image with the @option{-s} option
 +if ffmpeg cannot guess it.
 +
 +@item
 +You can input from a raw YUV420P file:
 +
 +@example
 +ffmpeg -i /tmp/test.yuv /tmp/out.avi
 +@end example
 +
 +test.yuv is a file containing raw YUV planar data. Each frame is composed
 +of the Y plane followed by the U and V planes at half vertical and
 +horizontal resolution.
 +
 +@item
 +You can output to a raw YUV420P file:
 +
 +@example
 +ffmpeg -i mydivx.avi hugefile.yuv
 +@end example
 +
 +@item
 +You can set several input files and output files:
 +
 +@example
 +ffmpeg -i /tmp/a.wav -s 640x480 -i /tmp/a.yuv /tmp/a.mpg
 +@end example
 +
 +Converts the audio file a.wav and the raw YUV video file a.yuv
 +to MPEG file a.mpg.
 +
 +@item
 +You can also do audio and video conversions at the same time:
 +
 +@example
 +ffmpeg -i /tmp/a.wav -ar 22050 /tmp/a.mp2
 +@end example
 +
 +Converts a.wav to MPEG audio at 22050 Hz sample rate.
 +
 +@item
 +You can encode to several formats at the same time and define a
 +mapping from input stream to output streams:
 +
 +@example
 +ffmpeg -i /tmp/a.wav -map 0:a -b:a 64k /tmp/a.mp2 -map 0:a -b:a 128k /tmp/b.mp2
 +@end example
 +
 +Converts a.wav to a.mp2 at 64 kbits and to b.mp2 at 128 kbits. '-map
 +file:index' specifies which input stream is used for each output
 +stream, in the order of the definition of output streams.
 +
 +@item
 +You can transcode decrypted VOBs:
 +
 +@example
 +ffmpeg -i snatch_1.vob -f avi -c:v mpeg4 -b:v 800k -g 300 -bf 2 -c:a libmp3lame -b:a 128k snatch.avi
 +@end example
 +
 +This is a typical DVD ripping example; the input is a VOB file, the
 +output an AVI file with MPEG-4 video and MP3 audio. Note that in this
 +command we use B-frames so the MPEG-4 stream is DivX5 compatible, and
 +GOP size is 300 which means one intra frame every 10 seconds for 29.97fps
 +input video. Furthermore, the audio stream is MP3-encoded so you need
 +to enable LAME support by passing @code{--enable-libmp3lame} to configure.
 +The mapping is particularly useful for DVD transcoding
 +to get the desired audio language.
 +
 +NOTE: To see the supported input formats, use @code{ffmpeg -formats}.
 +
 +@item
 +You can extract images from a video, or create a video from many images:
 +
 +For extracting images from a video:
 +@example
 +ffmpeg -i foo.avi -r 1 -s WxH -f image2 foo-%03d.jpeg
 +@end example
 +
 +This will extract one video frame per second from the video and will
 +output them in files named @file{foo-001.jpeg}, @file{foo-002.jpeg},
 +etc. Images will be rescaled to fit the new WxH values.
 +
 +If you want to extract just a limited number of frames, you can use the
 +above command in combination with the -vframes or -t option, or in
 +combination with -ss to start extracting from a certain point in time.
 +
 +For creating a video from many images:
 +@example
 +ffmpeg -f image2 -framerate 12 -i foo-%03d.jpeg -s WxH foo.avi
 +@end example
 +
 +The syntax @code{foo-%03d.jpeg} specifies to use a decimal number
 +composed of three digits padded with zeroes to express the sequence
 +number. It is the same syntax supported by the C printf function, but
 +only formats accepting a normal integer are suitable.
 +
 +When importing an image sequence, -i also supports expanding
 +shell-like wildcard patterns (globbing) internally, by selecting the
 +image2-specific @code{-pattern_type glob} option.
 +
 +For example, for creating a video from filenames matching the glob pattern
 +@code{foo-*.jpeg}:
 +@example
 +ffmpeg -f image2 -pattern_type glob -framerate 12 -i 'foo-*.jpeg' -s WxH foo.avi
 +@end example
 +
 +@item
 +You can put many streams of the same type in the output:
 +
 +@example
 +ffmpeg -i test1.avi -i test2.avi -map 1:1 -map 1:0 -map 0:1 -map 0:0 -c copy -y test12.nut
 +@end example
 +
 +The resulting output file @file{test12.nut} will contain the first four streams
 +from the input files in reverse order.
 +
 +@item
 +To force CBR video output:
 +@example
 +ffmpeg -i myfile.avi -b 4000k -minrate 4000k -maxrate 4000k -bufsize 1835k out.m2v
 +@end example
 +
 +@item
 +The four options lmin, lmax, mblmin and mblmax use 'lambda' units,
 +but you may use the QP2LAMBDA constant to easily convert from 'q' units:
 +@example
 +ffmpeg -i src.ext -lmax 21*QP2LAMBDA dst.ext
 +@end example
 +
 +@end itemize
 +@c man end EXAMPLES
 +
 +@include config.texi
 +@ifset config-all
 +@ifset config-avutil
 +@include utils.texi
 +@end ifset
 +@ifset config-avcodec
 +@include codecs.texi
 +@include bitstream_filters.texi
 +@end ifset
 +@ifset config-avformat
 +@include formats.texi
 +@include protocols.texi
 +@end ifset
 +@ifset config-avdevice
 +@include devices.texi
 +@end ifset
 +@ifset config-swresample
 +@include resampler.texi
 +@end ifset
 +@ifset config-swscale
 +@include scaler.texi
 +@end ifset
 +@ifset config-avfilter
 +@include filters.texi
 +@end ifset
 +@end ifset
 +
 +@chapter See Also
 +
 +@ifhtml
 +@ifset config-all
 +@url{ffmpeg.html,ffmpeg}
 +@end ifset
 +@ifset config-not-all
 +@url{ffmpeg-all.html,ffmpeg-all},
 +@end ifset
 +@url{ffplay.html,ffplay}, @url{ffprobe.html,ffprobe}, @url{ffserver.html,ffserver},
 +@url{ffmpeg-utils.html,ffmpeg-utils},
 +@url{ffmpeg-scaler.html,ffmpeg-scaler},
 +@url{ffmpeg-resampler.html,ffmpeg-resampler},
 +@url{ffmpeg-codecs.html,ffmpeg-codecs},
 +@url{ffmpeg-bitstream-filters.html,ffmpeg-bitstream-filters},
 +@url{ffmpeg-formats.html,ffmpeg-formats},
 +@url{ffmpeg-devices.html,ffmpeg-devices},
 +@url{ffmpeg-protocols.html,ffmpeg-protocols},
 +@url{ffmpeg-filters.html,ffmpeg-filters}
 +@end ifhtml
 +
 +@ifnothtml
 +@ifset config-all
 +ffmpeg(1),
 +@end ifset
 +@ifset config-not-all
 +ffmpeg-all(1),
 +@end ifset
 +ffplay(1), ffprobe(1), ffserver(1),
 +ffmpeg-utils(1), ffmpeg-scaler(1), ffmpeg-resampler(1),
 +ffmpeg-codecs(1), ffmpeg-bitstream-filters(1), ffmpeg-formats(1),
 +ffmpeg-devices(1), ffmpeg-protocols(1), ffmpeg-filters(1)
 +@end ifnothtml
 +
 +@include authors.texi
 +
 +@ignore
 +
 +@setfilename ffmpeg
 +@settitle ffmpeg video converter
 +
 +@end ignore
 +
 +@bye

diff --cc doc/filters.texi
index f47b0cc,2651f17..7267b21
--- 1/doc/filters.texi
--- 2/doc/filters.texi
+++ b/doc/filters.texi
@@@ -3695,13013 -2304,459 +3695,13013 @@@ Default value for @var{replaygain_nocli
  
  @end table
  
 -The default value of the select expression is "1".
 +@subsection Examples
  
 -Some examples:
 +@itemize
 +@item
 +Halve the input audio volume:
 +@example
 +volume=volume=0.5
 +volume=volume=1/2
 +volume=volume=-6.0206dB
 +@end example
  
 +In all the above example the named key for @option{volume} can be
 +omitted, for example like in:
  @example
 -# Select all the frames in input
 -select
 +volume=0.5
 +@end example
  
 -# The above is the same as
 -select=expr=1
 +@item
 +Increase input audio power by 6 decibels using fixed-point precision:
 +@example
 +volume=volume=6dB:precision=fixed
 +@end example
  
 -# Skip all frames
 -select=expr=0
 +@item
 +Fade volume after time 10 with an annihilation period of 5 seconds:
 +@example
 +volume='if(lt(t,10),1,max(1-(t-10)/5,0))':eval=frame
 +@end example
 +@end itemize
  
 -# Select only I-frames
 -select='expr=eq(pict_type\,I)'
 +@section volumedetect
  
 -# Select one frame per 100
 -select='not(mod(n\,100))'
 +Detect the volume of the input video.
  
 -# Select only frames contained in the 10-20 time interval
 -select='gte(t\,10)*lte(t\,20)'
 +The filter has no parameters. The input is not modified. Statistics about
 +the volume will be printed in the log when the input stream end is reached.
  
 -# Select only I-frames contained in the 10-20 time interval
 -select='gte(t\,10)*lte(t\,20)*eq(pict_type\,I)'
 +In particular it will show the mean volume (root mean square), maximum
 +volume (on a per-sample basis), and the beginning of a histogram of the
 +registered volume values (from the maximum value to a cumulated 1/1000 of
 +the samples).
  
 -# Select frames with a minimum distance of 10 seconds
 -select='isnan(prev_selected_t)+gte(t-prev_selected_t\,10)'
 -@end example
 +All volumes are in decibels relative to the maximum PCM value.
  
 -@anchor{setdar}
 -@section setdar
 +@subsection Examples
  
 -Set the Display Aspect Ratio for the filter output video.
 +Here is an excerpt of the output:
 +@example
 +[Parsed_volumedetect_0 @ 0xa23120] mean_volume: -27 dB
 +[Parsed_volumedetect_0 @ 0xa23120] max_volume: -4 dB
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_4db: 6
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_5db: 62
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_6db: 286
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_7db: 1042
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_8db: 2551
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_9db: 4609
 +[Parsed_volumedetect_0 @ 0xa23120] histogram_10db: 8409
 +@end example
  
 -This is done by changing the specified Sample (aka Pixel) Aspect
 -Ratio, according to the following equation:
 -@math{DAR = HORIZONTAL_RESOLUTION / VERTICAL_RESOLUTION * SAR}
 +It means that:
 +@itemize
 +@item
 +The mean square energy is approximately -27 dB, or 10^-2.7.
 +@item
 +The largest sample is at -4 dB, or more precisely between -4 dB and -5 dB.
 +@item
 +There are 6 samples at -4 dB, 62 at -5 dB, 286 at -6 dB, etc.
 +@end itemize
  
 -Keep in mind that this filter does not modify the pixel dimensions of
 -the video frame. Also, the display aspect ratio set by this filter may
 -be changed by later filters in the filterchain, e.g. in case of
 -scaling or if another "setdar" or a "setsar" filter is applied.
 +In other words, raising the volume by +4 dB does not cause any clipping,
 +raising it by +5 dB causes clipping for 6 samples, etc.
  
 -It accepts the following parameters:
 +@c man end AUDIO FILTERS
  
 -@table @option
 +@chapter Audio Sources
 +@c man begin AUDIO SOURCES
  
 -@item dar
 -The output display aspect ratio.
 +Below is a description of the currently available audio sources.
  
 -@end table
 +@section abuffer
  
 -The parameter @var{dar} is an expression containing
 -the following constants:
 +Buffer audio frames, and make them available to the filter chain.
 +
 +This source is mainly intended for a programmatic use, in particular
 +through the interface defined in @file{libavfilter/asrc_abuffer.h}.
  
 +It accepts the following parameters:
  @table @option
 -@item E, PI, PHI
 -These are approximated values for the mathematical constants e
 -(Euler's number), pi (Greek pi), and phi (the golden ratio).
  
 -@item w, h
 -The input width and height.
 +@item time_base
 +The timebase which will be used for timestamps of submitted frames. It must be
 +either a floating-point number or in @var{numerator}/@var{denominator} form.
  
 -@item a
 -This is the same as @var{w} / @var{h}.
 +@item sample_rate
 +The sample rate of the incoming audio buffers.
  
 -@item sar
 -The input sample aspect ratio.
 +@item sample_fmt
 +The sample format of the incoming audio buffers.
 +Either a sample format name or its corresponding integer representation from
 +the enum AVSampleFormat in @file{libavutil/samplefmt.h}
  
 -@item dar
 -The input display aspect ratio. It is the same as
 -(@var{w} / @var{h}) * @var{sar}.
 +@item channel_layout
 +The channel layout of the incoming audio buffers.
 +Either a channel layout name from channel_layout_map in
 +@file{libavutil/channel_layout.c} or its corresponding integer representation
 +from the AV_CH_LAYOUT_* macros in @file{libavutil/channel_layout.h}
 +
 +@item channels
 +The number of channels of the incoming audio buffers.
 +If both @var{channels} and @var{channel_layout} are specified, then they
 +must be consistent.
  
 -@item hsub, vsub
 -The horizontal and vertical chroma subsample values. For example, for the
 -pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
  @end table
  
 -To change the display aspect ratio to 16:9, specify:
 +@subsection Examples
 +
  @example
 -setdar=dar=16/9
 -# The above is equivalent to
 -setdar=dar=1.77777
 +abuffer=sample_rate=44100:sample_fmt=s16p:channel_layout=stereo
 +@end example
 +
 +will instruct the source to accept planar 16bit signed stereo at 44100Hz.
 +Since the sample format with name "s16p" corresponds to the number
 +6 and the "stereo" channel layout corresponds to the value 0x3, this is
 +equivalent to:
 +@example
 +abuffer=sample_rate=44100:sample_fmt=6:channel_layout=0x3
  @end example
  
 -Also see the the @ref{setsar} filter documentation.
 +@section aevalsrc
 +
 +Generate an audio signal specified by an expression.
 +
 +This source accepts in input one or more expressions (one for each
 +channel), which are evaluated and used to generate a corresponding
 +audio signal.
 +
 +This source accepts the following options:
 +
 +@table @option
 +@item exprs
 +Set the '|'-separated expressions list for each separate channel. In case the
 +@option{channel_layout} option is not specified, the selected channel layout
 +depends on the number of provided expressions. Otherwise the last
 +specified expression is applied to the remaining output channels.
 +
 +@item channel_layout, c
 +Set the channel layout. The number of channels in the specified layout
 +must be equal to the number of specified expressions.
 +
 +@item duration, d
 +Set the minimum duration of the sourced audio. See
 +@ref{time duration syntax,,the Time duration section in the ffmpeg-utils(1) manual,ffmpeg-utils}
 +for the accepted syntax.
 +Note that the resulting duration may be greater than the specified
 +duration, as the generated audio is always cut at the end of a
 +complete frame.
 +
 +If not specified, or the expressed duration is negative, the audio is
 +supposed to be generated forever.
 +
 +@item nb_samples, n
 +Set the number of samples per channel per each output frame,
 +default to 1024.
 +
 +@item sample_rate, s
 +Specify the sample rate, default to 44100.
 +@end table
 +
 +Each expression in @var{exprs} can contain the following constants:
 +
 +@table @option
 +@item n
 +number of the evaluated sample, starting from 0
 +
 +@item t
 +time of the evaluated sample expressed in seconds, starting from 0
 +
 +@item s
 +sample rate
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Generate silence:
 +@example
 +aevalsrc=0
 +@end example
 +
 +@item
 +Generate a sin signal with frequency of 440 Hz, set sample rate to
 +8000 Hz:
 +@example
 +aevalsrc="sin(440*2*PI*t):s=8000"
 +@end example
 +
 +@item
 +Generate a two channels signal, specify the channel layout (Front
 +Center + Back Center) explicitly:
 +@example
 +aevalsrc="sin(420*2*PI*t)|cos(430*2*PI*t):c=FC|BC"
 +@end example
 +
 +@item
 +Generate white noise:
 +@example
 +aevalsrc="-2+random(0)"
 +@end example
 +
 +@item
 +Generate an amplitude modulated signal:
 +@example
 +aevalsrc="sin(10*2*PI*t)*sin(880*2*PI*t)"
 +@end example
 +
 +@item
 +Generate 2.5 Hz binaural beats on a 360 Hz carrier:
 +@example
 +aevalsrc="0.1*sin(2*PI*(360-2.5/2)*t) | 0.1*sin(2*PI*(360+2.5/2)*t)"
 +@end example
 +
 +@end itemize
 +
 +@section anullsrc
 +
 +The null audio source, return unprocessed audio frames. It is mainly useful
 +as a template and to be employed in analysis / debugging tools, or as
 +the source for filters which ignore the input data (for example the sox
 +synth filter).
 +
 +This source accepts the following options:
 +
 +@table @option
 +
 +@item channel_layout, cl
 +
 +Specifies the channel layout, and can be either an integer or a string
 +representing a channel layout. The default value of @var{channel_layout}
 +is "stereo".
 +
 +Check the channel_layout_map definition in
 +@file{libavutil/channel_layout.c} for the mapping between strings and
 +channel layout values.
 +
 +@item sample_rate, r
 +Specifies the sample rate, and defaults to 44100.
 +
 +@item nb_samples, n
 +Set the number of samples per requested frames.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set the sample rate to 48000 Hz and the channel layout to AV_CH_LAYOUT_MONO.
 +@example
 +anullsrc=r=48000:cl=4
 +@end example
 +
 +@item
 +Do the same operation with a more obvious syntax:
 +@example
 +anullsrc=r=48000:cl=mono
 +@end example
 +@end itemize
 +
 +All the parameters need to be explicitly defined.
 +
 +@section flite
 +
 +Synthesize a voice utterance using the libflite library.
 +
 +To enable compilation of this filter you need to configure FFmpeg with
 +@code{--enable-libflite}.
 +
 +Note that the flite library is not thread-safe.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +
 +@item list_voices
 +If set to 1, list the names of the available voices and exit
 +immediately. Default value is 0.
 +
 +@item nb_samples, n
 +Set the maximum number of samples per frame. Default value is 512.
 +
 +@item textfile
 +Set the filename containing the text to speak.
 +
 +@item text
 +Set the text to speak.
 +
 +@item voice, v
 +Set the voice to use for the speech synthesis. Default value is
 +@code{kal}. See also the @var{list_voices} option.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Read from file @file{speech.txt}, and synthesize the text using the
 +standard flite voice:
 +@example
 +flite=textfile=speech.txt
 +@end example
 +
 +@item
 +Read the specified text selecting the @code{slt} voice:
 +@example
 +flite=text='So fare thee well, poor devil of a Sub-Sub, whose commentator I am':voice=slt
 +@end example
 +
 +@item
 +Input text to ffmpeg:
 +@example
 +ffmpeg -f lavfi -i flite=text='So fare thee well, poor devil of a Sub-Sub, whose commentator I am':voice=slt
 +@end example
 +
 +@item
 +Make @file{ffplay} speak the specified text, using @code{flite} and
 +the @code{lavfi} device:
 +@example
 +ffplay -f lavfi flite=text='No more be grieved for which that thou hast done.'
 +@end example
 +@end itemize
 +
 +For more information about libflite, check:
 +@url{http://www.speech.cs.cmu.edu/flite/}
 +
 +@section anoisesrc
 +
 +Generate a noise audio signal.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item sample_rate, r
 +Specify the sample rate. Default value is 48000 Hz.
 +
 +@item amplitude, a
 +Specify the amplitude (0.0 - 1.0) of the generated audio stream. Default value
 +is 1.0.
 +
 +@item duration, d
 +Specify the duration of the generated audio stream. Not specifying this option
 +results in noise with an infinite length.
 +
 +@item color, colour, c
 +Specify the color of noise. Available noise colors are white, pink, and brown.
 +Default color is white.
 +
 +@item seed, s
 +Specify a value used to seed the PRNG.
 +
 +@item nb_samples, n
 +Set the number of samples per each output frame, default is 1024.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +
 +@item
 +Generate 60 seconds of pink noise, with a 44.1 kHz sampling rate and an amplitude of 0.5:
 +@example
 +anoisesrc=d=60:c=pink:r=44100:a=0.5
 +@end example
 +@end itemize
 +
 +@section sine
 +
 +Generate an audio signal made of a sine wave with amplitude 1/8.
 +
 +The audio signal is bit-exact.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +
 +@item frequency, f
 +Set the carrier frequency. Default is 440 Hz.
 +
 +@item beep_factor, b
 +Enable a periodic beep every second with frequency @var{beep_factor} times
 +the carrier frequency. Default is 0, meaning the beep is disabled.
 +
 +@item sample_rate, r
 +Specify the sample rate, default is 44100.
 +
 +@item duration, d
 +Specify the duration of the generated audio stream.
 +
 +@item samples_per_frame
 +Set the number of samples per output frame.
 +
 +The expression can contain the following constants:
 +
 +@table @option
 +@item n
 +The (sequential) number of the output audio frame, starting from 0.
 +
 +@item pts
 +The PTS (Presentation TimeStamp) of the output audio frame,
 +expressed in @var{TB} units.
 +
 +@item t
 +The PTS of the output audio frame, expressed in seconds.
 +
 +@item TB
 +The timebase of the output audio frames.
 +@end table
 +
 +Default is @code{1024}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +
 +@item
 +Generate a simple 440 Hz sine wave:
 +@example
 +sine
 +@end example
 +
 +@item
 +Generate a 220 Hz sine wave with a 880 Hz beep each second, for 5 seconds:
 +@example
 +sine=220:4:d=5
 +sine=f=220:b=4:d=5
 +sine=frequency=220:beep_factor=4:duration=5
 +@end example
 +
 +@item
 +Generate a 1 kHz sine wave following @code{1602,1601,1602,1601,1602} NTSC
 +pattern:
 +@example
 +sine=1000:samples_per_frame='st(0,mod(n,5)); 1602-not(not(eq(ld(0),1)+eq(ld(0),3)))'
 +@end example
 +@end itemize
 +
 +@c man end AUDIO SOURCES
 +
 +@chapter Audio Sinks
 +@c man begin AUDIO SINKS
 +
 +Below is a description of the currently available audio sinks.
 +
 +@section abuffersink
 +
 +Buffer audio frames, and make them available to the end of filter chain.
 +
 +This sink is mainly intended for programmatic use, in particular
 +through the interface defined in @file{libavfilter/buffersink.h}
 +or the options system.
 +
 +It accepts a pointer to an AVABufferSinkContext structure, which
 +defines the incoming buffers' formats, to be passed as the opaque
 +parameter to @code{avfilter_init_filter} for initialization.
 +@section anullsink
 +
 +Null audio sink; do absolutely nothing with the input audio. It is
 +mainly useful as a template and for use in analysis / debugging
 +tools.
 +
 +@c man end AUDIO SINKS
 +
 +@chapter Video Filters
 +@c man begin VIDEO FILTERS
 +
 +When you configure your FFmpeg build, you can disable any of the
 +existing filters using @code{--disable-filters}.
 +The configure output will show the video filters included in your
 +build.
 +
 +Below is a description of the currently available video filters.
 +
 +@section alphaextract
 +
 +Extract the alpha component from the input as a grayscale video. This
 +is especially useful with the @var{alphamerge} filter.
 +
 +@section alphamerge
 +
 +Add or replace the alpha component of the primary input with the
 +grayscale value of a second input. This is intended for use with
 +@var{alphaextract} to allow the transmission or storage of frame
 +sequences that have alpha in a format that doesn't support an alpha
 +channel.
 +
 +For example, to reconstruct full frames from a normal YUV-encoded video
 +and a separate video created with @var{alphaextract}, you might use:
 +@example
 +movie=in_alpha.mkv [alpha]; [in][alpha] alphamerge [out]
 +@end example
 +
 +Since this filter is designed for reconstruction, it operates on frame
 +sequences without considering timestamps, and terminates when either
 +input reaches end of stream. This will cause problems if your encoding
 +pipeline drops frames. If you're trying to apply an image as an
 +overlay to a video stream, consider the @var{overlay} filter instead.
 +
 +@section ass
 +
 +Same as the @ref{subtitles} filter, except that it doesn't require libavcodec
 +and libavformat to work. On the other hand, it is limited to ASS (Advanced
 +Substation Alpha) subtitles files.
 +
 +This filter accepts the following option in addition to the common options from
 +the @ref{subtitles} filter:
 +
 +@table @option
 +@item shaping
 +Set the shaping engine
 +
 +Available values are:
 +@table @samp
 +@item auto
 +The default libass shaping engine, which is the best available.
 +@item simple
 +Fast, font-agnostic shaper that can do only substitutions
 +@item complex
 +Slower shaper using OpenType for substitutions and positioning
 +@end table
 +
 +The default is @code{auto}.
 +@end table
 +
 +@section atadenoise
 +Apply an Adaptive Temporal Averaging Denoiser to the video input.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item 0a
 +Set threshold A for 1st plane. Default is 0.02.
 +Valid range is 0 to 0.3.
 +
 +@item 0b
 +Set threshold B for 1st plane. Default is 0.04.
 +Valid range is 0 to 5.
 +
 +@item 1a
 +Set threshold A for 2nd plane. Default is 0.02.
 +Valid range is 0 to 0.3.
 +
 +@item 1b
 +Set threshold B for 2nd plane. Default is 0.04.
 +Valid range is 0 to 5.
 +
 +@item 2a
 +Set threshold A for 3rd plane. Default is 0.02.
 +Valid range is 0 to 0.3.
 +
 +@item 2b
 +Set threshold B for 3rd plane. Default is 0.04.
 +Valid range is 0 to 5.
 +
 +Threshold A is designed to react on abrupt changes in the input signal and
 +threshold B is designed to react on continuous changes in the input signal.
 +
 +@item s
 +Set number of frames filter will use for averaging. Default is 33. Must be odd
 +number in range [5, 129].
 +@end table
 +
 +@section bbox
 +
 +Compute the bounding box for the non-black pixels in the input frame
 +luminance plane.
 +
 +This filter computes the bounding box containing all the pixels with a
 +luminance value greater than the minimum allowed value.
 +The parameters describing the bounding box are printed on the filter
 +log.
 +
 +The filter accepts the following option:
 +
 +@table @option
 +@item min_val
 +Set the minimal luminance value. Default is @code{16}.
 +@end table
 +
 +@section blackdetect
 +
 +Detect video intervals that are (almost) completely black. Can be
 +useful to detect chapter transitions, commercials, or invalid
 +recordings. Output lines contains the time for the start, end and
 +duration of the detected black interval expressed in seconds.
 +
 +In order to display the output lines, you need to set the loglevel at
 +least to the AV_LOG_INFO value.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item black_min_duration, d
 +Set the minimum detected black duration expressed in seconds. It must
 +be a non-negative floating point number.
 +
 +Default value is 2.0.
 +
 +@item picture_black_ratio_th, pic_th
 +Set the threshold for considering a picture "black".
 +Express the minimum value for the ratio:
 +@example
 +@var{nb_black_pixels} / @var{nb_pixels}
 +@end example
 +
 +for which a picture is considered black.
 +Default value is 0.98.
 +
 +@item pixel_black_th, pix_th
 +Set the threshold for considering a pixel "black".
 +
 +The threshold expresses the maximum pixel luminance value for which a
 +pixel is considered "black". The provided value is scaled according to
 +the following equation:
 +@example
 +@var{absolute_threshold} = @var{luminance_minimum_value} + @var{pixel_black_th} * @var{luminance_range_size}
 +@end example
 +
 +@var{luminance_range_size} and @var{luminance_minimum_value} depend on
 +the input video format, the range is [0-255] for YUV full-range
 +formats and [16-235] for YUV non full-range formats.
 +
 +Default value is 0.10.
 +@end table
 +
 +The following example sets the maximum pixel threshold to the minimum
 +value, and detects only black intervals of 2 or more seconds:
 +@example
 +blackdetect=d=2:pix_th=0.00
 +@end example
 +
 +@section blackframe
 +
 +Detect frames that are (almost) completely black. Can be useful to
 +detect chapter transitions or commercials. Output lines consist of
 +the frame number of the detected frame, the percentage of blackness,
 +the position in the file if known or -1 and the timestamp in seconds.
 +
 +In order to display the output lines, you need to set the loglevel at
 +least to the AV_LOG_INFO value.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item amount
 +The percentage of the pixels that have to be below the threshold; it defaults to
 +@code{98}.
 +
 +@item threshold, thresh
 +The threshold below which a pixel value is considered black; it defaults to
 +@code{32}.
 +
 +@end table
 +
 +@section blend, tblend
 +
 +Blend two video frames into each other.
 +
 +The @code{blend} filter takes two input streams and outputs one
 +stream, the first input is the "top" layer and second input is
 +"bottom" layer.  Output terminates when shortest input terminates.
 +
 +The @code{tblend} (time blend) filter takes two consecutive frames
 +from one single stream, and outputs the result obtained by blending
 +the new frame on top of the old frame.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item c0_mode
 +@item c1_mode
 +@item c2_mode
 +@item c3_mode
 +@item all_mode
 +Set blend mode for specific pixel component or all pixel components in case
 +of @var{all_mode}. Default value is @code{normal}.
 +
 +Available values for component modes are:
 +@table @samp
 +@item addition
 +@item addition128
 +@item and
 +@item average
 +@item burn
 +@item darken
 +@item difference
 +@item difference128
 +@item divide
 +@item dodge
 +@item freeze
 +@item exclusion
 +@item glow
 +@item hardlight
 +@item hardmix
 +@item heat
 +@item lighten
 +@item linearlight
 +@item multiply
 +@item multiply128
 +@item negation
 +@item normal
 +@item or
 +@item overlay
 +@item phoenix
 +@item pinlight
 +@item reflect
 +@item screen
 +@item softlight
 +@item subtract
 +@item vividlight
 +@item xor
 +@end table
 +
 +@item c0_opacity
 +@item c1_opacity
 +@item c2_opacity
 +@item c3_opacity
 +@item all_opacity
 +Set blend opacity for specific pixel component or all pixel components in case
 +of @var{all_opacity}. Only used in combination with pixel component blend modes.
 +
 +@item c0_expr
 +@item c1_expr
 +@item c2_expr
 +@item c3_expr
 +@item all_expr
 +Set blend expression for specific pixel component or all pixel components in case
 +of @var{all_expr}. Note that related mode options will be ignored if those are set.
 +
 +The expressions can use the following variables:
 +
 +@table @option
 +@item N
 +The sequential number of the filtered frame, starting from @code{0}.
 +
 +@item X
 +@item Y
 +the coordinates of the current sample
 +
 +@item W
 +@item H
 +the width and height of currently filtered plane
 +
 +@item SW
 +@item SH
 +Width and height scale depending on the currently filtered plane. It is the
 +ratio between the corresponding luma plane number of pixels and the current
 +plane ones. E.g. for YUV4:2:0 the values are @code{1,1} for the luma plane, and
 +@code{0.5,0.5} for chroma planes.
 +
 +@item T
 +Time of the current frame, expressed in seconds.
 +
 +@item TOP, A
 +Value of pixel component at current location for first video frame (top layer).
 +
 +@item BOTTOM, B
 +Value of pixel component at current location for second video frame (bottom layer).
 +@end table
 +
 +@item shortest
 +Force termination when the shortest input terminates. Default is
 +@code{0}. This option is only defined for the @code{blend} filter.
 +
 +@item repeatlast
 +Continue applying the last bottom frame after the end of the stream. A value of
 +@code{0} disable the filter after the last frame of the bottom layer is reached.
 +Default is @code{1}. This option is only defined for the @code{blend} filter.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply transition from bottom layer to top layer in first 10 seconds:
 +@example
 +blend=all_expr='A*(if(gte(T,10),1,T/10))+B*(1-(if(gte(T,10),1,T/10)))'
 +@end example
 +
 +@item
 +Apply 1x1 checkerboard effect:
 +@example
 +blend=all_expr='if(eq(mod(X,2),mod(Y,2)),A,B)'
 +@end example
 +
 +@item
 +Apply uncover left effect:
 +@example
 +blend=all_expr='if(gte(N*SW+X,W),A,B)'
 +@end example
 +
 +@item
 +Apply uncover down effect:
 +@example
 +blend=all_expr='if(gte(Y-N*SH,0),A,B)'
 +@end example
 +
 +@item
 +Apply uncover up-left effect:
 +@example
 +blend=all_expr='if(gte(T*SH*40+Y,H)*gte((T*40*SW+X)*W/H,W),A,B)'
 +@end example
 +
 +@item
 +Split diagonally video and shows top and bottom layer on each side:
 +@example
 +blend=all_expr=if(gt(X,Y*(W/H)),A,B)
 +@end example
 +
 +@item
 +Display differences between the current and the previous frame:
 +@example
 +tblend=all_mode=difference128
 +@end example
 +@end itemize
 +
 +@section boxblur
 +
 +Apply a boxblur algorithm to the input video.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item luma_radius, lr
 +@item luma_power, lp
 +@item chroma_radius, cr
 +@item chroma_power, cp
 +@item alpha_radius, ar
 +@item alpha_power, ap
 +
 +@end table
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item luma_radius, lr
 +@item chroma_radius, cr
 +@item alpha_radius, ar
 +Set an expression for the box radius in pixels used for blurring the
 +corresponding input plane.
 +
 +The radius value must be a non-negative number, and must not be
 +greater than the value of the expression @code{min(w,h)/2} for the
 +luma and alpha planes, and of @code{min(cw,ch)/2} for the chroma
 +planes.
 +
 +Default value for @option{luma_radius} is "2". If not specified,
 +@option{chroma_radius} and @option{alpha_radius} default to the
 +corresponding value set for @option{luma_radius}.
 +
 +The expressions can contain the following constants:
 +@table @option
 +@item w
 +@item h
 +The input width and height in pixels.
 +
 +@item cw
 +@item ch
 +The input chroma image width and height in pixels.
 +
 +@item hsub
 +@item vsub
 +The horizontal and vertical chroma subsample values. For example, for the
 +pixel format "yuv422p", @var{hsub} is 2 and @var{vsub} is 1.
 +@end table
 +
 +@item luma_power, lp
 +@item chroma_power, cp
 +@item alpha_power, ap
 +Specify how many times the boxblur filter is applied to the
 +corresponding plane.
 +
 +Default value for @option{luma_power} is 2. If not specified,
 +@option{chroma_power} and @option{alpha_power} default to the
 +corresponding value set for @option{luma_power}.
 +
 +A value of 0 will disable the effect.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply a boxblur filter with the luma, chroma, and alpha radii
 +set to 2:
 +@example
 +boxblur=luma_radius=2:luma_power=1
 +boxblur=2:1
 +@end example
 +
 +@item
 +Set the luma radius to 2, and alpha and chroma radius to 0:
 +@example
 +boxblur=2:1:cr=0:ar=0
 +@end example
 +
 +@item
 +Set the luma and chroma radii to a fraction of the video dimension:
 +@example
 +boxblur=luma_radius=min(h\,w)/10:luma_power=1:chroma_radius=min(cw\,ch)/10:chroma_power=1
 +@end example
 +@end itemize
 +
 +@section bwdif
 +
 +Deinterlace the input video ("bwdif" stands for "Bob Weaver
 +Deinterlacing Filter").
 +
 +Motion adaptive deinterlacing based on yadif with the use of w3fdif and cubic
 +interpolation algorithms.
 +It accepts the following parameters:
 +
 +@table @option
 +@item mode
 +The interlacing mode to adopt. It accepts one of the following values:
 +
 +@table @option
 +@item 0, send_frame
 +Output one frame for each frame.
 +@item 1, send_field
 +Output one frame for each field.
 +@end table
 +
 +The default value is @code{send_field}.
 +
 +@item parity
 +The picture field parity assumed for the input interlaced video. It accepts one
 +of the following values:
 +
 +@table @option
 +@item 0, tff
 +Assume the top field is first.
 +@item 1, bff
 +Assume the bottom field is first.
 +@item -1, auto
 +Enable automatic detection of field parity.
 +@end table
 +
 +The default value is @code{auto}.
 +If the interlacing is unknown or the decoder does not export this information,
 +top field first will be assumed.
 +
 +@item deint
 +Specify which frames to deinterlace. Accept one of the following
 +values:
 +
 +@table @option
 +@item 0, all
 +Deinterlace all frames.
 +@item 1, interlaced
 +Only deinterlace frames marked as interlaced.
 +@end table
 +
 +The default value is @code{all}.
 +@end table
 +
 +@section chromakey
 +YUV colorspace color/chroma keying.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item color
 +The color which will be replaced with transparency.
 +
 +@item similarity
 +Similarity percentage with the key color.
 +
 +0.01 matches only the exact key color, while 1.0 matches everything.
 +
 +@item blend
 +Blend percentage.
 +
 +0.0 makes pixels either fully transparent, or not transparent at all.
 +
 +Higher values result in semi-transparent pixels, with a higher transparency
 +the more similar the pixels color is to the key color.
 +
 +@item yuv
 +Signals that the color passed is already in YUV instead of RGB.
 +
 +Litteral colors like "green" or "red" don't make sense with this enabled anymore.
 +This can be used to pass exact YUV values as hexadecimal numbers.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Make every green pixel in the input image transparent:
 +@example
 +ffmpeg -i input.png -vf chromakey=green out.png
 +@end example
 +
 +@item
 +Overlay a greenscreen-video on top of a static black background.
 +@example
 +ffmpeg -f lavfi -i color=c=black:s=1280x720 -i video.mp4 -shortest -filter_complex "[1:v]chromakey=0x70de77:0.1:0.2[ckout];[0:v][ckout]overlay[out]" -map "[out]" output.mkv
 +@end example
 +@end itemize
 +
 +@section ciescope
 +
 +Display CIE color diagram with pixels overlaid onto it.
 +
 +The filter acccepts the following options:
 +
 +@table @option
 +@item system
 +Set color system.
 +
 +@table @samp
 +@item ntsc, 470m
 +@item ebu, 470bg
 +@item smpte
 +@item 240m
 +@item apple
 +@item widergb
 +@item cie1931
 +@item rec709, hdtv
 +@item uhdtv, rec2020
 +@end table
 +
 +@item cie
 +Set CIE system.
 +
 +@table @samp
 +@item xyy
 +@item ucs
 +@item luv
 +@end table
 +
 +@item gamuts
 +Set what gamuts to draw.
 +
 +See @code{system} option for avaiable values.
 +
 +@item size, s
 +Set ciescope size, by default set to 512.
 +
 +@item intensity, i
 +Set intensity used to map input pixel values to CIE diagram.
 +
 +@item contrast
 +Set contrast used to draw tongue colors that are out of active color system gamut.
 +
 +@item corrgamma
 +Correct gamma displayed on scope, by default enabled.
 +
 +@item showwhite
 +Show white point on CIE diagram, by default disabled.
 +
 +@item gamma
 +Set input gamma. Used only with XYZ input color space.
 +@end table
 +
 +@section codecview
 +
 +Visualize information exported by some codecs.
 +
 +Some codecs can export information through frames using side-data or other
 +means. For example, some MPEG based codecs export motion vectors through the
 +@var{export_mvs} flag in the codec @option{flags2} option.
 +
 +The filter accepts the following option:
 +
 +@table @option
 +@item mv
 +Set motion vectors to visualize.
 +
 +Available flags for @var{mv} are:
 +
 +@table @samp
 +@item pf
 +forward predicted MVs of P-frames
 +@item bf
 +forward predicted MVs of B-frames
 +@item bb
 +backward predicted MVs of B-frames
 +@end table
 +
 +@item qp
 +Display quantization parameters using the chroma planes.
 +
 +@item mv_type, mvt
 +Set motion vectors type to visualize. Includes MVs from all frames unless specified by @var{frame_type} option.
 +
 +Available flags for @var{mv_type} are:
 +
 +@table @samp
 +@item fp
 +forward predicted MVs
 +@item bp
 +backward predicted MVs
 +@end table
 +
 +@item frame_type, ft
 +Set frame type to visualize motion vectors of.
 +
 +Available flags for @var{frame_type} are:
 +
 +@table @samp
 +@item if
 +intra-coded frames (I-frames)
 +@item pf
 +predicted frames (P-frames)
 +@item bf
 +bi-directionally predicted frames (B-frames)
 +@end table
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Visualize forward predicted MVs of all frames using @command{ffplay}:
 +@example
 +ffplay -flags2 +export_mvs input.mp4 -vf codecview=mv_type=fp
 +@end example
 +
 +@item
 +Visualize multi-directionals MVs of P and B-Frames using @command{ffplay}:
 +@example
 +ffplay -flags2 +export_mvs input.mp4 -vf codecview=mv=pf+bf+bb
 +@end example
 +@end itemize
 +
 +@section colorbalance
 +Modify intensity of primary colors (red, green and blue) of input frames.
 +
 +The filter allows an input frame to be adjusted in the shadows, midtones or highlights
 +regions for the red-cyan, green-magenta or blue-yellow balance.
 +
 +A positive adjustment value shifts the balance towards the primary color, a negative
 +value towards the complementary color.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item rs
 +@item gs
 +@item bs
 +Adjust red, green and blue shadows (darkest pixels).
 +
 +@item rm
 +@item gm
 +@item bm
 +Adjust red, green and blue midtones (medium pixels).
 +
 +@item rh
 +@item gh
 +@item bh
 +Adjust red, green and blue highlights (brightest pixels).
 +
 +Allowed ranges for options are @code{[-1.0, 1.0]}. Defaults are @code{0}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Add red color cast to shadows:
 +@example
 +colorbalance=rs=.3
 +@end example
 +@end itemize
 +
 +@section colorkey
 +RGB colorspace color keying.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item color
 +The color which will be replaced with transparency.
 +
 +@item similarity
 +Similarity percentage with the key color.
 +
 +0.01 matches only the exact key color, while 1.0 matches everything.
 +
 +@item blend
 +Blend percentage.
 +
 +0.0 makes pixels either fully transparent, or not transparent at all.
 +
 +Higher values result in semi-transparent pixels, with a higher transparency
 +the more similar the pixels color is to the key color.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Make every green pixel in the input image transparent:
 +@example
 +ffmpeg -i input.png -vf colorkey=green out.png
 +@end example
 +
 +@item
 +Overlay a greenscreen-video on top of a static background image.
 +@example
 +ffmpeg -i background.png -i video.mp4 -filter_complex "[1:v]colorkey=0x3BBD1E:0.3:0.2[ckout];[0:v][ckout]overlay[out]" -map "[out]" output.flv
 +@end example
 +@end itemize
 +
 +@section colorlevels
 +
 +Adjust video input frames using levels.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item rimin
 +@item gimin
 +@item bimin
 +@item aimin
 +Adjust red, green, blue and alpha input black point.
 +Allowed ranges for options are @code{[-1.0, 1.0]}. Defaults are @code{0}.
 +
 +@item rimax
 +@item gimax
 +@item bimax
 +@item aimax
 +Adjust red, green, blue and alpha input white point.
 +Allowed ranges for options are @code{[-1.0, 1.0]}. Defaults are @code{1}.
 +
 +Input levels are used to lighten highlights (bright tones), darken shadows
 +(dark tones), change the balance of bright and dark tones.
 +
 +@item romin
 +@item gomin
 +@item bomin
 +@item aomin
 +Adjust red, green, blue and alpha output black point.
 +Allowed ranges for options are @code{[0, 1.0]}. Defaults are @code{0}.
 +
 +@item romax
 +@item gomax
 +@item bomax
 +@item aomax
 +Adjust red, green, blue and alpha output white point.
 +Allowed ranges for options are @code{[0, 1.0]}. Defaults are @code{1}.
 +
 +Output levels allows manual selection of a constrained output level range.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Make video output darker:
 +@example
 +colorlevels=rimin=0.058:gimin=0.058:bimin=0.058
 +@end example
 +
 +@item
 +Increase contrast:
 +@example
 +colorlevels=rimin=0.039:gimin=0.039:bimin=0.039:rimax=0.96:gimax=0.96:bimax=0.96
 +@end example
 +
 +@item
 +Make video output lighter:
 +@example
 +colorlevels=rimax=0.902:gimax=0.902:bimax=0.902
 +@end example
 +
 +@item
 +Increase brightness:
 +@example
 +colorlevels=romin=0.5:gomin=0.5:bomin=0.5
 +@end example
 +@end itemize
 +
 +@section colorchannelmixer
 +
 +Adjust video input frames by re-mixing color channels.
 +
 +This filter modifies a color channel by adding the values associated to
 +the other channels of the same pixels. For example if the value to
 +modify is red, the output value will be:
 +@example
 +@var{red}=@var{red}*@var{rr} + @var{blue}*@var{rb} + @var{green}*@var{rg} + @var{alpha}*@var{ra}
 +@end example
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item rr
 +@item rg
 +@item rb
 +@item ra
 +Adjust contribution of input red, green, blue and alpha channels for output red channel.
 +Default is @code{1} for @var{rr}, and @code{0} for @var{rg}, @var{rb} and @var{ra}.
 +
 +@item gr
 +@item gg
 +@item gb
 +@item ga
 +Adjust contribution of input red, green, blue and alpha channels for output green channel.
 +Default is @code{1} for @var{gg}, and @code{0} for @var{gr}, @var{gb} and @var{ga}.
 +
 +@item br
 +@item bg
 +@item bb
 +@item ba
 +Adjust contribution of input red, green, blue and alpha channels for output blue channel.
 +Default is @code{1} for @var{bb}, and @code{0} for @var{br}, @var{bg} and @var{ba}.
 +
 +@item ar
 +@item ag
 +@item ab
 +@item aa
 +Adjust contribution of input red, green, blue and alpha channels for output alpha channel.
 +Default is @code{1} for @var{aa}, and @code{0} for @var{ar}, @var{ag} and @var{ab}.
 +
 +Allowed ranges for options are @code{[-2.0, 2.0]}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Convert source to grayscale:
 +@example
 +colorchannelmixer=.3:.4:.3:0:.3:.4:.3:0:.3:.4:.3
 +@end example
 +@item
 +Simulate sepia tones:
 +@example
 +colorchannelmixer=.393:.769:.189:0:.349:.686:.168:0:.272:.534:.131
 +@end example
 +@end itemize
 +
 +@section colormatrix
 +
 +Convert color matrix.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item src
 +@item dst
 +Specify the source and destination color matrix. Both values must be
 +specified.
 +
 +The accepted values are:
 +@table @samp
 +@item bt709
 +BT.709
 +
 +@item bt601
 +BT.601
 +
 +@item smpte240m
 +SMPTE-240M
 +
 +@item fcc
 +FCC
 +
 +@item bt2020
 +BT.2020
 +@end table
 +@end table
 +
 +For example to convert from BT.601 to SMPTE-240M, use the command:
 +@example
 +colormatrix=bt601:smpte240m
 +@end example
 +
 +@section colorspace
 +
 +Convert colorspace, transfer characteristics or color primaries.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item all
 +Specify all color properties at once.
 +
 +The accepted values are:
 +@table @samp
 +@item bt470m
 +BT.470M
 +
 +@item bt470bg
 +BT.470BG
 +
 +@item bt601-6-525
 +BT.601-6 525
 +
 +@item bt601-6-625
 +BT.601-6 625
 +
 +@item bt709
 +BT.709
 +
 +@item smpte170m
 +SMPTE-170M
 +
 +@item smpte240m
 +SMPTE-240M
 +
 +@item bt2020
 +BT.2020
 +
 +@end table
 +
 +@item space
 +Specify output colorspace.
 +
 +The accepted values are:
 +@table @samp
 +@item bt709
 +BT.709
 +
 +@item fcc
 +FCC
 +
 +@item bt470bg
 +BT.470BG or BT.601-6 625
 +
 +@item smpte170m
 +SMPTE-170M or BT.601-6 525
 +
 +@item smpte240m
 +SMPTE-240M
 +
 +@item bt2020ncl
 +BT.2020 with non-constant luminance
 +
 +@end table
 +
 +@item trc
 +Specify output transfer characteristics.
 +
 +The accepted values are:
 +@table @samp
 +@item bt709
 +BT.709
 +
 +@item gamma22
 +Constant gamma of 2.2
 +
 +@item gamma28
 +Constant gamma of 2.8
 +
 +@item smpte170m
 +SMPTE-170M, BT.601-6 625 or BT.601-6 525
 +
 +@item smpte240m
 +SMPTE-240M
 +
 +@item bt2020-10
 +BT.2020 for 10-bits content
 +
 +@item bt2020-12
 +BT.2020 for 12-bits content
 +
 +@end table
 +
 +@item prm
 +Specify output color primaries.
 +
 +The accepted values are:
 +@table @samp
 +@item bt709
 +BT.709
 +
 +@item bt470m
 +BT.470M
 +
 +@item bt470bg
 +BT.470BG or BT.601-6 625
 +
 +@item smpte170m
 +SMPTE-170M or BT.601-6 525
 +
 +@item smpte240m
 +SMPTE-240M
 +
 +@item bt2020
 +BT.2020
 +
 +@end table
 +
 +@item rng
 +Specify output color range.
 +
 +The accepted values are:
 +@table @samp
 +@item mpeg
 +MPEG (restricted) range
 +
 +@item jpeg
 +JPEG (full) range
 +
 +@end table
 +
 +@item format
 +Specify output color format.
 +
 +The accepted values are:
 +@table @samp
 +@item yuv420p
 +YUV 4:2:0 planar 8-bits
 +
 +@item yuv420p10
 +YUV 4:2:0 planar 10-bits
 +
 +@item yuv420p12
 +YUV 4:2:0 planar 12-bits
 +
 +@item yuv422p
 +YUV 4:2:2 planar 8-bits
 +
 +@item yuv422p10
 +YUV 4:2:2 planar 10-bits
 +
 +@item yuv422p12
 +YUV 4:2:2 planar 12-bits
 +
 +@item yuv444p
 +YUV 4:4:4 planar 8-bits
 +
 +@item yuv444p10
 +YUV 4:4:4 planar 10-bits
 +
 +@item yuv444p12
 +YUV 4:4:4 planar 12-bits
 +
 +@end table
 +
 +@item fast
 +Do a fast conversion, which skips gamma/primary correction. This will take
 +significantly less CPU, but will be mathematically incorrect. To get output
 +compatible with that produced by the colormatrix filter, use fast=1.
 +
 +@item dither
 +Specify dithering mode.
 +
 +The accepted values are:
 +@table @samp
 +@item none
 +No dithering
 +
 +@item fsb
 +Floyd-Steinberg dithering
 +@end table
 +
 +@item wpadapt
 +Whitepoint adaptation mode.
 +
 +The accepted values are:
 +@table @samp
 +@item bradford
 +Bradford whitepoint adaptation
 +
 +@item vonkries
 +von Kries whitepoint adaptation
 +
 +@item identity
 +identity whitepoint adaptation (i.e. no whitepoint adaptation)
 +@end table
 +
 +@end table
 +
 +The filter converts the transfer characteristics, color space and color
 +primaries to the specified user values. The output value, if not specified,
 +is set to a default value based on the "all" property. If that property is
 +also not specified, the filter will log an error. The output color range and
 +format default to the same value as the input color range and format. The
 +input transfer characteristics, color space, color primaries and color range
 +should be set on the input data. If any of these are missing, the filter will
 +log an error and no conversion will take place.
 +
 +For example to convert the input to SMPTE-240M, use the command:
 +@example
 +colorspace=smpte240m
 +@end example
 +
 +@section convolution
 +
 +Apply convolution 3x3 or 5x5 filter.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item 0m
 +@item 1m
 +@item 2m
 +@item 3m
 +Set matrix for each plane.
 +Matrix is sequence of 9 or 25 signed integers.
 +
 +@item 0rdiv
 +@item 1rdiv
 +@item 2rdiv
 +@item 3rdiv
 +Set multiplier for calculated value for each plane.
 +
 +@item 0bias
 +@item 1bias
 +@item 2bias
 +@item 3bias
 +Set bias for each plane. This value is added to the result of the multiplication.
 +Useful for making the overall image brighter or darker. Default is 0.0.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply sharpen:
 +@example
 +convolution="0 -1 0 -1 5 -1 0 -1 0:0 -1 0 -1 5 -1 0 -1 0:0 -1 0 -1 5 -1 0 -1 0:0 -1 0 -1 5 -1 0 -1 0"
 +@end example
 +
 +@item
 +Apply blur:
 +@example
 +convolution="1 1 1 1 1 1 1 1 1:1 1 1 1 1 1 1 1 1:1 1 1 1 1 1 1 1 1:1 1 1 1 1 1 1 1 1:1/9:1/9:1/9:1/9"
 +@end example
 +
 +@item
 +Apply edge enhance:
 +@example
 +convolution="0 0 0 -1 1 0 0 0 0:0 0 0 -1 1 0 0 0 0:0 0 0 -1 1 0 0 0 0:0 0 0 -1 1 0 0 0 0:5:1:1:1:0:128:128:128"
 +@end example
 +
 +@item
 +Apply edge detect:
 +@example
 +convolution="0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:0 1 0 1 -4 1 0 1 0:5:5:5:1:0:128:128:128"
 +@end example
 +
 +@item
 +Apply emboss:
 +@example
 +convolution="-2 -1 0 -1 1 1 0 1 2:-2 -1 0 -1 1 1 0 1 2:-2 -1 0 -1 1 1 0 1 2:-2 -1 0 -1 1 1 0 1 2"
 +@end example
 +@end itemize
 +
 +@section copy
 +
 +Copy the input source unchanged to the output. This is mainly useful for
 +testing purposes.
 +
 +@anchor{coreimage}
 +@section coreimage
 +Video filtering on GPU using Apple's CoreImage API on OSX.
 +
 +Hardware acceleration is based on an OpenGL context. Usually, this means it is
 +processed by video hardware. However, software-based OpenGL implementations
 +exist which means there is no guarantee for hardware processing. It depends on
 +the respective OSX.
 +
 +There are many filters and image generators provided by Apple that come with a
 +large variety of options. The filter has to be referenced by its name along
 +with its options.
 +
 +The coreimage filter accepts the following options:
 +@table @option
 +@item list_filters
 +List all available filters and generators along with all their respective
 +options as well as possible minimum and maximum values along with the default
 +values.
 +@example
 +list_filters=true
 +@end example
 +
 +@item filter
 +Specify all filters by their respective name and options.
 +Use @var{list_filters} to determine all valid filter names and options.
 +Numerical options are specified by a float value and are automatically clamped
 +to their respective value range.  Vector and color options have to be specified
 +by a list of space separated float values. Character escaping has to be done.
 +A special option name @code{default} is available to use default options for a
 +filter.
 +
 +It is required to specify either @code{default} or at least one of the filter options.
 +All omitted options are used with their default values.
 +The syntax of the filter string is as follows:
 +@example
 +filter=<NAME>@@<OPTION>=<VALUE>[@@<OPTION>=<VALUE>][@@...][#<NAME>@@<OPTION>=<VALUE>[@@<OPTION>=<VALUE>][@@...]][#...]
 +@end example
 +
 +@item output_rect
 +Specify a rectangle where the output of the filter chain is copied into the
 +input image. It is given by a list of space separated float values:
 +@example
 +output_rect=x\ y\ width\ height
 +@end example
 +If not given, the output rectangle equals the dimensions of the input image.
 +The output rectangle is automatically cropped at the borders of the input
 +image. Negative values are valid for each component.
 +@example
 +output_rect=25\ 25\ 100\ 100
 +@end example
 +@end table
 +
 +Several filters can be chained for successive processing without GPU-HOST
 +transfers allowing for fast processing of complex filter chains.
 +Currently, only filters with zero (generators) or exactly one (filters) input
 +image and one output image are supported. Also, transition filters are not yet
 +usable as intended.
 +
 +Some filters generate output images with additional padding depending on the
 +respective filter kernel. The padding is automatically removed to ensure the
 +filter output has the same size as the input image.
 +
 +For image generators, the size of the output image is determined by the
 +previous output image of the filter chain or the input image of the whole
 +filterchain, respectively. The generators do not use the pixel information of
 +this image to generate their output. However, the generated output is
 +blended onto this image, resulting in partial or complete coverage of the
 +output image.
 +
 +The @ref{coreimagesrc} video source can be used for generating input images
 +which are directly fed into the filter chain. By using it, providing input
 +images by another video source or an input video is not required.
 +
 +@subsection Examples
 +
 +@itemize
 +
 +@item
 +List all filters available:
 +@example
 +coreimage=list_filters=true
 +@end example
 +
 +@item
 +Use the CIBoxBlur filter with default options to blur an image:
 +@example
 +coreimage=filter=CIBoxBlur@@default
 +@end example
 +
 +@item
 +Use a filter chain with CISepiaTone at default values and CIVignetteEffect with
 +its center at 100x100 and a radius of 50 pixels:
 +@example
 +coreimage=filter=CIBoxBlur@@default#CIVignetteEffect@@inputCenter=100\ 100@@inputRadius=50
 +@end example
 +
 +@item
 +Use nullsrc and CIQRCodeGenerator to create a QR code for the FFmpeg homepage,
 +given as complete and escaped command-line for Apple's standard bash shell:
 +@example
 +ffmpeg -f lavfi -i nullsrc=s=100x100,coreimage=filter=CIQRCodeGenerator@@inputMessage=https\\\\\://FFmpeg.org/@@inputCorrectionLevel=H -frames:v 1 QRCode.png
 +@end example
 +@end itemize
 +
 +@section crop
 +
 +Crop the input video to given dimensions.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item w, out_w
 +The width of the output video. It defaults to @code{iw}.
 +This expression is evaluated only once during the filter
 +configuration, or when the @samp{w} or @samp{out_w} command is sent.
 +
 +@item h, out_h
 +The height of the output video. It defaults to @code{ih}.
 +This expression is evaluated only once during the filter
 +configuration, or when the @samp{h} or @samp{out_h} command is sent.
 +
 +@item x
 +The horizontal position, in the input video, of the left edge of the output
 +video. It defaults to @code{(in_w-out_w)/2}.
 +This expression is evaluated per-frame.
 +
 +@item y
 +The vertical position, in the input video, of the top edge of the output video.
 +It defaults to @code{(in_h-out_h)/2}.
 +This expression is evaluated per-frame.
 +
 +@item keep_aspect
 +If set to 1 will force the output display aspect ratio
 +to be the same of the input, by changing the output sample aspect
 +ratio. It defaults to 0.
 +@end table
 +
 +The @var{out_w}, @var{out_h}, @var{x}, @var{y} parameters are
 +expressions containing the following constants:
 +
 +@table @option
 +@item x
 +@item y
 +The computed values for @var{x} and @var{y}. They are evaluated for
 +each new frame.
 +
 +@item in_w
 +@item in_h
 +The input width and height.
 +
 +@item iw
 +@item ih
 +These are the same as @var{in_w} and @var{in_h}.
 +
 +@item out_w
 +@item out_h
 +The output (cropped) width and height.
 +
 +@item ow
 +@item oh
 +These are the same as @var{out_w} and @var{out_h}.
 +
 +@item a
 +same as @var{iw} / @var{ih}
 +
 +@item sar
 +input sample aspect ratio
 +
 +@item dar
 +input display aspect ratio, it is the same as (@var{iw} / @var{ih}) * @var{sar}
 +
 +@item hsub
 +@item vsub
 +horizontal and vertical chroma subsample values. For example for the
 +pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +
 +@item n
 +The number of the input frame, starting from 0.
 +
 +@item pos
 +the position in the file of the input frame, NAN if unknown
 +
 +@item t
 +The timestamp expressed in seconds. It's NAN if the input timestamp is unknown.
 +
 +@end table
 +
 +The expression for @var{out_w} may depend on the value of @var{out_h},
 +and the expression for @var{out_h} may depend on @var{out_w}, but they
 +cannot depend on @var{x} and @var{y}, as @var{x} and @var{y} are
 +evaluated after @var{out_w} and @var{out_h}.
 +
 +The @var{x} and @var{y} parameters specify the expressions for the
 +position of the top-left corner of the output (non-cropped) area. They
 +are evaluated for each frame. If the evaluated value is not valid, it
 +is approximated to the nearest valid value.
 +
 +The expression for @var{x} may depend on @var{y}, and the expression
 +for @var{y} may depend on @var{x}.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Crop area with size 100x100 at position (12,34).
 +@example
 +crop=100:100:12:34
 +@end example
 +
 +Using named options, the example above becomes:
 +@example
 +crop=w=100:h=100:x=12:y=34
 +@end example
 +
 +@item
 +Crop the central input area with size 100x100:
 +@example
 +crop=100:100
 +@end example
 +
 +@item
 +Crop the central input area with size 2/3 of the input video:
 +@example
 +crop=2/3*in_w:2/3*in_h
 +@end example
 +
 +@item
 +Crop the input video central square:
 +@example
 +crop=out_w=in_h
 +crop=in_h
 +@end example
 +
 +@item
 +Delimit the rectangle with the top-left corner placed at position
 +100:100 and the right-bottom corner corresponding to the right-bottom
 +corner of the input image.
 +@example
 +crop=in_w-100:in_h-100:100:100
 +@end example
 +
 +@item
 +Crop 10 pixels from the left and right borders, and 20 pixels from
 +the top and bottom borders
 +@example
 +crop=in_w-2*10:in_h-2*20
 +@end example
 +
 +@item
 +Keep only the bottom right quarter of the input image:
 +@example
 +crop=in_w/2:in_h/2:in_w/2:in_h/2
 +@end example
 +
 +@item
 +Crop height for getting Greek harmony:
 +@example
 +crop=in_w:1/PHI*in_w
 +@end example
 +
 +@item
 +Apply trembling effect:
 +@example
 +crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(n/10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(n/7)
 +@end example
 +
 +@item
 +Apply erratic camera effect depending on timestamp:
 +@example
 +crop=in_w/2:in_h/2:(in_w-out_w)/2+((in_w-out_w)/2)*sin(t*10):(in_h-out_h)/2 +((in_h-out_h)/2)*sin(t*13)"
 +@end example
 +
 +@item
 +Set x depending on the value of y:
 +@example
 +crop=in_w/2:in_h/2:y:10+10*sin(n/10)
 +@end example
 +@end itemize
 +
 +@subsection Commands
 +
 +This filter supports the following commands:
 +@table @option
 +@item w, out_w
 +@item h, out_h
 +@item x
 +@item y
 +Set width/height of the output video and the horizontal/vertical position
 +in the input video.
 +The command accepts the same syntax of the corresponding option.
 +
 +If the specified expression is not valid, it is kept at its current
 +value.
 +@end table
 +
 +@section cropdetect
 +
 +Auto-detect the crop size.
 +
 +It calculates the necessary cropping parameters and prints the
 +recommended parameters via the logging system. The detected dimensions
 +correspond to the non-black area of the input video.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item limit
 +Set higher black value threshold, which can be optionally specified
- from nothing (0) to everything (255 for 8bit based formats). An intensity
++from nothing (0) to everything (255 for 8-bit based formats). An intensity
 +value greater to the set value is considered non-black. It defaults to 24.
 +You can also specify a value between 0.0 and 1.0 which will be scaled depending
 +on the bitdepth of the pixel format.
 +
 +@item round
 +The value which the width/height should be divisible by. It defaults to
 +16. The offset is automatically adjusted to center the video. Use 2 to
 +get only even dimensions (needed for 4:2:2 video). 16 is best when
 +encoding to most video codecs.
 +
 +@item reset_count, reset
 +Set the counter that determines after how many frames cropdetect will
 +reset the previously detected largest video area and start over to
 +detect the current optimal crop area. Default value is 0.
 +
 +This can be useful when channel logos distort the video area. 0
 +indicates 'never reset', and returns the largest area encountered during
 +playback.
 +@end table
 +
 +@anchor{curves}
 +@section curves
 +
 +Apply color adjustments using curves.
 +
 +This filter is similar to the Adobe Photoshop and GIMP curves tools. Each
 +component (red, green and blue) has its values defined by @var{N} key points
 +tied from each other using a smooth curve. The x-axis represents the pixel
 +values from the input frame, and the y-axis the new pixel values to be set for
 +the output frame.
 +
 +By default, a component curve is defined by the two points @var{(0;0)} and
 +@var{(1;1)}. This creates a straight line where each original pixel value is
 +"adjusted" to its own value, which means no change to the image.
 +
 +The filter allows you to redefine these two points and add some more. A new
 +curve (using a natural cubic spline interpolation) will be define to pass
 +smoothly through all these new coordinates. The new defined points needs to be
 +strictly increasing over the x-axis, and their @var{x} and @var{y} values must
 +be in the @var{[0;1]} interval.  If the computed curves happened to go outside
 +the vector spaces, the values will be clipped accordingly.
 +
 +If there is no key point defined in @code{x=0}, the filter will automatically
 +insert a @var{(0;0)} point. In the same way, if there is no key point defined
 +in @code{x=1}, the filter will automatically insert a @var{(1;1)} point.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item preset
 +Select one of the available color presets. This option can be used in addition
 +to the @option{r}, @option{g}, @option{b} parameters; in this case, the later
 +options takes priority on the preset values.
 +Available presets are:
 +@table @samp
 +@item none
 +@item color_negative
 +@item cross_process
 +@item darker
 +@item increase_contrast
 +@item lighter
 +@item linear_contrast
 +@item medium_contrast
 +@item negative
 +@item strong_contrast
 +@item vintage
 +@end table
 +Default is @code{none}.
 +@item master, m
 +Set the master key points. These points will define a second pass mapping. It
 +is sometimes called a "luminance" or "value" mapping. It can be used with
 +@option{r}, @option{g}, @option{b} or @option{all} since it acts like a
 +post-processing LUT.
 +@item red, r
 +Set the key points for the red component.
 +@item green, g
 +Set the key points for the green component.
 +@item blue, b
 +Set the key points for the blue component.
 +@item all
 +Set the key points for all components (not including master).
 +Can be used in addition to the other key points component
 +options. In this case, the unset component(s) will fallback on this
 +@option{all} setting.
 +@item psfile
 +Specify a Photoshop curves file (@code{.acv}) to import the settings from.
 +@end table
 +
 +To avoid some filtergraph syntax conflicts, each key points list need to be
 +defined using the following syntax: @code{x0/y0 x1/y1 x2/y2 ...}.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Increase slightly the middle level of blue:
 +@example
 +curves=blue='0.5/0.58'
 +@end example
 +
 +@item
 +Vintage effect:
 +@example
 +curves=r='0/0.11 .42/.51 1/0.95':g='0.50/0.48':b='0/0.22 .49/.44 1/0.8'
 +@end example
 +Here we obtain the following coordinates for each components:
 +@table @var
 +@item red
 +@code{(0;0.11) (0.42;0.51) (1;0.95)}
 +@item green
 +@code{(0;0) (0.50;0.48) (1;1)}
 +@item blue
 +@code{(0;0.22) (0.49;0.44) (1;0.80)}
 +@end table
 +
 +@item
 +The previous example can also be achieved with the associated built-in preset:
 +@example
 +curves=preset=vintage
 +@end example
 +
 +@item
 +Or simply:
 +@example
 +curves=vintage
 +@end example
 +
 +@item
 +Use a Photoshop preset and redefine the points of the green component:
 +@example
 +curves=psfile='MyCurvesPresets/purple.acv':green='0.45/0.53'
 +@end example
 +@end itemize
 +
 +@section datascope
 +
 +Video data analysis filter.
 +
 +This filter shows hexadecimal pixel values of part of video.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item size, s
 +Set output video size.
 +
 +@item x
 +Set x offset from where to pick pixels.
 +
 +@item y
 +Set y offset from where to pick pixels.
 +
 +@item mode
 +Set scope mode, can be one of the following:
 +@table @samp
 +@item mono
 +Draw hexadecimal pixel values with white color on black background.
 +
 +@item color
 +Draw hexadecimal pixel values with input video pixel color on black
 +background.
 +
 +@item color2
 +Draw hexadecimal pixel values on color background picked from input video,
 +the text color is picked in such way so its always visible.
 +@end table
 +
 +@item axis
 +Draw rows and columns numbers on left and top of video.
 +@end table
 +
 +@section dctdnoiz
 +
 +Denoise frames using 2D DCT (frequency domain filtering).
 +
 +This filter is not designed for real time.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item sigma, s
 +Set the noise sigma constant.
 +
 +This @var{sigma} defines a hard threshold of @code{3 * sigma}; every DCT
 +coefficient (absolute value) below this threshold with be dropped.
 +
 +If you need a more advanced filtering, see @option{expr}.
 +
 +Default is @code{0}.
 +
 +@item overlap
 +Set number overlapping pixels for each block. Since the filter can be slow, you
 +may want to reduce this value, at the cost of a less effective filter and the
 +risk of various artefacts.
 +
 +If the overlapping value doesn't permit processing the whole input width or
 +height, a warning will be displayed and according borders won't be denoised.
 +
 +Default value is @var{blocksize}-1, which is the best possible setting.
 +
 +@item expr, e
 +Set the coefficient factor expression.
 +
 +For each coefficient of a DCT block, this expression will be evaluated as a
 +multiplier value for the coefficient.
 +
 +If this is option is set, the @option{sigma} option will be ignored.
 +
 +The absolute value of the coefficient can be accessed through the @var{c}
 +variable.
 +
 +@item n
 +Set the @var{blocksize} using the number of bits. @code{1<<@var{n}} defines the
 +@var{blocksize}, which is the width and height of the processed blocks.
 +
 +The default value is @var{3} (8x8) and can be raised to @var{4} for a
 +@var{blocksize} of 16x16. Note that changing this setting has huge consequences
 +on the speed processing. Also, a larger block size does not necessarily means a
 +better de-noising.
 +@end table
 +
 +@subsection Examples
 +
 +Apply a denoise with a @option{sigma} of @code{4.5}:
 +@example
 +dctdnoiz=4.5
 +@end example
 +
 +The same operation can be achieved using the expression system:
 +@example
 +dctdnoiz=e='gte(c, 4.5*3)'
 +@end example
 +
 +Violent denoise using a block size of @code{16x16}:
 +@example
 +dctdnoiz=15:n=4
 +@end example
 +
 +@section deband
 +
 +Remove banding artifacts from input video.
 +It works by replacing banded pixels with average value of referenced pixels.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item 1thr
 +@item 2thr
 +@item 3thr
 +@item 4thr
 +Set banding detection threshold for each plane. Default is 0.02.
 +Valid range is 0.00003 to 0.5.
 +If difference between current pixel and reference pixel is less than threshold,
 +it will be considered as banded.
 +
 +@item range, r
 +Banding detection range in pixels. Default is 16. If positive, random number
 +in range 0 to set value will be used. If negative, exact absolute value
 +will be used.
 +The range defines square of four pixels around current pixel.
 +
 +@item direction, d
 +Set direction in radians from which four pixel will be compared. If positive,
 +random direction from 0 to set direction will be picked. If negative, exact of
 +absolute value will be picked. For example direction 0, -PI or -2*PI radians
 +will pick only pixels on same row and -PI/2 will pick only pixels on same
 +column.
 +
 +@item blur
 +If enabled, current pixel is compared with average value of all four
 +surrounding pixels. The default is enabled. If disabled current pixel is
 +compared with all four surrounding pixels. The pixel is considered banded
 +if only all four differences with surrounding pixels are less than threshold.
 +@end table
 +
 +@anchor{decimate}
 +@section decimate
 +
 +Drop duplicated frames at regular intervals.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item cycle
 +Set the number of frames from which one will be dropped. Setting this to
 +@var{N} means one frame in every batch of @var{N} frames will be dropped.
 +Default is @code{5}.
 +
 +@item dupthresh
 +Set the threshold for duplicate detection. If the difference metric for a frame
 +is less than or equal to this value, then it is declared as duplicate. Default
 +is @code{1.1}
 +
 +@item scthresh
 +Set scene change threshold. Default is @code{15}.
 +
 +@item blockx
 +@item blocky
 +Set the size of the x and y-axis blocks used during metric calculations.
 +Larger blocks give better noise suppression, but also give worse detection of
 +small movements. Must be a power of two. Default is @code{32}.
 +
 +@item ppsrc
 +Mark main input as a pre-processed input and activate clean source input
 +stream. This allows the input to be pre-processed with various filters to help
 +the metrics calculation while keeping the frame selection lossless. When set to
 +@code{1}, the first stream is for the pre-processed input, and the second
 +stream is the clean source from where the kept frames are chosen. Default is
 +@code{0}.
 +
 +@item chroma
 +Set whether or not chroma is considered in the metric calculations. Default is
 +@code{1}.
 +@end table
 +
 +@section deflate
 +
 +Apply deflate effect to the video.
 +
 +This filter replaces the pixel by the local(3x3) average by taking into account
 +only values lower than the pixel.
 +
 +It accepts the following options:
 +
 +@table @option
 +@item threshold0
 +@item threshold1
 +@item threshold2
 +@item threshold3
 +Limit the maximum change for each plane, default is 65535.
 +If 0, plane will remain unchanged.
 +@end table
 +
 +@section dejudder
 +
 +Remove judder produced by partially interlaced telecined content.
 +
 +Judder can be introduced, for instance, by @ref{pullup} filter. If the original
 +source was partially telecined content then the output of @code{pullup,dejudder}
 +will have a variable frame rate. May change the recorded frame rate of the
 +container. Aside from that change, this filter will not affect constant frame
 +rate video.
 +
 +The option available in this filter is:
 +@table @option
 +
 +@item cycle
 +Specify the length of the window over which the judder repeats.
 +
 +Accepts any integer greater than 1. Useful values are:
 +@table @samp
 +
 +@item 4
 +If the original was telecined from 24 to 30 fps (Film to NTSC).
 +
 +@item 5
 +If the original was telecined from 25 to 30 fps (PAL to NTSC).
 +
 +@item 20
 +If a mixture of the two.
 +@end table
 +
 +The default is @samp{4}.
 +@end table
 +
 +@section delogo
 +
 +Suppress a TV station logo by a simple interpolation of the surrounding
 +pixels. Just set a rectangle covering the logo and watch it disappear
 +(and sometimes something even uglier appear - your mileage may vary).
 +
 +It accepts the following parameters:
 +@table @option
 +
 +@item x
 +@item y
 +Specify the top left corner coordinates of the logo. They must be
 +specified.
 +
 +@item w
 +@item h
 +Specify the width and height of the logo to clear. They must be
 +specified.
 +
 +@item band, t
 +Specify the thickness of the fuzzy edge of the rectangle (added to
 +@var{w} and @var{h}). The default value is 1. This option is
 +deprecated, setting higher values should no longer be necessary and
 +is not recommended.
 +
 +@item show
 +When set to 1, a green rectangle is drawn on the screen to simplify
 +finding the right @var{x}, @var{y}, @var{w}, and @var{h} parameters.
 +The default value is 0.
 +
 +The rectangle is drawn on the outermost pixels which will be (partly)
 +replaced with interpolated values. The values of the next pixels
 +immediately outside this rectangle in each direction will be used to
 +compute the interpolated pixel values inside the rectangle.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set a rectangle covering the area with top left corner coordinates 0,0
 +and size 100x77, and a band of size 10:
 +@example
 +delogo=x=0:y=0:w=100:h=77:band=10
 +@end example
 +
 +@end itemize
 +
 +@section deshake
 +
 +Attempt to fix small changes in horizontal and/or vertical shift. This
 +filter helps remove camera shake from hand-holding a camera, bumping a
 +tripod, moving on a vehicle, etc.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +
 +@item x
 +@item y
 +@item w
 +@item h
 +Specify a rectangular area where to limit the search for motion
 +vectors.
 +If desired the search for motion vectors can be limited to a
 +rectangular area of the frame defined by its top left corner, width
 +and height. These parameters have the same meaning as the drawbox
 +filter which can be used to visualise the position of the bounding
 +box.
 +
 +This is useful when simultaneous movement of subjects within the frame
 +might be confused for camera motion by the motion vector search.
 +
 +If any or all of @var{x}, @var{y}, @var{w} and @var{h} are set to -1
 +then the full frame is used. This allows later options to be set
 +without specifying the bounding box for the motion vector search.
 +
 +Default - search the whole frame.
 +
 +@item rx
 +@item ry
 +Specify the maximum extent of movement in x and y directions in the
 +range 0-64 pixels. Default 16.
 +
 +@item edge
 +Specify how to generate pixels to fill blanks at the edge of the
 +frame. Available values are:
 +@table @samp
 +@item blank, 0
 +Fill zeroes at blank locations
 +@item original, 1
 +Original image at blank locations
 +@item clamp, 2
 +Extruded edge value at blank locations
 +@item mirror, 3
 +Mirrored edge at blank locations
 +@end table
 +Default value is @samp{mirror}.
 +
 +@item blocksize
 +Specify the blocksize to use for motion search. Range 4-128 pixels,
 +default 8.
 +
 +@item contrast
 +Specify the contrast threshold for blocks. Only blocks with more than
 +the specified contrast (difference between darkest and lightest
 +pixels) will be considered. Range 1-255, default 125.
 +
 +@item search
 +Specify the search strategy. Available values are:
 +@table @samp
 +@item exhaustive, 0
 +Set exhaustive search
 +@item less, 1
 +Set less exhaustive search.
 +@end table
 +Default value is @samp{exhaustive}.
 +
 +@item filename
 +If set then a detailed log of the motion search is written to the
 +specified file.
 +
 +@item opencl
 +If set to 1, specify using OpenCL capabilities, only available if
 +FFmpeg was configured with @code{--enable-opencl}. Default value is 0.
 +
 +@end table
 +
 +@section detelecine
 +
 +Apply an exact inverse of the telecine operation. It requires a predefined
 +pattern specified using the pattern option which must be the same as that passed
 +to the telecine filter.
 +
 +This filter accepts the following options:
 +
 +@table @option
 +@item first_field
 +@table @samp
 +@item top, t
 +top field first
 +@item bottom, b
 +bottom field first
 +The default value is @code{top}.
 +@end table
 +
 +@item pattern
 +A string of numbers representing the pulldown pattern you wish to apply.
 +The default value is @code{23}.
 +
 +@item start_frame
 +A number representing position of the first frame with respect to the telecine
 +pattern. This is to be used if the stream is cut. The default value is @code{0}.
 +@end table
 +
 +@section dilation
 +
 +Apply dilation effect to the video.
 +
 +This filter replaces the pixel by the local(3x3) maximum.
 +
 +It accepts the following options:
 +
 +@table @option
 +@item threshold0
 +@item threshold1
 +@item threshold2
 +@item threshold3
 +Limit the maximum change for each plane, default is 65535.
 +If 0, plane will remain unchanged.
 +
 +@item coordinates
 +Flag which specifies the pixel to refer to. Default is 255 i.e. all eight
 +pixels are used.
 +
 +Flags to local 3x3 coordinates maps like this:
 +
 +    1 2 3
 +    4   5
 +    6 7 8
 +@end table
 +
 +@section displace
 +
 +Displace pixels as indicated by second and third input stream.
 +
 +It takes three input streams and outputs one stream, the first input is the
 +source, and second and third input are displacement maps.
 +
 +The second input specifies how much to displace pixels along the
 +x-axis, while the third input specifies how much to displace pixels
 +along the y-axis.
 +If one of displacement map streams terminates, last frame from that
 +displacement map will be used.
 +
 +Note that once generated, displacements maps can be reused over and over again.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item edge
 +Set displace behavior for pixels that are out of range.
 +
 +Available values are:
 +@table @samp
 +@item blank
 +Missing pixels are replaced by black pixels.
 +
 +@item smear
 +Adjacent pixels will spread out to replace missing pixels.
 +
 +@item wrap
 +Out of range pixels are wrapped so they point to pixels of other side.
 +@end table
 +Default is @samp{smear}.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Add ripple effect to rgb input of video size hd720:
 +@example
 +ffmpeg -i INPUT -f lavfi -i nullsrc=s=hd720,lutrgb=128:128:128 -f lavfi -i nullsrc=s=hd720,geq='r=128+30*sin(2*PI*X/400+T):g=128+30*sin(2*PI*X/400+T):b=128+30*sin(2*PI*X/400+T)' -lavfi '[0][1][2]displace' OUTPUT
 +@end example
 +
 +@item
 +Add wave effect to rgb input of video size hd720:
 +@example
 +ffmpeg -i INPUT -f lavfi -i nullsrc=hd720,geq='r=128+80*(sin(sqrt((X-W/2)*(X-W/2)+(Y-H/2)*(Y-H/2))/220*2*PI+T)):g=128+80*(sin(sqrt((X-W/2)*(X-W/2)+(Y-H/2)*(Y-H/2))/220*2*PI+T)):b=128+80*(sin(sqrt((X-W/2)*(X-W/2)+(Y-H/2)*(Y-H/2))/220*2*PI+T))' -lavfi '[1]split[x][y],[0][x][y]displace' OUTPUT
 +@end example
 +@end itemize
 +
 +@section drawbox
 +
 +Draw a colored box on the input image.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item x
 +@item y
 +The expressions which specify the top left corner coordinates of the box. It defaults to 0.
 +
 +@item width, w
 +@item height, h
 +The expressions which specify the width and height of the box; if 0 they are interpreted as
 +the input width and height. It defaults to 0.
 +
 +@item color, c
 +Specify the color of the box to write. For the general syntax of this option,
 +check the "Color" section in the ffmpeg-utils manual. If the special
 +value @code{invert} is used, the box edge color is the same as the
 +video with inverted luma.
 +
 +@item thickness, t
 +The expression which sets the thickness of the box edge. Default value is @code{3}.
 +
 +See below for the list of accepted constants.
 +@end table
 +
 +The parameters for @var{x}, @var{y}, @var{w} and @var{h} and @var{t} are expressions containing the
 +following constants:
 +
 +@table @option
 +@item dar
 +The input display aspect ratio, it is the same as (@var{w} / @var{h}) * @var{sar}.
 +
 +@item hsub
 +@item vsub
 +horizontal and vertical chroma subsample values. For example for the
 +pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +
 +@item in_h, ih
 +@item in_w, iw
 +The input width and height.
 +
 +@item sar
 +The input sample aspect ratio.
 +
 +@item x
 +@item y
 +The x and y offset coordinates where the box is drawn.
 +
 +@item w
 +@item h
 +The width and height of the drawn box.
 +
 +@item t
 +The thickness of the drawn box.
 +
 +These constants allow the @var{x}, @var{y}, @var{w}, @var{h} and @var{t} expressions to refer to
 +each other, so you may for example specify @code{y=x/dar} or @code{h=w/dar}.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw a black box around the edge of the input image:
 +@example
 +drawbox
 +@end example
 +
 +@item
 +Draw a box with color red and an opacity of 50%:
 +@example
 +drawbox=10:20:200:60:red@@0.5
 +@end example
 +
 +The previous example can be specified as:
 +@example
 +drawbox=x=10:y=20:w=200:h=60:color=red@@0.5
 +@end example
 +
 +@item
 +Fill the box with pink color:
 +@example
 +drawbox=x=10:y=10:w=100:h=100:color=pink@@0.5:t=max
 +@end example
 +
 +@item
 +Draw a 2-pixel red 2.40:1 mask:
 +@example
 +drawbox=x=-t:y=0.5*(ih-iw/2.4)-t:w=iw+t*2:h=iw/2.4+t*2:t=2:c=red
 +@end example
 +@end itemize
 +
 +@section drawgraph, adrawgraph
 +
 +Draw a graph using input video or audio metadata.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item m1
 +Set 1st frame metadata key from which metadata values will be used to draw a graph.
 +
 +@item fg1
 +Set 1st foreground color expression.
 +
 +@item m2
 +Set 2nd frame metadata key from which metadata values will be used to draw a graph.
 +
 +@item fg2
 +Set 2nd foreground color expression.
 +
 +@item m3
 +Set 3rd frame metadata key from which metadata values will be used to draw a graph.
 +
 +@item fg3
 +Set 3rd foreground color expression.
 +
 +@item m4
 +Set 4th frame metadata key from which metadata values will be used to draw a graph.
 +
 +@item fg4
 +Set 4th foreground color expression.
 +
 +@item min
 +Set minimal value of metadata value.
 +
 +@item max
 +Set maximal value of metadata value.
 +
 +@item bg
 +Set graph background color. Default is white.
 +
 +@item mode
 +Set graph mode.
 +
 +Available values for mode is:
 +@table @samp
 +@item bar
 +@item dot
 +@item line
 +@end table
 +
 +Default is @code{line}.
 +
 +@item slide
 +Set slide mode.
 +
 +Available values for slide is:
 +@table @samp
 +@item frame
 +Draw new frame when right border is reached.
 +
 +@item replace
 +Replace old columns with new ones.
 +
 +@item scroll
 +Scroll from right to left.
 +
 +@item rscroll
 +Scroll from left to right.
 +@end table
 +
 +Default is @code{frame}.
 +
 +@item size
 +Set size of graph video. For the syntax of this option, check the
 +@ref{video size syntax,,"Video size" section in the ffmpeg-utils manual,ffmpeg-utils}.
 +The default value is @code{900x256}.
 +
 +The foreground color expressions can use the following variables:
 +@table @option
 +@item MIN
 +Minimal value of metadata value.
 +
 +@item MAX
 +Maximal value of metadata value.
 +
 +@item VAL
 +Current metadata key value.
 +@end table
 +
 +The color is defined as 0xAABBGGRR.
 +@end table
 +
 +Example using metadata from @ref{signalstats} filter:
 +@example
 +signalstats,drawgraph=lavfi.signalstats.YAVG:min=0:max=255
 +@end example
 +
 +Example using metadata from @ref{ebur128} filter:
 +@example
 +ebur128=metadata=1,adrawgraph=lavfi.r128.M:min=-120:max=5
 +@end example
 +
 +@section drawgrid
 +
 +Draw a grid on the input image.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item x
 +@item y
 +The expressions which specify the coordinates of some point of grid intersection (meant to configure offset). Both default to 0.
 +
 +@item width, w
 +@item height, h
 +The expressions which specify the width and height of the grid cell, if 0 they are interpreted as the
 +input width and height, respectively, minus @code{thickness}, so image gets
 +framed. Default to 0.
 +
 +@item color, c
 +Specify the color of the grid. For the general syntax of this option,
 +check the "Color" section in the ffmpeg-utils manual. If the special
 +value @code{invert} is used, the grid color is the same as the
 +video with inverted luma.
 +
 +@item thickness, t
 +The expression which sets the thickness of the grid line. Default value is @code{1}.
 +
 +See below for the list of accepted constants.
 +@end table
 +
 +The parameters for @var{x}, @var{y}, @var{w} and @var{h} and @var{t} are expressions containing the
 +following constants:
 +
 +@table @option
 +@item dar
 +The input display aspect ratio, it is the same as (@var{w} / @var{h}) * @var{sar}.
 +
 +@item hsub
 +@item vsub
 +horizontal and vertical chroma subsample values. For example for the
 +pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +
 +@item in_h, ih
 +@item in_w, iw
 +The input grid cell width and height.
 +
 +@item sar
 +The input sample aspect ratio.
 +
 +@item x
 +@item y
 +The x and y coordinates of some point of grid intersection (meant to configure offset).
 +
 +@item w
 +@item h
 +The width and height of the drawn cell.
 +
 +@item t
 +The thickness of the drawn cell.
 +
 +These constants allow the @var{x}, @var{y}, @var{w}, @var{h} and @var{t} expressions to refer to
 +each other, so you may for example specify @code{y=x/dar} or @code{h=w/dar}.
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw a grid with cell 100x100 pixels, thickness 2 pixels, with color red and an opacity of 50%:
 +@example
 +drawgrid=width=100:height=100:thickness=2:color=red@@0.5
 +@end example
 +
 +@item
 +Draw a white 3x3 grid with an opacity of 50%:
 +@example
 +drawgrid=w=iw/3:h=ih/3:t=2:c=white@@0.5
 +@end example
 +@end itemize
 +
 +@anchor{drawtext}
 +@section drawtext
 +
 +Draw a text string or text from a specified file on top of a video, using the
 +libfreetype library.
 +
 +To enable compilation of this filter, you need to configure FFmpeg with
 +@code{--enable-libfreetype}.
 +To enable default font fallback and the @var{font} option you need to
 +configure FFmpeg with @code{--enable-libfontconfig}.
 +To enable the @var{text_shaping} option, you need to configure FFmpeg with
 +@code{--enable-libfribidi}.
 +
 +@subsection Syntax
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item box
 +Used to draw a box around text using the background color.
 +The value must be either 1 (enable) or 0 (disable).
 +The default value of @var{box} is 0.
 +
 +@item boxborderw
 +Set the width of the border to be drawn around the box using @var{boxcolor}.
 +The default value of @var{boxborderw} is 0.
 +
 +@item boxcolor
 +The color to be used for drawing box around text. For the syntax of this
 +option, check the "Color" section in the ffmpeg-utils manual.
 +
 +The default value of @var{boxcolor} is "white".
 +
 +@item borderw
 +Set the width of the border to be drawn around the text using @var{bordercolor}.
 +The default value of @var{borderw} is 0.
 +
 +@item bordercolor
 +Set the color to be used for drawing border around text. For the syntax of this
 +option, check the "Color" section in the ffmpeg-utils manual.
 +
 +The default value of @var{bordercolor} is "black".
 +
 +@item expansion
 +Select how the @var{text} is expanded. Can be either @code{none},
 +@code{strftime} (deprecated) or
 +@code{normal} (default). See the @ref{drawtext_expansion, Text expansion} section
 +below for details.
 +
 +@item fix_bounds
 +If true, check and fix text coords to avoid clipping.
 +
 +@item fontcolor
 +The color to be used for drawing fonts. For the syntax of this option, check
 +the "Color" section in the ffmpeg-utils manual.
 +
 +The default value of @var{fontcolor} is "black".
 +
 +@item fontcolor_expr
 +String which is expanded the same way as @var{text} to obtain dynamic
 +@var{fontcolor} value. By default this option has empty value and is not
 +processed. When this option is set, it overrides @var{fontcolor} option.
 +
 +@item font
 +The font family to be used for drawing text. By default Sans.
 +
 +@item fontfile
 +The font file to be used for drawing text. The path must be included.
 +This parameter is mandatory if the fontconfig support is disabled.
 +
 +@item draw
 +This option does not exist, please see the timeline system
 +
 +@item alpha
 +Draw the text applying alpha blending. The value can
 +be either a number between 0.0 and 1.0
 +The expression accepts the same variables @var{x, y} do.
 +The default value is 1.
 +Please see fontcolor_expr
 +
 +@item fontsize
 +The font size to be used for drawing text.
 +The default value of @var{fontsize} is 16.
 +
 +@item text_shaping
 +If set to 1, attempt to shape the text (for example, reverse the order of
 +right-to-left text and join Arabic characters) before drawing it.
 +Otherwise, just draw the text exactly as given.
 +By default 1 (if supported).
 +
 +@item ft_load_flags
 +The flags to be used for loading the fonts.
 +
 +The flags map the corresponding flags supported by libfreetype, and are
 +a combination of the following values:
 +@table @var
 +@item default
 +@item no_scale
 +@item no_hinting
 +@item render
 +@item no_bitmap
 +@item vertical_layout
 +@item force_autohint
 +@item crop_bitmap
 +@item pedantic
 +@item ignore_global_advance_width
 +@item no_recurse
 +@item ignore_transform
 +@item monochrome
 +@item linear_design
 +@item no_autohint
 +@end table
 +
 +Default value is "default".
 +
 +For more information consult the documentation for the FT_LOAD_*
 +libfreetype flags.
 +
 +@item shadowcolor
 +The color to be used for drawing a shadow behind the drawn text. For the
 +syntax of this option, check the "Color" section in the ffmpeg-utils manual.
 +
 +The default value of @var{shadowcolor} is "black".
 +
 +@item shadowx
 +@item shadowy
 +The x and y offsets for the text shadow position with respect to the
 +position of the text. They can be either positive or negative
 +values. The default value for both is "0".
 +
 +@item start_number
 +The starting frame number for the n/frame_num variable. The default value
 +is "0".
 +
 +@item tabsize
 +The size in number of spaces to use for rendering the tab.
 +Default value is 4.
 +
 +@item timecode
 +Set the initial timecode representation in "hh:mm:ss[:;.]ff"
 +format. It can be used with or without text parameter. @var{timecode_rate}
 +option must be specified.
 +
 +@item timecode_rate, rate, r
 +Set the timecode frame rate (timecode only).
 +
 +@item text
 +The text string to be drawn. The text must be a sequence of UTF-8
 +encoded characters.
 +This parameter is mandatory if no file is specified with the parameter
 +@var{textfile}.
 +
 +@item textfile
 +A text file containing text to be drawn. The text must be a sequence
 +of UTF-8 encoded characters.
 +
 +This parameter is mandatory if no text string is specified with the
 +parameter @var{text}.
 +
 +If both @var{text} and @var{textfile} are specified, an error is thrown.
 +
 +@item reload
 +If set to 1, the @var{textfile} will be reloaded before each frame.
 +Be sure to update it atomically, or it may be read partially, or even fail.
 +
 +@item x
 +@item y
 +The expressions which specify the offsets where text will be drawn
 +within the video frame. They are relative to the top/left border of the
 +output image.
 +
 +The default value of @var{x} and @var{y} is "0".
 +
 +See below for the list of accepted constants and functions.
 +@end table
 +
 +The parameters for @var{x} and @var{y} are expressions containing the
 +following constants and functions:
 +
 +@table @option
 +@item dar
 +input display aspect ratio, it is the same as (@var{w} / @var{h}) * @var{sar}
 +
 +@item hsub
 +@item vsub
 +horizontal and vertical chroma subsample values. For example for the
 +pixel format "yuv422p" @var{hsub} is 2 and @var{vsub} is 1.
 +
 +@item line_h, lh
 +the height of each text line
 +
 +@item main_h, h, H
 +the input height
 +
 +@item main_w, w, W
 +the input width
 +
 +@item max_glyph_a, ascent
 +the maximum distance from the baseline to the highest/upper grid
 +coordinate used to place a glyph outline point, for all the rendered
 +glyphs.
 +It is a positive value, due to the grid's orientation with the Y axis
 +upwards.
 +
 +@item max_glyph_d, descent
 +the maximum distance from the baseline to the lowest grid coordinate
 +used to place a glyph outline point, for all the rendered glyphs.
 +This is a negative value, due to the grid's orientation, with the Y axis
 +upwards.
 +
 +@item max_glyph_h
 +maximum glyph height, that is the maximum height for all the glyphs
 +contained in the rendered text, it is equivalent to @var{ascent} -
 +@var{descent}.
 +
 +@item max_glyph_w
 +maximum glyph width, that is the maximum width for all the glyphs
 +contained in the rendered text
 +
 +@item n
 +the number of input frame, starting from 0
 +
 +@item rand(min, max)
 +return a random number included between @var{min} and @var{max}
 +
 +@item sar
 +The input sample aspect ratio.
 +
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +
 +@item text_h, th
 +the height of the rendered text
 +
 +@item text_w, tw
 +the width of the rendered text
 +
 +@item x
 +@item y
 +the x and y offset coordinates where the text is drawn.
 +
 +These parameters allow the @var{x} and @var{y} expressions to refer
 +each other, so you can for example specify @code{y=x/dar}.
 +@end table
 +
 +@anchor{drawtext_expansion}
 +@subsection Text expansion
 +
 +If @option{expansion} is set to @code{strftime},
 +the filter recognizes strftime() sequences in the provided text and
 +expands them accordingly. Check the documentation of strftime(). This
 +feature is deprecated.
 +
 +If @option{expansion} is set to @code{none}, the text is printed verbatim.
 +
 +If @option{expansion} is set to @code{normal} (which is the default),
 +the following expansion mechanism is used.
 +
 +The backslash character @samp{\}, followed by any character, always expands to
 +the second character.
 +
 +Sequence of the form @code{%@{...@}} are expanded. The text between the
 +braces is a function name, possibly followed by arguments separated by ':'.
 +If the arguments contain special characters or delimiters (':' or '@}'),
 +they should be escaped.
 +
 +Note that they probably must also be escaped as the value for the
 +@option{text} option in the filter argument string and as the filter
 +argument in the filtergraph description, and possibly also for the shell,
 +that makes up to four levels of escaping; using a text file avoids these
 +problems.
 +
 +The following functions are available:
 +
 +@table @command
 +
 +@item expr, e
 +The expression evaluation result.
 +
 +It must take one argument specifying the expression to be evaluated,
 +which accepts the same constants and functions as the @var{x} and
 +@var{y} values. Note that not all constants should be used, for
 +example the text size is not known when evaluating the expression, so
 +the constants @var{text_w} and @var{text_h} will have an undefined
 +value.
 +
 +@item expr_int_format, eif
 +Evaluate the expression's value and output as formatted integer.
 +
 +The first argument is the expression to be evaluated, just as for the @var{expr} function.
 +The second argument specifies the output format. Allowed values are @samp{x},
 +@samp{X}, @samp{d} and @samp{u}. They are treated exactly as in the
 +@code{printf} function.
 +The third parameter is optional and sets the number of positions taken by the output.
 +It can be used to add padding with zeros from the left.
 +
 +@item gmtime
 +The time at which the filter is running, expressed in UTC.
 +It can accept an argument: a strftime() format string.
 +
 +@item localtime
 +The time at which the filter is running, expressed in the local time zone.
 +It can accept an argument: a strftime() format string.
 +
 +@item metadata
 +Frame metadata. Takes one or two arguments.
 +
 +The first argument is mandatory and specifies the metadata key.
 +
 +The second argument is optional and specifies a default value, used when the
 +metadata key is not found or empty.
 +
 +@item n, frame_num
 +The frame number, starting from 0.
 +
 +@item pict_type
 +A 1 character description of the current picture type.
 +
 +@item pts
 +The timestamp of the current frame.
 +It can take up to three arguments.
 +
 +The first argument is the format of the timestamp; it defaults to @code{flt}
 +for seconds as a decimal number with microsecond accuracy; @code{hms} stands
 +for a formatted @var{[-]HH:MM:SS.mmm} timestamp with millisecond accuracy.
 +@code{gmtime} stands for the timestamp of the frame formatted as UTC time;
 +@code{localtime} stands for the timestamp of the frame formatted as
 +local time zone time.
 +
 +The second argument is an offset added to the timestamp.
 +
 +If the format is set to @code{localtime} or @code{gmtime},
 +a third argument may be supplied: a strftime() format string.
 +By default, @var{YYYY-MM-DD HH:MM:SS} format will be used.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Draw "Test Text" with font FreeSerif, using the default values for the
 +optional parameters.
 +
 +@example
 +drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text'"
 +@end example
 +
 +@item
 +Draw 'Test Text' with font FreeSerif of size 24 at position x=100
 +and y=50 (counting from the top-left corner of the screen), text is
 +yellow with a red box around it. Both the text and the box have an
 +opacity of 20%.
 +
 +@example
 +drawtext="fontfile=/usr/share/fonts/truetype/freefont/FreeSerif.ttf: text='Test Text':\
 +          x=100: y=50: fontsize=24: fontcolor=yellow@@0.2: box=1: boxcolor=red@@0.2"
 +@end example
 +
 +Note that the double quotes are not necessary if spaces are not used
 +within the parameter list.
 +
 +@item
 +Show the text at the center of the video frame:
 +@example
 +drawtext="fontsize=30:fontfile=FreeSerif.ttf:text='hello world':x=(w-text_w)/2:y=(h-text_h)/2"
 +@end example
 +
 +@item
 +Show the text at a random position, switching to a new position every 30 seconds:
 +@example
 +drawtext="fontsize=30:fontfile=FreeSerif.ttf:text='hello world':x=if(eq(mod(t\,30)\,0)\,rand(0\,(w-text_w))\,x):y=if(eq(mod(t\,30)\,0)\,rand(0\,(h-text_h))\,y)"
 +@end example
 +
 +@item
 +Show a text line sliding from right to left in the last row of the video
 +frame. The file @file{LONG_LINE} is assumed to contain a single line
 +with no newlines.
 +@example
 +drawtext="fontsize=15:fontfile=FreeSerif.ttf:text=LONG_LINE:y=h-line_h:x=-50*t"
 +@end example
 +
 +@item
 +Show the content of file @file{CREDITS} off the bottom of the frame and scroll up.
 +@example
 +drawtext="fontsize=20:fontfile=FreeSerif.ttf:textfile=CREDITS:y=h-20*t"
 +@end example
 +
 +@item
 +Draw a single green letter "g", at the center of the input video.
 +The glyph baseline is placed at half screen height.
 +@example
 +drawtext="fontsize=60:fontfile=FreeSerif.ttf:fontcolor=green:text=g:x=(w-max_glyph_w)/2:y=h/2-ascent"
 +@end example
 +
 +@item
 +Show text for 1 second every 3 seconds:
 +@example
 +drawtext="fontfile=FreeSerif.ttf:fontcolor=white:x=100:y=x/dar:enable=lt(mod(t\,3)\,1):text='blink'"
 +@end example
 +
 +@item
 +Use fontconfig to set the font. Note that the colons need to be escaped.
 +@example
 +drawtext='fontfile=Linux Libertine O-40\:style=Semibold:text=FFmpeg'
 +@end example
 +
 +@item
 +Print the date of a real-time encoding (see strftime(3)):
 +@example
 +drawtext='fontfile=FreeSans.ttf:text=%@{localtime\:%a %b %d %Y@}'
 +@end example
 +
 +@item
 +Show text fading in and out (appearing/disappearing):
 +@example
 +#!/bin/sh
 +DS=1.0 # display start
 +DE=10.0 # display end
 +FID=1.5 # fade in duration
 +FOD=5 # fade out duration
 +ffplay -f lavfi "color,drawtext=text=TEST:fontsize=50:fontfile=FreeSerif.ttf:fontcolor_expr=ff0000%@{eif\\\\: clip(255*(1*between(t\\, $DS + $FID\\, $DE - $FOD) + ((t - $DS)/$FID)*between(t\\, $DS\\, $DS + $FID) + (-(t - $DE)/$FOD)*between(t\\, $DE - $FOD\\, $DE) )\\, 0\\, 255) \\\\: x\\\\: 2 @}"
 +@end example
 +
 +@end itemize
 +
 +For more information about libfreetype, check:
 +@url{http://www.freetype.org/}.
 +
 +For more information about fontconfig, check:
 +@url{http://freedesktop.org/software/fontconfig/fontconfig-user.html}.
 +
 +For more information about libfribidi, check:
 +@url{http://fribidi.org/}.
 +
 +@section edgedetect
 +
 +Detect and draw edges. The filter uses the Canny Edge Detection algorithm.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item low
 +@item high
 +Set low and high threshold values used by the Canny thresholding
 +algorithm.
 +
 +The high threshold selects the "strong" edge pixels, which are then
 +connected through 8-connectivity with the "weak" edge pixels selected
 +by the low threshold.
 +
 +@var{low} and @var{high} threshold values must be chosen in the range
 +[0,1], and @var{low} should be lesser or equal to @var{high}.
 +
 +Default value for @var{low} is @code{20/255}, and default value for @var{high}
 +is @code{50/255}.
 +
 +@item mode
 +Define the drawing mode.
 +
 +@table @samp
 +@item wires
 +Draw white/gray wires on black background.
 +
 +@item colormix
 +Mix the colors to create a paint/cartoon effect.
 +@end table
 +
 +Default value is @var{wires}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Standard edge detection with custom values for the hysteresis thresholding:
 +@example
 +edgedetect=low=0.1:high=0.4
 +@end example
 +
 +@item
 +Painting effect without thresholding:
 +@example
 +edgedetect=mode=colormix:high=0
 +@end example
 +@end itemize
 +
 +@section eq
 +Set brightness, contrast, saturation and approximate gamma adjustment.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item contrast
 +Set the contrast expression. The value must be a float value in range
 +@code{-2.0} to @code{2.0}. The default value is "1".
 +
 +@item brightness
 +Set the brightness expression. The value must be a float value in
 +range @code{-1.0} to @code{1.0}. The default value is "0".
 +
 +@item saturation
 +Set the saturation expression. The value must be a float in
 +range @code{0.0} to @code{3.0}. The default value is "1".
 +
 +@item gamma
 +Set the gamma expression. The value must be a float in range
 +@code{0.1} to @code{10.0}.  The default value is "1".
 +
 +@item gamma_r
 +Set the gamma expression for red. The value must be a float in
 +range @code{0.1} to @code{10.0}. The default value is "1".
 +
 +@item gamma_g
 +Set the gamma expression for green. The value must be a float in range
 +@code{0.1} to @code{10.0}. The default value is "1".
 +
 +@item gamma_b
 +Set the gamma expression for blue. The value must be a float in range
 +@code{0.1} to @code{10.0}. The default value is "1".
 +
 +@item gamma_weight
 +Set the gamma weight expression. It can be used to reduce the effect
 +of a high gamma value on bright image areas, e.g. keep them from
 +getting overamplified and just plain white. The value must be a float
 +in range @code{0.0} to @code{1.0}. A value of @code{0.0} turns the
 +gamma correction all the way down while @code{1.0} leaves it at its
 +full strength. Default is "1".
 +
 +@item eval
 +Set when the expressions for brightness, contrast, saturation and
 +gamma expressions are evaluated.
 +
 +It accepts the following values:
 +@table @samp
 +@item init
 +only evaluate expressions once during the filter initialization or
 +when a command is processed
 +
 +@item frame
 +evaluate expressions for each incoming frame
 +@end table
 +
 +Default value is @samp{init}.
 +@end table
 +
 +The expressions accept the following parameters:
 +@table @option
 +@item n
 +frame count of the input frame starting from 0
 +
 +@item pos
 +byte position of the corresponding packet in the input file, NAN if
 +unspecified
 +
 +@item r
 +frame rate of the input video, NAN if the input frame rate is unknown
 +
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +@end table
 +
 +@subsection Commands
 +The filter supports the following commands:
 +
 +@table @option
 +@item contrast
 +Set the contrast expression.
 +
 +@item brightness
 +Set the brightness expression.
 +
 +@item saturation
 +Set the saturation expression.
 +
 +@item gamma
 +Set the gamma expression.
 +
 +@item gamma_r
 +Set the gamma_r expression.
 +
 +@item gamma_g
 +Set gamma_g expression.
 +
 +@item gamma_b
 +Set gamma_b expression.
 +
 +@item gamma_weight
 +Set gamma_weight expression.
 +
 +The command accepts the same syntax of the corresponding option.
 +
 +If the specified expression is not valid, it is kept at its current
 +value.
 +
 +@end table
 +
 +@section erosion
 +
 +Apply erosion effect to the video.
 +
 +This filter replaces the pixel by the local(3x3) minimum.
 +
 +It accepts the following options:
 +
 +@table @option
 +@item threshold0
 +@item threshold1
 +@item threshold2
 +@item threshold3
 +Limit the maximum change for each plane, default is 65535.
 +If 0, plane will remain unchanged.
 +
 +@item coordinates
 +Flag which specifies the pixel to refer to. Default is 255 i.e. all eight
 +pixels are used.
 +
 +Flags to local 3x3 coordinates maps like this:
 +
 +    1 2 3
 +    4   5
 +    6 7 8
 +@end table
 +
 +@section extractplanes
 +
 +Extract color channel components from input video stream into
 +separate grayscale video streams.
 +
 +The filter accepts the following option:
 +
 +@table @option
 +@item planes
 +Set plane(s) to extract.
 +
 +Available values for planes are:
 +@table @samp
 +@item y
 +@item u
 +@item v
 +@item a
 +@item r
 +@item g
 +@item b
 +@end table
 +
 +Choosing planes not available in the input will result in an error.
 +That means you cannot select @code{r}, @code{g}, @code{b} planes
 +with @code{y}, @code{u}, @code{v} planes at same time.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Extract luma, u and v color channel component from input video frame
 +into 3 grayscale outputs:
 +@example
 +ffmpeg -i video.avi -filter_complex 'extractplanes=y+u+v[y][u][v]' -map '[y]' y.avi -map '[u]' u.avi -map '[v]' v.avi
 +@end example
 +@end itemize
 +
 +@section elbg
 +
 +Apply a posterize effect using the ELBG (Enhanced LBG) algorithm.
 +
 +For each input image, the filter will compute the optimal mapping from
 +the input to the output given the codebook length, that is the number
 +of distinct output colors.
 +
 +This filter accepts the following options.
 +
 +@table @option
 +@item codebook_length, l
 +Set codebook length. The value must be a positive integer, and
 +represents the number of distinct output colors. Default value is 256.
 +
 +@item nb_steps, n
 +Set the maximum number of iterations to apply for computing the optimal
 +mapping. The higher the value the better the result and the higher the
 +computation time. Default value is 1.
 +
 +@item seed, s
 +Set a random seed, must be an integer included between 0 and
 +UINT32_MAX. If not specified, or if explicitly set to -1, the filter
 +will try to use a good random seed on a best effort basis.
 +
 +@item pal8
 +Set pal8 output pixel format. This option does not work with codebook
 +length greater than 256.
 +@end table
 +
 +@section fade
 +
 +Apply a fade-in/out effect to the input video.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item type, t
 +The effect type can be either "in" for a fade-in, or "out" for a fade-out
 +effect.
 +Default is @code{in}.
 +
 +@item start_frame, s
 +Specify the number of the frame to start applying the fade
 +effect at. Default is 0.
 +
 +@item nb_frames, n
 +The number of frames that the fade effect lasts. At the end of the
 +fade-in effect, the output video will have the same intensity as the input video.
 +At the end of the fade-out transition, the output video will be filled with the
 +selected @option{color}.
 +Default is 25.
 +
 +@item alpha
 +If set to 1, fade only alpha channel, if one exists on the input.
 +Default value is 0.
 +
 +@item start_time, st
 +Specify the timestamp (in seconds) of the frame to start to apply the fade
 +effect. If both start_frame and start_time are specified, the fade will start at
 +whichever comes last.  Default is 0.
 +
 +@item duration, d
 +The number of seconds for which the fade effect has to last. At the end of the
 +fade-in effect the output video will have the same intensity as the input video,
 +at the end of the fade-out transition the output video will be filled with the
 +selected @option{color}.
 +If both duration and nb_frames are specified, duration is used. Default is 0
 +(nb_frames is used by default).
 +
 +@item color, c
 +Specify the color of the fade. Default is "black".
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Fade in the first 30 frames of video:
 +@example
 +fade=in:0:30
 +@end example
 +
 +The command above is equivalent to:
 +@example
 +fade=t=in:s=0:n=30
 +@end example
 +
 +@item
 +Fade out the last 45 frames of a 200-frame video:
 +@example
 +fade=out:155:45
 +fade=type=out:start_frame=155:nb_frames=45
 +@end example
 +
 +@item
 +Fade in the first 25 frames and fade out the last 25 frames of a 1000-frame video:
 +@example
 +fade=in:0:25, fade=out:975:25
 +@end example
 +
 +@item
 +Make the first 5 frames yellow, then fade in from frame 5-24:
 +@example
 +fade=in:5:20:color=yellow
 +@end example
 +
 +@item
 +Fade in alpha over first 25 frames of video:
 +@example
 +fade=in:0:25:alpha=1
 +@end example
 +
 +@item
 +Make the first 5.5 seconds black, then fade in for 0.5 seconds:
 +@example
 +fade=t=in:st=5.5:d=0.5
 +@end example
 +
 +@end itemize
 +
 +@section fftfilt
 +Apply arbitrary expressions to samples in frequency domain
 +
 +@table @option
 +@item dc_Y
 +Adjust the dc value (gain) of the luma plane of the image. The filter
 +accepts an integer value in range @code{0} to @code{1000}. The default
 +value is set to @code{0}.
 +
 +@item dc_U
 +Adjust the dc value (gain) of the 1st chroma plane of the image. The
 +filter accepts an integer value in range @code{0} to @code{1000}. The
 +default value is set to @code{0}.
 +
 +@item dc_V
 +Adjust the dc value (gain) of the 2nd chroma plane of the image. The
 +filter accepts an integer value in range @code{0} to @code{1000}. The
 +default value is set to @code{0}.
 +
 +@item weight_Y
 +Set the frequency domain weight expression for the luma plane.
 +
 +@item weight_U
 +Set the frequency domain weight expression for the 1st chroma plane.
 +
 +@item weight_V
 +Set the frequency domain weight expression for the 2nd chroma plane.
 +
 +The filter accepts the following variables:
 +@item X
 +@item Y
 +The coordinates of the current sample.
 +
 +@item W
 +@item H
 +The width and height of the image.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +High-pass:
 +@example
 +fftfilt=dc_Y=128:weight_Y='squish(1-(Y+X)/100)'
 +@end example
 +
 +@item
 +Low-pass:
 +@example
 +fftfilt=dc_Y=0:weight_Y='squish((Y+X)/100-1)'
 +@end example
 +
 +@item
 +Sharpen:
 +@example
 +fftfilt=dc_Y=0:weight_Y='1+squish(1-(Y+X)/100)'
 +@end example
 +
 +@item
 +Blur:
 +@example
 +fftfilt=dc_Y=0:weight_Y='exp(-4 * ((Y+X)/(W+H)))'
 +@end example
 +
 +@end itemize
 +
 +@section field
 +
 +Extract a single field from an interlaced image using stride
 +arithmetic to avoid wasting CPU time. The output frames are marked as
 +non-interlaced.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item type
 +Specify whether to extract the top (if the value is @code{0} or
 +@code{top}) or the bottom field (if the value is @code{1} or
 +@code{bottom}).
 +@end table
 +
 +@section fieldhint
 +
 +Create new frames by copying the top and bottom fields from surrounding frames
 +supplied as numbers by the hint file.
 +
 +@table @option
 +@item hint
 +Set file containing hints: absolute/relative frame numbers.
 +
 +There must be one line for each frame in a clip. Each line must contain two
 +numbers separated by the comma, optionally followed by @code{-} or @code{+}.
 +Numbers supplied on each line of file can not be out of [N-1,N+1] where N
 +is current frame number for @code{absolute} mode or out of [-1, 1] range
 +for @code{relative} mode. First number tells from which frame to pick up top
 +field and second number tells from which frame to pick up bottom field.
 +
 +If optionally followed by @code{+} output frame will be marked as interlaced,
 +else if followed by @code{-} output frame will be marked as progressive, else
 +it will be marked same as input frame.
 +If line starts with @code{#} or @code{;} that line is skipped.
 +
 +@item mode
 +Can be item @code{absolute} or @code{relative}. Default is @code{absolute}.
 +@end table
 +
 +Example of first several lines of @code{hint} file for @code{relative} mode:
 +@example
 +0,0 - # first frame
 +1,0 - # second frame, use third's frame top field and second's frame bottom field
 +1,0 - # third frame, use fourth's frame top field and third's frame bottom field
 +1,0 -
 +0,0 -
 +0,0 -
 +1,0 -
 +1,0 -
 +1,0 -
 +0,0 -
 +0,0 -
 +1,0 -
 +1,0 -
 +1,0 -
 +0,0 -
 +@end example
 +
 +@section fieldmatch
 +
 +Field matching filter for inverse telecine. It is meant to reconstruct the
 +progressive frames from a telecined stream. The filter does not drop duplicated
 +frames, so to achieve a complete inverse telecine @code{fieldmatch} needs to be
 +followed by a decimation filter such as @ref{decimate} in the filtergraph.
 +
 +The separation of the field matching and the decimation is notably motivated by
 +the possibility of inserting a de-interlacing filter fallback between the two.
 +If the source has mixed telecined and real interlaced content,
 +@code{fieldmatch} will not be able to match fields for the interlaced parts.
 +But these remaining combed frames will be marked as interlaced, and thus can be
 +de-interlaced by a later filter such as @ref{yadif} before decimation.
 +
 +In addition to the various configuration options, @code{fieldmatch} can take an
 +optional second stream, activated through the @option{ppsrc} option. If
 +enabled, the frames reconstruction will be based on the fields and frames from
 +this second stream. This allows the first input to be pre-processed in order to
 +help the various algorithms of the filter, while keeping the output lossless
 +(assuming the fields are matched properly). Typically, a field-aware denoiser,
 +or brightness/contrast adjustments can help.
 +
 +Note that this filter uses the same algorithms as TIVTC/TFM (AviSynth project)
 +and VIVTC/VFM (VapourSynth project). The later is a light clone of TFM from
 +which @code{fieldmatch} is based on. While the semantic and usage are very
 +close, some behaviour and options names can differ.
 +
 +The @ref{decimate} filter currently only works for constant frame rate input.
 +If your input has mixed telecined (30fps) and progressive content with a lower
 +framerate like 24fps use the following filterchain to produce the necessary cfr
 +stream: @code{dejudder,fps=30000/1001,fieldmatch,decimate}.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item order
 +Specify the assumed field order of the input stream. Available values are:
 +
 +@table @samp
 +@item auto
 +Auto detect parity (use FFmpeg's internal parity value).
 +@item bff
 +Assume bottom field first.
 +@item tff
 +Assume top field first.
 +@end table
 +
 +Note that it is sometimes recommended not to trust the parity announced by the
 +stream.
 +
 +Default value is @var{auto}.
 +
 +@item mode
 +Set the matching mode or strategy to use. @option{pc} mode is the safest in the
 +sense that it won't risk creating jerkiness due to duplicate frames when
 +possible, but if there are bad edits or blended fields it will end up
 +outputting combed frames when a good match might actually exist. On the other
 +hand, @option{pcn_ub} mode is the most risky in terms of creating jerkiness,
 +but will almost always find a good frame if there is one. The other values are
 +all somewhere in between @option{pc} and @option{pcn_ub} in terms of risking
 +jerkiness and creating duplicate frames versus finding good matches in sections
 +with bad edits, orphaned fields, blended fields, etc.
 +
 +More details about p/c/n/u/b are available in @ref{p/c/n/u/b meaning} section.
 +
 +Available values are:
 +
 +@table @samp
 +@item pc
 +2-way matching (p/c)
 +@item pc_n
 +2-way matching, and trying 3rd match if still combed (p/c + n)
 +@item pc_u
 +2-way matching, and trying 3rd match (same order) if still combed (p/c + u)
 +@item pc_n_ub
 +2-way matching, trying 3rd match if still combed, and trying 4th/5th matches if
 +still combed (p/c + n + u/b)
 +@item pcn
 +3-way matching (p/c/n)
 +@item pcn_ub
 +3-way matching, and trying 4th/5th matches if all 3 of the original matches are
 +detected as combed (p/c/n + u/b)
 +@end table
 +
 +The parenthesis at the end indicate the matches that would be used for that
 +mode assuming @option{order}=@var{tff} (and @option{field} on @var{auto} or
 +@var{top}).
 +
 +In terms of speed @option{pc} mode is by far the fastest and @option{pcn_ub} is
 +the slowest.
 +
 +Default value is @var{pc_n}.
 +
 +@item ppsrc
 +Mark the main input stream as a pre-processed input, and enable the secondary
 +input stream as the clean source to pick the fields from. See the filter
 +introduction for more details. It is similar to the @option{clip2} feature from
 +VFM/TFM.
 +
 +Default value is @code{0} (disabled).
 +
 +@item field
 +Set the field to match from. It is recommended to set this to the same value as
 +@option{order} unless you experience matching failures with that setting. In
 +certain circumstances changing the field that is used to match from can have a
 +large impact on matching performance. Available values are:
 +
 +@table @samp
 +@item auto
 +Automatic (same value as @option{order}).
 +@item bottom
 +Match from the bottom field.
 +@item top
 +Match from the top field.
 +@end table
 +
 +Default value is @var{auto}.
 +
 +@item mchroma
 +Set whether or not chroma is included during the match comparisons. In most
 +cases it is recommended to leave this enabled. You should set this to @code{0}
 +only if your clip has bad chroma problems such as heavy rainbowing or other
 +artifacts. Setting this to @code{0} could also be used to speed things up at
 +the cost of some accuracy.
 +
 +Default value is @code{1}.
 +
 +@item y0
 +@item y1
 +These define an exclusion band which excludes the lines between @option{y0} and
 +@option{y1} from being included in the field matching decision. An exclusion
 +band can be used to ignore subtitles, a logo, or other things that may
 +interfere with the matching. @option{y0} sets the starting scan line and
 +@option{y1} sets the ending line; all lines in between @option{y0} and
 +@option{y1} (including @option{y0} and @option{y1}) will be ignored. Setting
 +@option{y0} and @option{y1} to the same value will disable the feature.
 +@option{y0} and @option{y1} defaults to @code{0}.
 +
 +@item scthresh
 +Set the scene change detection threshold as a percentage of maximum change on
 +the luma plane. Good values are in the @code{[8.0, 14.0]} range. Scene change
 +detection is only relevant in case @option{combmatch}=@var{sc}.  The range for
 +@option{scthresh} is @code{[0.0, 100.0]}.
 +
 +Default value is @code{12.0}.
 +
 +@item combmatch
 +When @option{combatch} is not @var{none}, @code{fieldmatch} will take into
 +account the combed scores of matches when deciding what match to use as the
 +final match. Available values are:
 +
 +@table @samp
 +@item none
 +No final matching based on combed scores.
 +@item sc
 +Combed scores are only used when a scene change is detected.
 +@item full
 +Use combed scores all the time.
 +@end table
 +
 +Default is @var{sc}.
 +
 +@item combdbg
 +Force @code{fieldmatch} to calculate the combed metrics for certain matches and
 +print them. This setting is known as @option{micout} in TFM/VFM vocabulary.
 +Available values are:
 +
 +@table @samp
 +@item none
 +No forced calculation.
 +@item pcn
 +Force p/c/n calculations.
 +@item pcnub
 +Force p/c/n/u/b calculations.
 +@end table
 +
 +Default value is @var{none}.
 +
 +@item cthresh
 +This is the area combing threshold used for combed frame detection. This
 +essentially controls how "strong" or "visible" combing must be to be detected.
 +Larger values mean combing must be more visible and smaller values mean combing
 +can be less visible or strong and still be detected. Valid settings are from
 +@code{-1} (every pixel will be detected as combed) to @code{255} (no pixel will
 +be detected as combed). This is basically a pixel difference value. A good
 +range is @code{[8, 12]}.
 +
 +Default value is @code{9}.
 +
 +@item chroma
 +Sets whether or not chroma is considered in the combed frame decision.  Only
 +disable this if your source has chroma problems (rainbowing, etc.) that are
 +causing problems for the combed frame detection with chroma enabled. Actually,
 +using @option{chroma}=@var{0} is usually more reliable, except for the case
 +where there is chroma only combing in the source.
 +
 +Default value is @code{0}.
 +
 +@item blockx
 +@item blocky
 +Respectively set the x-axis and y-axis size of the window used during combed
 +frame detection. This has to do with the size of the area in which
 +@option{combpel} pixels are required to be detected as combed for a frame to be
 +declared combed. See the @option{combpel} parameter description for more info.
 +Possible values are any number that is a power of 2 starting at 4 and going up
 +to 512.
 +
 +Default value is @code{16}.
 +
 +@item combpel
 +The number of combed pixels inside any of the @option{blocky} by
 +@option{blockx} size blocks on the frame for the frame to be detected as
 +combed. While @option{cthresh} controls how "visible" the combing must be, this
 +setting controls "how much" combing there must be in any localized area (a
 +window defined by the @option{blockx} and @option{blocky} settings) on the
 +frame. Minimum value is @code{0} and maximum is @code{blocky x blockx} (at
 +which point no frames will ever be detected as combed). This setting is known
 +as @option{MI} in TFM/VFM vocabulary.
 +
 +Default value is @code{80}.
 +@end table
 +
 +@anchor{p/c/n/u/b meaning}
 +@subsection p/c/n/u/b meaning
 +
 +@subsubsection p/c/n
 +
 +We assume the following telecined stream:
 +
 +@example
 +Top fields:     1 2 2 3 4
 +Bottom fields:  1 2 3 4 4
 +@end example
 +
 +The numbers correspond to the progressive frame the fields relate to. Here, the
 +first two frames are progressive, the 3rd and 4th are combed, and so on.
 +
 +When @code{fieldmatch} is configured to run a matching from bottom
 +(@option{field}=@var{bottom}) this is how this input stream get transformed:
 +
 +@example
 +Input stream:
 +                T     1 2 2 3 4
 +                B     1 2 3 4 4   <-- matching reference
 +
 +Matches:              c c n n c
 +
 +Output stream:
 +                T     1 2 3 4 4
 +                B     1 2 3 4 4
 +@end example
 +
 +As a result of the field matching, we can see that some frames get duplicated.
 +To perform a complete inverse telecine, you need to rely on a decimation filter
 +after this operation. See for instance the @ref{decimate} filter.
 +
 +The same operation now matching from top fields (@option{field}=@var{top})
 +looks like this:
 +
 +@example
 +Input stream:
 +                T     1 2 2 3 4   <-- matching reference
 +                B     1 2 3 4 4
 +
 +Matches:              c c p p c
 +
 +Output stream:
 +                T     1 2 2 3 4
 +                B     1 2 2 3 4
 +@end example
 +
 +In these examples, we can see what @var{p}, @var{c} and @var{n} mean;
 +basically, they refer to the frame and field of the opposite parity:
 +
 +@itemize
 +@item @var{p} matches the field of the opposite parity in the previous frame
 +@item @var{c} matches the field of the opposite parity in the current frame
 +@item @var{n} matches the field of the opposite parity in the next frame
 +@end itemize
 +
 +@subsubsection u/b
 +
 +The @var{u} and @var{b} matching are a bit special in the sense that they match
 +from the opposite parity flag. In the following examples, we assume that we are
 +currently matching the 2nd frame (Top:2, bottom:2). According to the match, a
 +'x' is placed above and below each matched fields.
 +
 +With bottom matching (@option{field}=@var{bottom}):
 +@example
 +Match:           c         p           n          b          u
 +
 +                 x       x               x        x          x
 +  Top          1 2 2     1 2 2       1 2 2      1 2 2      1 2 2
 +  Bottom       1 2 3     1 2 3       1 2 3      1 2 3      1 2 3
 +                 x         x           x        x              x
 +
 +Output frames:
 +                 2          1          2          2          2
 +                 2          2          2          1          3
 +@end example
 +
 +With top matching (@option{field}=@var{top}):
 +@example
 +Match:           c         p           n          b          u
 +
 +                 x         x           x        x              x
 +  Top          1 2 2     1 2 2       1 2 2      1 2 2      1 2 2
 +  Bottom       1 2 3     1 2 3       1 2 3      1 2 3      1 2 3
 +                 x       x               x        x          x
 +
 +Output frames:
 +                 2          2          2          1          2
 +                 2          1          3          2          2
 +@end example
 +
 +@subsection Examples
 +
 +Simple IVTC of a top field first telecined stream:
 +@example
 +fieldmatch=order=tff:combmatch=none, decimate
 +@end example
 +
 +Advanced IVTC, with fallback on @ref{yadif} for still combed frames:
 +@example
 +fieldmatch=order=tff:combmatch=full, yadif=deint=interlaced, decimate
 +@end example
 +
 +@section fieldorder
 +
 +Transform the field order of the input video.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item order
 +The output field order. Valid values are @var{tff} for top field first or @var{bff}
 +for bottom field first.
 +@end table
 +
 +The default value is @samp{tff}.
 +
 +The transformation is done by shifting the picture content up or down
 +by one line, and filling the remaining line with appropriate picture content.
 +This method is consistent with most broadcast field order converters.
 +
 +If the input video is not flagged as being interlaced, or it is already
 +flagged as being of the required output field order, then this filter does
 +not alter the incoming video.
 +
 +It is very useful when converting to or from PAL DV material,
 +which is bottom field first.
 +
 +For example:
 +@example
 +ffmpeg -i in.vob -vf "fieldorder=bff" out.dv
 +@end example
 +
 +@section fifo, afifo
 +
 +Buffer input images and send them when they are requested.
 +
 +It is mainly useful when auto-inserted by the libavfilter
 +framework.
 +
 +It does not take parameters.
 +
 +@section find_rect
 +
 +Find a rectangular object
 +
 +It accepts the following options:
 +
 +@table @option
 +@item object
 +Filepath of the object image, needs to be in gray8.
 +
 +@item threshold
 +Detection threshold, default is 0.5.
 +
 +@item mipmaps
 +Number of mipmaps, default is 3.
 +
 +@item xmin, ymin, xmax, ymax
 +Specifies the rectangle in which to search.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Generate a representative palette of a given video using @command{ffmpeg}:
 +@example
 +ffmpeg -i file.ts -vf find_rect=newref.pgm,cover_rect=cover.jpg:mode=cover new.mkv
 +@end example
 +@end itemize
 +
 +@section cover_rect
 +
 +Cover a rectangular object
 +
 +It accepts the following options:
 +
 +@table @option
 +@item cover
 +Filepath of the optional cover image, needs to be in yuv420.
 +
 +@item mode
 +Set covering mode.
 +
 +It accepts the following values:
 +@table @samp
 +@item cover
 +cover it by the supplied image
 +@item blur
 +cover it by interpolating the surrounding pixels
 +@end table
 +
 +Default value is @var{blur}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Generate a representative palette of a given video using @command{ffmpeg}:
 +@example
 +ffmpeg -i file.ts -vf find_rect=newref.pgm,cover_rect=cover.jpg:mode=cover new.mkv
 +@end example
 +@end itemize
 +
 +@anchor{format}
 +@section format
 +
 +Convert the input video to one of the specified pixel formats.
 +Libavfilter will try to pick one that is suitable as input to
 +the next filter.
 +
 +It accepts the following parameters:
 +@table @option
 +
 +@item pix_fmts
 +A '|'-separated list of pixel format names, such as
 +"pix_fmts=yuv420p|monow|rgb24".
 +
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Convert the input video to the @var{yuv420p} format
 +@example
 +format=pix_fmts=yuv420p
 +@end example
 +
 +Convert the input video to any of the formats in the list
 +@example
 +format=pix_fmts=yuv420p|yuv444p|yuv410p
 +@end example
 +@end itemize
 +
 +@anchor{fps}
 +@section fps
 +
 +Convert the video to specified constant frame rate by duplicating or dropping
 +frames as necessary.
 +
 +It accepts the following parameters:
 +@table @option
 +
 +@item fps
 +The desired output frame rate. The default is @code{25}.
 +
 +@item round
 +Rounding method.
 +
 +Possible values are:
 +@table @option
 +@item zero
 +zero round towards 0
 +@item inf
 +round away from 0
 +@item down
 +round towards -infinity
 +@item up
 +round towards +infinity
 +@item near
 +round to nearest
 +@end table
 +The default is @code{near}.
 +
 +@item start_time
 +Assume the first PTS should be the given value, in seconds. This allows for
 +padding/trimming at the start of stream. By default, no assumption is made
 +about the first frame's expected PTS, so no padding or trimming is done.
 +For example, this could be set to 0 to pad the beginning with duplicates of
 +the first frame if a video stream starts after the audio stream or to trim any
 +frames with a negative PTS.
 +
 +@end table
 +
 +Alternatively, the options can be specified as a flat string:
 +@var{fps}[:@var{round}].
 +
 +See also the @ref{setpts} filter.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +A typical usage in order to set the fps to 25:
 +@example
 +fps=fps=25
 +@end example
 +
 +@item
 +Sets the fps to 24, using abbreviation and rounding method to round to nearest:
 +@example
 +fps=fps=film:round=near
 +@end example
 +@end itemize
 +
 +@section framepack
 +
 +Pack two different video streams into a stereoscopic video, setting proper
 +metadata on supported codecs. The two views should have the same size and
 +framerate and processing will stop when the shorter video ends. Please note
 +that you may conveniently adjust view properties with the @ref{scale} and
 +@ref{fps} filters.
 +
 +It accepts the following parameters:
 +@table @option
 +
 +@item format
 +The desired packing format. Supported values are:
 +
 +@table @option
 +
 +@item sbs
 +The views are next to each other (default).
 +
 +@item tab
 +The views are on top of each other.
 +
 +@item lines
 +The views are packed by line.
 +
 +@item columns
 +The views are packed by column.
 +
 +@item frameseq
 +The views are temporally interleaved.
 +
 +@end table
 +
 +@end table
 +
 +Some examples:
 +
 +@example
 +# Convert left and right views into a frame-sequential video
 +ffmpeg -i LEFT -i RIGHT -filter_complex framepack=frameseq OUTPUT
 +
 +# Convert views into a side-by-side video with the same output resolution as the input
 +ffmpeg -i LEFT -i RIGHT -filter_complex [0:v]scale=w=iw/2[left],[1:v]scale=w=iw/2[right],[left][right]framepack=sbs OUTPUT
 +@end example
 +
 +@section framerate
 +
 +Change the frame rate by interpolating new video output frames from the source
 +frames.
 +
 +This filter is not designed to function correctly with interlaced media. If
 +you wish to change the frame rate of interlaced media then you are required
 +to deinterlace before this filter and re-interlace after this filter.
 +
 +A description of the accepted options follows.
 +
 +@table @option
 +@item fps
 +Specify the output frames per second. This option can also be specified
 +as a value alone. The default is @code{50}.
 +
 +@item interp_start
 +Specify the start of a range where the output frame will be created as a
 +linear interpolation of two frames. The range is [@code{0}-@code{255}],
 +the default is @code{15}.
 +
 +@item interp_end
 +Specify the end of a range where the output frame will be created as a
 +linear interpolation of two frames. The range is [@code{0}-@code{255}],
 +the default is @code{240}.
 +
 +@item scene
 +Specify the level at which a scene change is detected as a value between
 +0 and 100 to indicate a new scene; a low value reflects a low
 +probability for the current frame to introduce a new scene, while a higher
 +value means the current frame is more likely to be one.
 +The default is @code{7}.
 +
 +@item flags
 +Specify flags influencing the filter process.
 +
 +Available value for @var{flags} is:
 +
 +@table @option
 +@item scene_change_detect, scd
 +Enable scene change detection using the value of the option @var{scene}.
 +This flag is enabled by default.
 +@end table
 +@end table
 +
 +@section framestep
 +
 +Select one frame every N-th frame.
 +
 +This filter accepts the following option:
 +@table @option
 +@item step
 +Select frame after every @code{step} frames.
 +Allowed values are positive integers higher than 0. Default value is @code{1}.
 +@end table
 +
 +@anchor{frei0r}
 +@section frei0r
 +
 +Apply a frei0r effect to the input video.
 +
 +To enable the compilation of this filter, you need to install the frei0r
 +header and configure FFmpeg with @code{--enable-frei0r}.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item filter_name
 +The name of the frei0r effect to load. If the environment variable
 +@env{FREI0R_PATH} is defined, the frei0r effect is searched for in each of the
 +directories specified by the colon-separated list in @env{FREIOR_PATH}.
 +Otherwise, the standard frei0r paths are searched, in this order:
 +@file{HOME/.frei0r-1/lib/}, @file{/usr/local/lib/frei0r-1/},
 +@file{/usr/lib/frei0r-1/}.
 +
 +@item filter_params
 +A '|'-separated list of parameters to pass to the frei0r effect.
 +
 +@end table
 +
 +A frei0r effect parameter can be a boolean (its value is either
 +"y" or "n"), a double, a color (specified as
 +@var{R}/@var{G}/@var{B}, where @var{R}, @var{G}, and @var{B} are floating point
 +numbers between 0.0 and 1.0, inclusive) or by a color description specified in the "Color"
 +section in the ffmpeg-utils manual), a position (specified as @var{X}/@var{Y}, where
 +@var{X} and @var{Y} are floating point numbers) and/or a string.
 +
 +The number and types of parameters depend on the loaded effect. If an
 +effect parameter is not specified, the default value is set.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply the distort0r effect, setting the first two double parameters:
 +@example
 +frei0r=filter_name=distort0r:filter_params=0.5|0.01
 +@end example
 +
 +@item
 +Apply the colordistance effect, taking a color as the first parameter:
 +@example
 +frei0r=colordistance:0.2/0.3/0.4
 +frei0r=colordistance:violet
 +frei0r=colordistance:0x112233
 +@end example
 +
 +@item
 +Apply the perspective effect, specifying the top left and top right image
 +positions:
 +@example
 +frei0r=perspective:0.2/0.2|0.8/0.2
 +@end example
 +@end itemize
 +
 +For more information, see
 +@url{http://frei0r.dyne.org}
 +
 +@section fspp
 +
 +Apply fast and simple postprocessing. It is a faster version of @ref{spp}.
 +
 +It splits (I)DCT into horizontal/vertical passes. Unlike the simple post-
 +processing filter, one of them is performed once per block, not per pixel.
 +This allows for much higher speed.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item quality
 +Set quality. This option defines the number of levels for averaging. It accepts
 +an integer in the range 4-5. Default value is @code{4}.
 +
 +@item qp
 +Force a constant quantization parameter. It accepts an integer in range 0-63.
 +If not set, the filter will use the QP from the video stream (if available).
 +
 +@item strength
 +Set filter strength. It accepts an integer in range -15 to 32. Lower values mean
 +more details but also more artifacts, while higher values make the image smoother
 +but also blurrier. Default value is @code{0} − PSNR optimal.
 +
 +@item use_bframe_qp
 +Enable the use of the QP from the B-Frames if set to @code{1}. Using this
 +option may cause flicker since the B-Frames have often larger QP. Default is
 +@code{0} (not enabled).
 +
 +@end table
 +
 +@section geq
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item lum_expr, lum
 +Set the luminance expression.
 +@item cb_expr, cb
 +Set the chrominance blue expression.
 +@item cr_expr, cr
 +Set the chrominance red expression.
 +@item alpha_expr, a
 +Set the alpha expression.
 +@item red_expr, r
 +Set the red expression.
 +@item green_expr, g
 +Set the green expression.
 +@item blue_expr, b
 +Set the blue expression.
 +@end table
 +
 +The colorspace is selected according to the specified options. If one
 +of the @option{lum_expr}, @option{cb_expr}, or @option{cr_expr}
 +options is specified, the filter will automatically select a YCbCr
 +colorspace. If one of the @option{red_expr}, @option{green_expr}, or
 +@option{blue_expr} options is specified, it will select an RGB
 +colorspace.
 +
 +If one of the chrominance expression is not defined, it falls back on the other
 +one. If no alpha expression is specified it will evaluate to opaque value.
 +If none of chrominance expressions are specified, they will evaluate
 +to the luminance expression.
 +
 +The expressions can use the following variables and functions:
 +
 +@table @option
 +@item N
 +The sequential number of the filtered frame, starting from @code{0}.
 +
 +@item X
 +@item Y
 +The coordinates of the current sample.
 +
 +@item W
 +@item H
 +The width and height of the image.
 +
 +@item SW
 +@item SH
 +Width and height scale depending on the currently filtered plane. It is the
 +ratio between the corresponding luma plane number of pixels and the current
 +plane ones. E.g. for YUV4:2:0 the values are @code{1,1} for the luma plane, and
 +@code{0.5,0.5} for chroma planes.
 +
 +@item T
 +Time of the current frame, expressed in seconds.
 +
 +@item p(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the current
 +plane.
 +
 +@item lum(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the luminance
 +plane.
 +
 +@item cb(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the
 +blue-difference chroma plane. Return 0 if there is no such plane.
 +
 +@item cr(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the
 +red-difference chroma plane. Return 0 if there is no such plane.
 +
 +@item r(x, y)
 +@item g(x, y)
 +@item b(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the
 +red/green/blue component. Return 0 if there is no such component.
 +
 +@item alpha(x, y)
 +Return the value of the pixel at location (@var{x},@var{y}) of the alpha
 +plane. Return 0 if there is no such plane.
 +@end table
 +
 +For functions, if @var{x} and @var{y} are outside the area, the value will be
 +automatically clipped to the closer edge.
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Flip the image horizontally:
 +@example
 +geq=p(W-X\,Y)
 +@end example
 +
 +@item
 +Generate a bidimensional sine wave, with angle @code{PI/3} and a
 +wavelength of 100 pixels:
 +@example
 +geq=128 + 100*sin(2*(PI/100)*(cos(PI/3)*(X-50*T) + sin(PI/3)*Y)):128:128
 +@end example
 +
 +@item
 +Generate a fancy enigmatic moving light:
 +@example
 +nullsrc=s=256x256,geq=random(1)/hypot(X-cos(N*0.07)*W/2-W/2\,Y-sin(N*0.09)*H/2-H/2)^2*1000000*sin(N*0.02):128:128
 +@end example
 +
 +@item
 +Generate a quick emboss effect:
 +@example
 +format=gray,geq=lum_expr='(p(X,Y)+(256-p(X-4,Y-4)))/2'
 +@end example
 +
 +@item
 +Modify RGB components depending on pixel position:
 +@example
 +geq=r='X/W*r(X,Y)':g='(1-X/W)*g(X,Y)':b='(H-Y)/H*b(X,Y)'
 +@end example
 +
 +@item
 +Create a radial gradient that is the same size as the input (also see
 +the @ref{vignette} filter):
 +@example
 +geq=lum=255*gauss((X/W-0.5)*3)*gauss((Y/H-0.5)*3)/gauss(0)/gauss(0),format=gray
 +@end example
 +@end itemize
 +
 +@section gradfun
 +
 +Fix the banding artifacts that are sometimes introduced into nearly flat
- regions by truncation to 8bit color depth.
++regions by truncation to 8-bit color depth.
 +Interpolate the gradients that should go where the bands are, and
 +dither them.
 +
 +It is designed for playback only.  Do not use it prior to
 +lossy compression, because compression tends to lose the dither and
 +bring back the bands.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +
 +@item strength
 +The maximum amount by which the filter will change any one pixel. This is also
 +the threshold for detecting nearly flat regions. Acceptable values range from
 +.51 to 64; the default value is 1.2. Out-of-range values will be clipped to the
 +valid range.
 +
 +@item radius
 +The neighborhood to fit the gradient to. A larger radius makes for smoother
 +gradients, but also prevents the filter from modifying the pixels near detailed
 +regions. Acceptable values are 8-32; the default value is 16. Out-of-range
 +values will be clipped to the valid range.
 +
 +@end table
 +
 +Alternatively, the options can be specified as a flat string:
 +@var{strength}[:@var{radius}]
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply the filter with a @code{3.5} strength and radius of @code{8}:
 +@example
 +gradfun=3.5:8
 +@end example
 +
 +@item
 +Specify radius, omitting the strength (which will fall-back to the default
 +value):
 +@example
 +gradfun=radius=8
 +@end example
 +
 +@end itemize
 +
 +@anchor{haldclut}
 +@section haldclut
 +
 +Apply a Hald CLUT to a video stream.
 +
 +First input is the video stream to process, and second one is the Hald CLUT.
 +The Hald CLUT input can be a simple picture or a complete video stream.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item shortest
 +Force termination when the shortest input terminates. Default is @code{0}.
 +@item repeatlast
 +Continue applying the last CLUT after the end of the stream. A value of
 +@code{0} disable the filter after the last frame of the CLUT is reached.
 +Default is @code{1}.
 +@end table
 +
 +@code{haldclut} also has the same interpolation options as @ref{lut3d} (both
 +filters share the same internals).
 +
 +More information about the Hald CLUT can be found on Eskil Steenberg's website
 +(Hald CLUT author) at @url{http://www.quelsolaar.com/technology/clut.html}.
 +
 +@subsection Workflow examples
 +
 +@subsubsection Hald CLUT video stream
 +
 +Generate an identity Hald CLUT stream altered with various effects:
 +@example
 +ffmpeg -f lavfi -i @ref{haldclutsrc}=8 -vf "hue=H=2*PI*t:s=sin(2*PI*t)+1, curves=cross_process" -t 10 -c:v ffv1 clut.nut
 +@end example
 +
 +Note: make sure you use a lossless codec.
 +
 +Then use it with @code{haldclut} to apply it on some random stream:
 +@example
 +ffmpeg -f lavfi -i mandelbrot -i clut.nut -filter_complex '[0][1] haldclut' -t 20 mandelclut.mkv
 +@end example
 +
 +The Hald CLUT will be applied to the 10 first seconds (duration of
 +@file{clut.nut}), then the latest picture of that CLUT stream will be applied
 +to the remaining frames of the @code{mandelbrot} stream.
 +
 +@subsubsection Hald CLUT with preview
 +
 +A Hald CLUT is supposed to be a squared image of @code{Level*Level*Level} by
 +@code{Level*Level*Level} pixels. For a given Hald CLUT, FFmpeg will select the
 +biggest possible square starting at the top left of the picture. The remaining
 +padding pixels (bottom or right) will be ignored. This area can be used to add
 +a preview of the Hald CLUT.
 +
 +Typically, the following generated Hald CLUT will be supported by the
 +@code{haldclut} filter:
 +
 +@example
 +ffmpeg -f lavfi -i @ref{haldclutsrc}=8 -vf "
 +   pad=iw+320 [padded_clut];
 +   smptebars=s=320x256, split [a][b];
 +   [padded_clut][a] overlay=W-320:h, curves=color_negative [main];
 +   [main][b] overlay=W-320" -frames:v 1 clut.png
 +@end example
 +
 +It contains the original and a preview of the effect of the CLUT: SMPTE color
 +bars are displayed on the right-top, and below the same color bars processed by
 +the color changes.
 +
 +Then, the effect of this Hald CLUT can be visualized with:
 +@example
 +ffplay input.mkv -vf "movie=clut.png, [in] haldclut"
 +@end example
 +
 +@section hdcd
 +
 +Decodes high definition audio cd data. 16-Bit PCM stream containing hdcd flags
 +is converted to 20-bit PCM stream.
 +
 +@section hflip
 +
 +Flip the input video horizontally.
 +
 +For example, to horizontally flip the input video with @command{ffmpeg}:
 +@example
 +ffmpeg -i in.avi -vf "hflip" out.avi
 +@end example
 +
 +@section histeq
 +This filter applies a global color histogram equalization on a
 +per-frame basis.
 +
 +It can be used to correct video that has a compressed range of pixel
 +intensities.  The filter redistributes the pixel intensities to
 +equalize their distribution across the intensity range. It may be
 +viewed as an "automatically adjusting contrast filter". This filter is
 +useful only for correcting degraded or poorly captured source
 +video.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item strength
 +Determine the amount of equalization to be applied.  As the strength
 +is reduced, the distribution of pixel intensities more-and-more
 +approaches that of the input frame. The value must be a float number
 +in the range [0,1] and defaults to 0.200.
 +
 +@item intensity
 +Set the maximum intensity that can generated and scale the output
 +values appropriately.  The strength should be set as desired and then
 +the intensity can be limited if needed to avoid washing-out. The value
 +must be a float number in the range [0,1] and defaults to 0.210.
 +
 +@item antibanding
 +Set the antibanding level. If enabled the filter will randomly vary
 +the luminance of output pixels by a small amount to avoid banding of
 +the histogram. Possible values are @code{none}, @code{weak} or
 +@code{strong}. It defaults to @code{none}.
 +@end table
 +
 +@section histogram
 +
 +Compute and draw a color distribution histogram for the input video.
 +
 +The computed histogram is a representation of the color component
 +distribution in an image.
 +
 +Standard histogram displays the color components distribution in an image.
 +Displays color graph for each color component. Shows distribution of
 +the Y, U, V, A or R, G, B components, depending on input format, in the
 +current frame. Below each graph a color component scale meter is shown.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item level_height
 +Set height of level. Default value is @code{200}.
 +Allowed range is [50, 2048].
 +
 +@item scale_height
 +Set height of color scale. Default value is @code{12}.
 +Allowed range is [0, 40].
 +
 +@item display_mode
 +Set display mode.
 +It accepts the following values:
 +@table @samp
 +@item parade
 +Per color component graphs are placed below each other.
 +
 +@item overlay
 +Presents information identical to that in the @code{parade}, except
 +that the graphs representing color components are superimposed directly
 +over one another.
 +@end table
 +Default is @code{parade}.
 +
 +@item levels_mode
 +Set mode. Can be either @code{linear}, or @code{logarithmic}.
 +Default is @code{linear}.
 +
 +@item components
 +Set what color components to display.
 +Default is @code{7}.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +
 +@item
 +Calculate and draw histogram:
 +@example
 +ffplay -i input -vf histogram
 +@end example
 +
 +@end itemize
 +
 +@anchor{hqdn3d}
 +@section hqdn3d
 +
 +This is a high precision/quality 3d denoise filter. It aims to reduce
 +image noise, producing smooth images and making still images really
 +still. It should enhance compressibility.
 +
 +It accepts the following optional parameters:
 +
 +@table @option
 +@item luma_spatial
 +A non-negative floating point number which specifies spatial luma strength.
 +It defaults to 4.0.
 +
 +@item chroma_spatial
 +A non-negative floating point number which specifies spatial chroma strength.
 +It defaults to 3.0*@var{luma_spatial}/4.0.
 +
 +@item luma_tmp
 +A floating point number which specifies luma temporal strength. It defaults to
 +6.0*@var{luma_spatial}/4.0.
 +
 +@item chroma_tmp
 +A floating point number which specifies chroma temporal strength. It defaults to
 +@var{luma_tmp}*@var{chroma_spatial}/@var{luma_spatial}.
 +@end table
 +
 +@anchor{hwupload_cuda}
 +@section hwupload_cuda
 +
 +Upload system memory frames to a CUDA device.
 +
 +It accepts the following optional parameters:
 +
 +@table @option
 +@item device
 +The number of the CUDA device to use
 +@end table
 +
 +@section hqx
 +
 +Apply a high-quality magnification filter designed for pixel art. This filter
 +was originally created by Maxim Stepin.
 +
 +It accepts the following option:
 +
 +@table @option
 +@item n
 +Set the scaling dimension: @code{2} for @code{hq2x}, @code{3} for
 +@code{hq3x} and @code{4} for @code{hq4x}.
 +Default is @code{3}.
 +@end table
 +
 +@section hstack
 +Stack input videos horizontally.
 +
 +All streams must be of same pixel format and of same height.
 +
 +Note that this filter is faster than using @ref{overlay} and @ref{pad} filter
 +to create same output.
 +
 +The filter accept the following option:
 +
 +@table @option
 +@item inputs
 +Set number of input streams. Default is 2.
 +
 +@item shortest
 +If set to 1, force the output to terminate when the shortest input
 +terminates. Default value is 0.
 +@end table
 +
 +@section hue
 +
 +Modify the hue and/or the saturation of the input.
 +
 +It accepts the following parameters:
 +
 +@table @option
 +@item h
 +Specify the hue angle as a number of degrees. It accepts an expression,
 +and defaults to "0".
 +
 +@item s
 +Specify the saturation in the [-10,10] range. It accepts an expression and
 +defaults to "1".
 +
 +@item H
 +Specify the hue angle as a number of radians. It accepts an
 +expression, and defaults to "0".
 +
 +@item b
 +Specify the brightness in the [-10,10] range. It accepts an expression and
 +defaults to "0".
 +@end table
 +
 +@option{h} and @option{H} are mutually exclusive, and can't be
 +specified at the same time.
 +
 +The @option{b}, @option{h}, @option{H} and @option{s} option values are
 +expressions containing the following constants:
 +
 +@table @option
 +@item n
 +frame count of the input frame starting from 0
 +
 +@item pts
 +presentation timestamp of the input frame expressed in time base units
 +
 +@item r
 +frame rate of the input video, NAN if the input frame rate is unknown
 +
 +@item t
 +timestamp expressed in seconds, NAN if the input timestamp is unknown
 +
 +@item tb
 +time base of the input video
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Set the hue to 90 degrees and the saturation to 1.0:
 +@example
 +hue=h=90:s=1
 +@end example
 +
 +@item
 +Same command but expressing the hue in radians:
 +@example
 +hue=H=PI/2:s=1
 +@end example
 +
 +@item
 +Rotate hue and make the saturation swing between 0
 +and 2 over a period of 1 second:
 +@example
 +hue="H=2*PI*t: s=sin(2*PI*t)+1"
 +@end example
 +
 +@item
 +Apply a 3 seconds saturation fade-in effect starting at 0:
 +@example
 +hue="s=min(t/3\,1)"
 +@end example
 +
 +The general fade-in expression can be written as:
 +@example
 +hue="s=min(0\, max((t-START)/DURATION\, 1))"
 +@end example
 +
 +@item
 +Apply a 3 seconds saturation fade-out effect starting at 5 seconds:
 +@example
 +hue="s=max(0\, min(1\, (8-t)/3))"
 +@end example
 +
 +The general fade-out expression can be written as:
 +@example
 +hue="s=max(0\, min(1\, (START+DURATION-t)/DURATION))"
 +@end example
 +
 +@end itemize
 +
 +@subsection Commands
 +
 +This filter supports the following commands:
 +@table @option
 +@item b
 +@item s
 +@item h
 +@item H
 +Modify the hue and/or the saturation and/or brightness of the input video.
 +The command accepts the same syntax of the corresponding option.
 +
 +If the specified expression is not valid, it is kept at its current
 +value.
 +@end table
 +
 +@section idet
 +
 +Detect video interlacing type.
 +
 +This filter tries to detect if the input frames as interlaced, progressive,
 +top or bottom field first. It will also try and detect fields that are
 +repeated between adjacent frames (a sign of telecine).
 +
 +Single frame detection considers only immediately adjacent frames when classifying each frame.
 +Multiple frame detection incorporates the classification history of previous frames.
 +
 +The filter will log these metadata values:
 +
 +@table @option
 +@item single.current_frame
 +Detected type of current frame using single-frame detection. One of:
 +``tff'' (top field first), ``bff'' (bottom field first),
 +``progressive'', or ``undetermined''
 +
 +@item single.tff
 +Cumulative number of frames detected as top field first using single-frame detection.
 +
 +@item multiple.tff
 +Cumulative number of frames detected as top field first using multiple-frame detection.
 +
 +@item single.bff
 +Cumulative number of frames detected as bottom field first using single-frame detection.
 +
 +@item multiple.current_frame
 +Detected type of current frame using multiple-frame detection. One of:
 +``tff'' (top field first), ``bff'' (bottom field first),
 +``progressive'', or ``undetermined''
 +
 +@item multiple.bff
 +Cumulative number of frames detected as bottom field first using multiple-frame detection.
 +
 +@item single.progressive
 +Cumulative number of frames detected as progressive using single-frame detection.
 +
 +@item multiple.progressive
 +Cumulative number of frames detected as progressive using multiple-frame detection.
 +
 +@item single.undetermined
 +Cumulative number of frames that could not be classified using single-frame detection.
 +
 +@item multiple.undetermined
 +Cumulative number of frames that could not be classified using multiple-frame detection.
 +
 +@item repeated.current_frame
 +Which field in the current frame is repeated from the last. One of ``neither'', ``top'', or ``bottom''.
 +
 +@item repeated.neither
 +Cumulative number of frames with no repeated field.
 +
 +@item repeated.top
 +Cumulative number of frames with the top field repeated from the previous frame's top field.
 +
 +@item repeated.bottom
 +Cumulative number of frames with the bottom field repeated from the previous frame's bottom field.
 +@end table
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item intl_thres
 +Set interlacing threshold.
 +@item prog_thres
 +Set progressive threshold.
 +@item rep_thres
 +Threshold for repeated field detection.
 +@item half_life
 +Number of frames after which a given frame's contribution to the
 +statistics is halved (i.e., it contributes only 0.5 to it's
 +classification). The default of 0 means that all frames seen are given
 +full weight of 1.0 forever.
 +@item analyze_interlaced_flag
 +When this is not 0 then idet will use the specified number of frames to determine
 +if the interlaced flag is accurate, it will not count undetermined frames.
 +If the flag is found to be accurate it will be used without any further
 +computations, if it is found to be inaccurate it will be cleared without any
 +further computations. This allows inserting the idet filter as a low computational
 +method to clean up the interlaced flag
 +@end table
 +
 +@section il
 +
 +Deinterleave or interleave fields.
 +
 +This filter allows one to process interlaced images fields without
 +deinterlacing them. Deinterleaving splits the input frame into 2
 +fields (so called half pictures). Odd lines are moved to the top
 +half of the output image, even lines to the bottom half.
 +You can process (filter) them independently and then re-interleave them.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item luma_mode, l
 +@item chroma_mode, c
 +@item alpha_mode, a
 +Available values for @var{luma_mode}, @var{chroma_mode} and
 +@var{alpha_mode} are:
 +
 +@table @samp
 +@item none
 +Do nothing.
 +
 +@item deinterleave, d
 +Deinterleave fields, placing one above the other.
 +
 +@item interleave, i
 +Interleave fields. Reverse the effect of deinterleaving.
 +@end table
 +Default value is @code{none}.
 +
 +@item luma_swap, ls
 +@item chroma_swap, cs
 +@item alpha_swap, as
 +Swap luma/chroma/alpha fields. Exchange even & odd lines. Default value is @code{0}.
 +@end table
 +
 +@section inflate
 +
 +Apply inflate effect to the video.
 +
 +This filter replaces the pixel by the local(3x3) average by taking into account
 +only values higher than the pixel.
 +
 +It accepts the following options:
 +
 +@table @option
 +@item threshold0
 +@item threshold1
 +@item threshold2
 +@item threshold3
 +Limit the maximum change for each plane, default is 65535.
 +If 0, plane will remain unchanged.
 +@end table
 +
 +@section interlace
 +
 +Simple interlacing filter from progressive contents. This interleaves upper (or
 +lower) lines from odd frames with lower (or upper) lines from even frames,
 +halving the frame rate and preserving image height.
 +
 +@example
 +   Original        Original             New Frame
 +   Frame 'j'      Frame 'j+1'             (tff)
 +  ==========      ===========       ==================
 +    Line 0  -------------------->    Frame 'j' Line 0
 +    Line 1          Line 1  ---->   Frame 'j+1' Line 1
 +    Line 2 --------------------->    Frame 'j' Line 2
 +    Line 3          Line 3  ---->   Frame 'j+1' Line 3
 +     ...             ...                   ...
 +New Frame + 1 will be generated by Frame 'j+2' and Frame 'j+3' and so on
 +@end example
 +
 +It accepts the following optional parameters:
 +
 +@table @option
 +@item scan
 +This determines whether the interlaced frame is taken from the even
 +(tff - default) or odd (bff) lines of the progressive frame.
 +
 +@item lowpass
 +Enable (default) or disable the vertical lowpass filter to avoid twitter
 +interlacing and reduce moire patterns.
 +@end table
 +
 +@section kerndeint
 +
 +Deinterlace input video by applying Donald Graft's adaptive kernel
 +deinterling. Work on interlaced parts of a video to produce
 +progressive frames.
 +
 +The description of the accepted parameters follows.
 +
 +@table @option
 +@item thresh
 +Set the threshold which affects the filter's tolerance when
 +determining if a pixel line must be processed. It must be an integer
 +in the range [0,255] and defaults to 10. A value of 0 will result in
 +applying the process on every pixels.
 +
 +@item map
 +Paint pixels exceeding the threshold value to white if set to 1.
 +Default is 0.
 +
 +@item order
 +Set the fields order. Swap fields if set to 1, leave fields alone if
 +0. Default is 0.
 +
 +@item sharp
 +Enable additional sharpening if set to 1. Default is 0.
 +
 +@item twoway
 +Enable twoway sharpening if set to 1. Default is 0.
 +@end table
 +
 +@subsection Examples
 +
 +@itemize
 +@item
 +Apply default values:
 +@example
 +kerndeint=thresh=10:map=0:order=0:sharp=0:twoway=0
 +@end example
 +
 +@item
 +Enable additional sharpening:
 +@example
 +kerndeint=sharp=1
 +@end example
 +
 +@item
 +Paint processed pixels in white:
 +@example
 +kerndeint=map=1
 +@end example
 +@end itemize
 +
 +@section lenscorrection
 +
 +Correct radial lens distortion
 +
 +This filter can be used to correct for radial distortion as can result from the use
 +of wide angle lenses, and thereby re-rectify the image. To find the right parameters
 +one can use tools available for example as part of opencv or simply trial-and-error.
 +To use opencv use the calibration sample (under samples/cpp) from the opencv sources
 +and extract the k1 and k2 coefficients from the resulting matrix.
 +
 +Note that effectively the same filter is available in the open-source tools Krita and
 +Digikam from the KDE project.
 +
 +In contrast to the @ref{vignette} filter, which can also be used to compensate lens errors,
 +this filter corrects the distortion of the image, whereas @ref{vignette} corrects the
 +brightness distribution, so you may want to use both filters together in certain
 +cases, though you will have to take care of ordering, i.e. whether vignetting should
 +be applied before or after lens correction.
 +
 +@subsection Options
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item cx
 +Relative x-coordinate of the focal point of the image, and thereby the center of the
 +distortion. This value has a range [0,1] and is expressed as fractions of the image
 +width.
 +@item cy
 +Relative y-coordinate of the focal point of the image, and thereby the center of the
 +distortion. This value has a range [0,1] and is expressed as fractions of the image
 +height.
 +@item k1
 +Coefficient of the quadratic correction term. 0.5 means no correction.
 +@item k2
 +Coefficient of the double quadratic correction term. 0.5 means no correction.
 +@end table
 +
 +The formula that generates the correction is:
 +
 +@var{r_src} = @var{r_tgt} * (1 + @var{k1} * (@var{r_tgt} / @var{r_0})^2 + @var{k2} * (@var{r_tgt} / @var{r_0})^4)
 +
 +where @var{r_0} is halve of the image diagonal and @var{r_src} and @var{r_tgt} are the
 +distances from the focal point in the source and target images, respectively.
 +
 +@section loop, aloop
 +
 +Loop video frames or audio samples.
 +
 +Those filters accepts the following options:
 +
 +@table @option
 +@item loop
 +Set the number of loops.
 +
 +@item size
 +Set maximal size in number of frames for @code{loop} filter or maximal number
 +of samples in case of @code{aloop} filter.
 +
 +@item start
 +Set first frame of loop for @code{loop} filter or first sample of loop in case
 +of @code{aloop} filter.
 +@end table
 +
 +@anchor{lut3d}
 +@section lut3d
 +
 +Apply a 3D LUT to an input video.
 +
 +The filter accepts the following options:
 +
 +@table @option
 +@item file
 +Set the 3D LUT file name.
 +
 +Currently supported formats:
 +@table @samp
 +@item 3dl
 +AfterEffects
 +@item cube
 +Iridas
 +@item dat
 +DaVinci
 +@item m3d
 +Pandora
 +@end table
 +@item interp
 +Select interpolation mode.
 +
 +Available values are:
 +
 +@table @samp
 +@item nearest
 +Use values from the nearest defined point.
 +@item trilinear
 +Interpolate values using the 8 points defining a cube.
 +@item tetrahedral
 +Interpolate values using a tetrahedron.
 +@end table
 +@end table
 +
 +@section lut, lutrgb, lutyuv
 +
 +Compute a look-up table for binding each pixel component input value
 +to an output value, and apply it to the input video.
 +
 +@var{lutyuv} applies a lookup table to a YUV input video, @var{lutrgb}
 +to an RGB input video.
 +
 +These filters accept the following parameters:
 +@table @option
 +@item c0
 +set first pixel component expression
 +@item c1
 +set second pixel component expression
 +@item c2
 +set third pixel component expression
 +@item c3
 +set fourth pixel component expression, corresponds to the alpha component
 +
 +@item r
 +set red component expression
 +@item g
 +set green component expression
 +@item b
 +set blue component expression
 +@item a
 +alpha component expression
 +
 +@item y
 +set Y/luminance component expression
 +@item u
 +set U/Cb component expression
 +@item v
 +set V/Cr component expression
 +@end table
 +
 +Each of them specifies the expression to use for computing the lookup table for
 +the corresponding pixel component values.
 +
 +The exact component associated to each of the @var{c*} options depends on the
 +format in input.
 +
 +The @var{lut} filter requires either YUV or RGB pixel formats in input,
 +@var{lutrgb} requires RGB pixel formats in input, and @var{lutyuv} requires YUV.
 +
 +The expressions can contain the following constants and functions:
 +
 +@table @option
 +@item w
 +@item h
 +The input width and height.
 +
 +@item val
 +The input value for the pixel component.
 +
 +@item clipval
 +The input value, clipped to the @var{minval}-@var{maxval} range.
 +
 +@item maxval
 +The maximum value for the pixel component.
 +
 +@item minval
 +The minimum value for the&n