Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Sat, 25 Feb 2012 03:00:43 +0000 (04:00 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Sat, 25 Feb 2012 03:00:43 +0000 (04:00 +0100)
* qatar/master:
  docs: use -bsf:[vas] instead of -[vas]bsf.
  mpegaudiodec: Prevent premature clipping of mp3 input buffer.
  lavf: move the packet keyframe setting code.
  oggenc: free comment header for all codecs
  lcl: error out if uncompressed input buffer is smaller than framesize.
  mjpeg: abort decoding if packet is too large.
  golomb: use HAVE_BITS_REMAINING() macro to prevent infloop on EOF.
  get_bits: add HAVE_BITS_REMAINING macro.
  lavf/output-example: use new audio encoding API correctly.
  lavf/output-example: more proper usage of the new API.
  tiff: Prevent overreads in the type_sizes array.
  tiff: Make the TIFF_LONG and TIFF_SHORT types unsigned.
  apetag: do not leak memory if avio_read() fails
  apetag: propagate errors.
  SBR DSP x86: implement SSE sbr_hf_g_filt
  SBR DSP x86: implement SSE sbr_sum_square_sse
  SBR DSP: use intptr_t for the ixh parameter.

Conflicts:
doc/bitstream_filters.texi
doc/examples/muxing.c
doc/ffmpeg.texi
libavcodec/golomb.h
libavcodec/x86/Makefile
libavformat/oggenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
13 files changed:
1  2 
doc/bitstream_filters.texi
doc/examples/muxing.c
doc/ffmpeg.texi
libavcodec/get_bits.h
libavcodec/golomb.h
libavcodec/lcldec.c
libavcodec/mjpegdec.c
libavcodec/mpegaudiodec.c
libavcodec/tiff.c
libavcodec/x86/Makefile
libavformat/apetag.c
libavformat/oggenc.c
libavformat/utils.c

@@@ -71,9 -57,9 +71,9 @@@ stream (carrying the AVI1 header ID an
  produce fully qualified JPEG images.
  
  @example
- ffmpeg -i mjpeg-movie.avi -c:v copy -vbsf mjpeg2jpeg frame_%d.jpg
 -avconv -i mjpeg-movie.avi -c:v copy -bsf:v mjpeg2jpeg frame_%d.jpg
++ffmpeg -i mjpeg-movie.avi -c:v copy -bsf:v mjpeg2jpeg frame_%d.jpg
  exiftran -i -9 frame*.jpg
 -avconv -i frame_%d.jpg -c:v copy rotated.avi
 +ffmpeg -i frame_%d.jpg -c:v copy rotated.avi
  @end example
  
  @section mjpega_dump_header
index 8070ea4,0000000..5e2bf9f
mode 100644,000000..100644
--- /dev/null
@@@ -1,556 -1,0 +1,539 @@@
- static uint8_t *audio_outbuf;
- static int audio_outbuf_size;
 +/*
 + * 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.
 + */
 +
 +#include <stdlib.h>
 +#include <stdio.h>
 +#include <string.h>
 +#include <math.h>
 +
 +#include "libavutil/mathematics.h"
 +#include "libavformat/avformat.h"
 +#include "libswscale/swscale.h"
 +
 +#undef exit
 +
 +/* 5 seconds stream duration */
 +#define STREAM_DURATION   200.0
 +#define STREAM_FRAME_RATE 25 /* 25 images/s */
 +#define STREAM_NB_FRAMES  ((int)(STREAM_DURATION * STREAM_FRAME_RATE))
 +#define STREAM_PIX_FMT PIX_FMT_YUV420P /* default pix_fmt */
 +
 +static int sws_flags = SWS_BICUBIC;
 +
 +/**************************************************************/
 +/* audio output */
 +
 +static float t, tincr, tincr2;
 +static int16_t *samples;
-     st = avformat_new_stream(oc, NULL);
 +static int audio_input_frame_size;
 +
 +/*
 + * add an audio output stream
 + */
 +static AVStream *add_audio_stream(AVFormatContext *oc, enum CodecID codec_id)
 +{
 +    AVCodecContext *c;
 +    AVStream *st;
++    AVCodec *codec;
 +
-     c->codec_id = codec_id;
-     c->codec_type = AVMEDIA_TYPE_AUDIO;
++    /* find the audio encoder */
++    codec = avcodec_find_encoder(codec_id);
++    if (!codec) {
++        fprintf(stderr, "codec not found\n");
++        exit(1);
++    }
++
++    st = avformat_new_stream(oc, codec);
 +    if (!st) {
 +        fprintf(stderr, "Could not alloc stream\n");
 +        exit(1);
 +    }
 +    st->id = 1;
 +
 +    c = st->codec;
-     AVCodec *codec;
 +
 +    /* put sample parameters */
 +    c->sample_fmt = AV_SAMPLE_FMT_S16;
 +    c->bit_rate = 64000;
 +    c->sample_rate = 44100;
 +    c->channels = 2;
 +
 +    // some formats want stream headers to be separate
 +    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 +        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
 +
 +    return st;
 +}
 +
 +static void open_audio(AVFormatContext *oc, AVStream *st)
 +{
 +    AVCodecContext *c;
-     /* find the audio encoder */
-     codec = avcodec_find_encoder(c->codec_id);
-     if (!codec) {
-         fprintf(stderr, "codec not found\n");
-         exit(1);
-     }
 +
 +    c = st->codec;
 +
-     if (avcodec_open2(c, codec, NULL) < 0) {
 +    /* open it */
-     audio_outbuf_size = 10000;
-     audio_outbuf = av_malloc(audio_outbuf_size);
-     /* ugly hack for PCM codecs (will be removed ASAP with new PCM
-        support to compute the input frame size in samples */
-     if (c->frame_size <= 1) {
-         audio_input_frame_size = audio_outbuf_size / c->channels;
-         switch(st->codec->codec_id) {
-         case CODEC_ID_PCM_S16LE:
-         case CODEC_ID_PCM_S16BE:
-         case CODEC_ID_PCM_U16LE:
-         case CODEC_ID_PCM_U16BE:
-             audio_input_frame_size >>= 1;
-             break;
-         default:
-             break;
-         }
-     } else {
++    if (avcodec_open2(c, NULL, NULL) < 0) {
 +        fprintf(stderr, "could not open codec\n");
 +        exit(1);
 +    }
 +
 +    /* init signal generator */
 +    t = 0;
 +    tincr = 2 * M_PI * 110.0 / c->sample_rate;
 +    /* increment frequency by 110 Hz per second */
 +    tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;
 +
-     }
-     samples = av_malloc(audio_input_frame_size * 2 * c->channels);
++    if (c->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)
++        audio_input_frame_size = 10000;
++    else
 +        audio_input_frame_size = c->frame_size;
-     av_init_packet(&pkt);
++    samples = av_malloc(audio_input_frame_size * av_get_bytes_per_sample(c->sample_fmt)
++                        * c->channels);
 +}
 +
 +/* prepare a 16 bit dummy audio frame of 'frame_size' samples and
 +   'nb_channels' channels */
 +static void get_audio_frame(int16_t *samples, int frame_size, int nb_channels)
 +{
 +    int j, i, v;
 +    int16_t *q;
 +
 +    q = samples;
 +    for (j = 0; j < frame_size; j++) {
 +        v = (int)(sin(t) * 10000);
 +        for(i = 0; i < nb_channels; i++)
 +            *q++ = v;
 +        t += tincr;
 +        tincr += tincr2;
 +    }
 +}
 +
 +static void write_audio_frame(AVFormatContext *oc, AVStream *st)
 +{
 +    AVCodecContext *c;
 +    AVPacket pkt;
-     pkt.size = avcodec_encode_audio2(c, audio_outbuf, audio_outbuf_size, samples);
++    AVFrame *frame = avcodec_alloc_frame();
++    int got_packet;
 +
++    av_init_packet(&pkt);
 +    c = st->codec;
 +
 +    get_audio_frame(samples, audio_input_frame_size, c->channels);
++    frame->nb_samples = audio_input_frame_size;
++    avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt, (uint8_t *)samples,
++                             audio_input_frame_size * av_get_bytes_per_sample(c->sample_fmt)
++                             * c->channels, 1);
 +
-     if (c->coded_frame && c->coded_frame->pts != AV_NOPTS_VALUE)
-         pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
-     pkt.flags |= AV_PKT_FLAG_KEY;
-     pkt.stream_index = st->index;
-     pkt.data = audio_outbuf;
++    avcodec_encode_audio2(c, &pkt, frame, &got_packet);
++    if (!got_packet)
++        return;
 +
-     av_free(audio_outbuf);
++    pkt.stream_index= st->index;
 +
 +    /* write the compressed frame in the media file */
 +    if (av_interleaved_write_frame(oc, &pkt) != 0) {
 +        fprintf(stderr, "Error while writing audio frame\n");
 +        exit(1);
 +    }
 +}
 +
 +static void close_audio(AVFormatContext *oc, AVStream *st)
 +{
 +    avcodec_close(st->codec);
 +
 +    av_free(samples);
-     st = avformat_new_stream(oc, NULL);
 +}
 +
 +/**************************************************************/
 +/* video output */
 +
 +static AVFrame *picture, *tmp_picture;
 +static uint8_t *video_outbuf;
 +static int frame_count, video_outbuf_size;
 +
 +/* add a video output stream */
 +static AVStream *add_video_stream(AVFormatContext *oc, enum CodecID codec_id)
 +{
 +    AVCodecContext *c;
 +    AVStream *st;
 +    AVCodec *codec;
 +
-     AVCodec *codec;
++    /* find the video encoder */
++    codec = avcodec_find_encoder(codec_id);
++    if (!codec) {
++        fprintf(stderr, "codec not found\n");
++        exit(1);
++    }
++
++    st = avformat_new_stream(oc, codec);
 +    if (!st) {
 +        fprintf(stderr, "Could not alloc stream\n");
 +        exit(1);
 +    }
 +
 +    c = st->codec;
 +
 +    /* find the video encoder */
 +    codec = avcodec_find_encoder(codec_id);
 +    if (!codec) {
 +        fprintf(stderr, "codec not found\n");
 +        exit(1);
 +    }
 +    avcodec_get_context_defaults3(c, codec);
 +
 +    c->codec_id = codec_id;
 +
 +    /* put sample parameters */
 +    c->bit_rate = 400000;
 +    /* resolution must be a multiple of two */
 +    c->width = 352;
 +    c->height = 288;
 +    /* time base: 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
 +       identically 1. */
 +    c->time_base.den = STREAM_FRAME_RATE;
 +    c->time_base.num = 1;
 +    c->gop_size = 12; /* emit one intra frame every twelve frames at most */
 +    c->pix_fmt = STREAM_PIX_FMT;
 +    if (c->codec_id == CODEC_ID_MPEG2VIDEO) {
 +        /* just for testing, we also add B frames */
 +        c->max_b_frames = 2;
 +    }
 +    if (c->codec_id == 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;
 +    }
 +    // some formats want stream headers to be separate
 +    if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 +        c->flags |= CODEC_FLAG_GLOBAL_HEADER;
 +
 +    return st;
 +}
 +
 +static AVFrame *alloc_picture(enum PixelFormat pix_fmt, int width, int height)
 +{
 +    AVFrame *picture;
 +    uint8_t *picture_buf;
 +    int size;
 +
 +    picture = avcodec_alloc_frame();
 +    if (!picture)
 +        return NULL;
 +    size = avpicture_get_size(pix_fmt, width, height);
 +    picture_buf = av_malloc(size);
 +    if (!picture_buf) {
 +        av_free(picture);
 +        return NULL;
 +    }
 +    avpicture_fill((AVPicture *)picture, picture_buf,
 +                   pix_fmt, width, height);
 +    return picture;
 +}
 +
 +static void open_video(AVFormatContext *oc, AVStream *st)
 +{
-     /* find the video encoder */
-     codec = avcodec_find_encoder(c->codec_id);
-     if (!codec) {
-         fprintf(stderr, "codec not found\n");
-         exit(1);
-     }
 +    AVCodecContext *c;
 +
 +    c = st->codec;
 +
-     if (avcodec_open2(c, codec, NULL) < 0) {
 +    /* open the codec */
++    if (avcodec_open2(c, NULL, NULL) < 0) {
 +        fprintf(stderr, "could not open codec\n");
 +        exit(1);
 +    }
 +
 +    video_outbuf = NULL;
 +    if (!(oc->oformat->flags & AVFMT_RAWPICTURE)) {
 +        /* allocate output buffer */
 +        /* XXX: API change will be done */
 +        /* buffers passed into lav* can be allocated any way you prefer,
 +           as long as they're aligned enough for the architecture, and
 +           they're freed appropriately (such as using av_free for buffers
 +           allocated with av_malloc) */
 +        video_outbuf_size = 200000;
 +        video_outbuf = av_malloc(video_outbuf_size);
 +    }
 +
 +    /* allocate the encoded raw picture */
 +    picture = alloc_picture(c->pix_fmt, c->width, c->height);
 +    if (!picture) {
 +        fprintf(stderr, "Could not allocate picture\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 */
 +    tmp_picture = NULL;
 +    if (c->pix_fmt != PIX_FMT_YUV420P) {
 +        tmp_picture = alloc_picture(PIX_FMT_YUV420P, c->width, c->height);
 +        if (!tmp_picture) {
 +            fprintf(stderr, "Could not allocate temporary picture\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;
 +
 +    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 void write_video_frame(AVFormatContext *oc, AVStream *st)
 +{
 +    int out_size, ret;
 +    AVCodecContext *c;
 +    static struct SwsContext *img_convert_ctx;
 +
 +    c = st->codec;
 +
 +    if (frame_count >= STREAM_NB_FRAMES) {
 +        /* no more frame to compress. The codec has a latency of a few
 +           frames if using B frames, so we get the last frames by
 +           passing the same picture again */
 +    } else {
 +        if (c->pix_fmt != PIX_FMT_YUV420P) {
 +            /* as we only generate a YUV420P picture, we must convert it
 +               to the codec pixel format if needed */
 +            if (img_convert_ctx == NULL) {
 +                img_convert_ctx = sws_getContext(c->width, c->height,
 +                                                 PIX_FMT_YUV420P,
 +                                                 c->width, c->height,
 +                                                 c->pix_fmt,
 +                                                 sws_flags, NULL, NULL, NULL);
 +                if (img_convert_ctx == NULL) {
 +                    fprintf(stderr, "Cannot initialize the conversion context\n");
 +                    exit(1);
 +                }
 +            }
 +            fill_yuv_image(tmp_picture, frame_count, c->width, c->height);
 +            sws_scale(img_convert_ctx, tmp_picture->data, tmp_picture->linesize,
 +                      0, c->height, picture->data, picture->linesize);
 +        } else {
 +            fill_yuv_image(picture, frame_count, c->width, c->height);
 +        }
 +    }
 +
 +
 +    if (oc->oformat->flags & AVFMT_RAWPICTURE) {
 +        /* raw video case. The API will change slightly in the near
 +           future for that. */
 +        AVPacket pkt;
 +        av_init_packet(&pkt);
 +
 +        pkt.flags |= AV_PKT_FLAG_KEY;
 +        pkt.stream_index = st->index;
 +        pkt.data = (uint8_t *)picture;
 +        pkt.size = sizeof(AVPicture);
 +
 +        ret = av_interleaved_write_frame(oc, &pkt);
 +    } else {
 +        /* encode the image */
 +        out_size = avcodec_encode_video(c, video_outbuf, video_outbuf_size, picture);
 +        /* if zero size, it means the image was buffered */
 +        if (out_size > 0) {
 +            AVPacket pkt;
 +            av_init_packet(&pkt);
 +
 +            if (c->coded_frame->pts != AV_NOPTS_VALUE)
 +                pkt.pts= av_rescale_q(c->coded_frame->pts, c->time_base, st->time_base);
 +            if(c->coded_frame->key_frame)
 +                pkt.flags |= AV_PKT_FLAG_KEY;
 +            pkt.stream_index = st->index;
 +            pkt.data = video_outbuf;
 +            pkt.size = out_size;
 +
 +            /* write the compressed frame in the media file */
 +            ret = av_interleaved_write_frame(oc, &pkt);
 +        } else {
 +            ret = 0;
 +        }
 +    }
 +    if (ret != 0) {
 +        fprintf(stderr, "Error while writing video frame\n");
 +        exit(1);
 +    }
 +    frame_count++;
 +}
 +
 +static void close_video(AVFormatContext *oc, AVStream *st)
 +{
 +    avcodec_close(st->codec);
 +    av_free(picture->data[0]);
 +    av_free(picture);
 +    if (tmp_picture) {
 +        av_free(tmp_picture->data[0]);
 +        av_free(tmp_picture);
 +    }
 +    av_free(video_outbuf);
 +}
 +
 +/**************************************************************/
 +/* media file output */
 +
 +int main(int argc, char **argv)
 +{
 +    const char *filename;
 +    AVOutputFormat *fmt;
 +    AVFormatContext *oc;
 +    AVStream *audio_st, *video_st;
 +    double audio_pts, video_pts;
 +    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"
 +               "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];
 +
 +    /* 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 */
 +    video_st = NULL;
 +    audio_st = NULL;
 +    if (fmt->video_codec != CODEC_ID_NONE) {
 +        video_st = add_video_stream(oc, fmt->video_codec);
 +    }
 +    if (fmt->audio_codec != CODEC_ID_NONE) {
 +        audio_st = add_audio_stream(oc, fmt->audio_codec);
 +    }
 +
 +    av_dump_format(oc, 0, filename, 1);
 +
 +    /* now that all the parameters are set, we can open the audio and
 +       video codecs and allocate the necessary encode buffers */
 +    if (video_st)
 +        open_video(oc, video_st);
 +    if (audio_st)
 +        open_audio(oc, audio_st);
 +
 +    /* open the output file, if needed */
 +    if (!(fmt->flags & AVFMT_NOFILE)) {
 +        if (avio_open(&oc->pb, filename, AVIO_FLAG_WRITE) < 0) {
 +            fprintf(stderr, "Could not open '%s'\n", filename);
 +            return 1;
 +        }
 +    }
 +
 +    /* write the stream header, if any */
 +    avformat_write_header(oc, NULL);
 +    picture->pts = 0;
 +    for(;;) {
 +        /* compute current audio and video time */
 +        if (audio_st)
 +            audio_pts = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 +        else
 +            audio_pts = 0.0;
 +
 +        if (video_st)
 +            video_pts = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 +        else
 +            video_pts = 0.0;
 +
 +        if ((!audio_st || audio_pts >= STREAM_DURATION) &&
 +            (!video_st || video_pts >= STREAM_DURATION))
 +            break;
 +
 +        /* write interleaved audio and video frames */
 +        if (!video_st || (video_st && audio_st && audio_pts < video_pts)) {
 +            write_audio_frame(oc, audio_st);
 +        } else {
 +            write_video_frame(oc, video_st);
 +            picture->pts++;
 +        }
 +    }
 +
 +    /* write the trailer, if any.  the trailer must be written
 +     * before you close the CodecContexts open when you wrote the
 +     * header; otherwise write_trailer may try to use memory that
 +     * was freed on av_codec_close() */
 +    av_write_trailer(oc);
 +
 +    /* close each codec */
 +    if (video_st)
 +        close_video(oc, video_st);
 +    if (audio_st)
 +        close_audio(oc, audio_st);
 +
 +    /* free the streams */
 +    for(i = 0; i < oc->nb_streams; i++) {
 +        av_freep(&oc->streams[i]->codec);
 +        av_freep(&oc->streams[i]);
 +    }
 +
 +    if (!(fmt->flags & AVFMT_NOFILE)) {
 +        /* close the output file */
 +        avio_close(oc->pb);
 +    }
 +
 +    /* free the stream */
 +    av_free(oc);
 +
 +    return 0;
 +}
diff --cc doc/ffmpeg.texi
index 51a282e,0000000..128acec
mode 100644,000000..100644
--- /dev/null
@@@ -1,1327 -1,0 +1,1327 @@@
- ffmpeg -i h264.mp4 -c:v copy -vbsf h264_mp4toannexb -an out.h264
 +\input texinfo @c -*- texinfo -*-
 +
 +@settitle ffmpeg Documentation
 +@titlepage
 +@center @titlefont{ffmpeg Documentation}
 +@end titlepage
 +
 +@top
 +
 +@contents
 +
 +@chapter Synopsis
 +
 +The generic syntax is:
 +
 +@example
 +@c man begin SYNOPSIS
 +ffmpeg [global options] [[infile options][@option{-i} @var{infile}]]... @{[outfile options] @var{outfile}@}...
 +@c man end
 +@end example
 +
 +@chapter Description
 +@c man begin DESCRIPTION
 +
 +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.
 +
 +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). Allowed number and/or
 +types of streams can be limited by the container format. Selecting, which
 +streams from which inputs go into output, is done either 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. See also 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 64kbit/s:
 +@example
 +ffmpeg -i input.avi -b:v 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 Stream selection
 +@c man begin STREAM SELECTION
 +
 +By default 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 the stream with the most channels, for
 +subtitle it's the first subtitle stream. In the case where several streams of
 +the same type rate equally, the lowest numbered stream is chosen.
 +
 +You can disable some of those defaults by using @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 avtools-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 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 but exit if file exists.
 +
 +@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{output})
 +Stop writing the output after its duration reaches @var{duration}.
 +@var{duration} may be a number in seconds, or in @code{hh:mm:ss[.xxx]} form.
 +
 +@item -fs @var{limit_size} (@emph{output})
 +Set the file size limit, expressed in bytes.
 +
 +@item -ss @var{position} (@emph{input/output})
 +When used as an input option (before @code{-i}), seeks in this input file to
 +@var{position}. When used as an output option (before an output filename),
 +decodes but discards input until the timestamps reach @var{position}. This is
 +slower, but more accurate.
 +
 +@var{position} may be either in seconds or in @code{hh:mm:ss[.xxx]} form.
 +
 +@item -itsoffset @var{offset} (@emph{input})
 +Set the input time offset in seconds.
 +@code{[-]hh:mm:ss[.xxx]} syntax is also supported.
 +The offset is added to the timestamps of the input files.
 +Specifying a positive offset means that the corresponding
 +streams are delayed by @var{offset} seconds.
 +
 +@item -timestamp @var{time} (@emph{output})
 +Set the recording timestamp in the container.
 +The syntax for @var{time} is:
 +@example
 +now|([(YYYY-MM-DD|YYYYMMDD)[T|t| ]]((HH[:MM[:SS[.m...]]])|(HH[MM[SS[.m...]]]))[Z|z])
 +@end example
 +If the value is "now" it takes the current time.
 +Time is local time unless 'Z' or 'z' is appended, in which case it is
 +interpreted as UTC.
 +If the year-month-day part is not specified it takes the current
 +year-month-day.
 +
 +@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 or chapters. 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:1 language=eng OUTPUT
 +@end example
 +
 +@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 record. 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} is
 +codec-dependent.
 +
 +@item -filter[:@var{stream_specifier}] @var{filter_graph} (@emph{output,per-stream})
 +@var{filter_graph} is a description of the filter graph to apply to
 +the stream. Use @code{-filters} to show all the available filters
 +(including also sources and sinks).
 +@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. On by default.
 +
 +@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 INPUT
 +@end example
 +To extract all attachments to files determined by the @code{filename} tag:
 +@example
 +ffmpeg -dump_attachment:t "" 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.
 +
 +@end table
 +
 +@section Video Options
 +
 +@table @option
 +@item -vframes @var{number} (@emph{output})
 +Set the number of video frames to record. 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), (default = 25).
 +@item -s[:@var{stream_specifier}] @var{size} (@emph{input/output,per-stream})
 +Set frame size. The format is @samp{wxh} (default - same as source).
 +The following abbreviations are recognized:
 +@table @samp
 +@item sqcif
 +128x96
 +@item qcif
 +176x144
 +@item cif
 +352x288
 +@item 4cif
 +704x576
 +@item 16cif
 +1408x1152
 +@item qqvga
 +160x120
 +@item qvga
 +320x240
 +@item vga
 +640x480
 +@item svga
 +800x600
 +@item xga
 +1024x768
 +@item uxga
 +1600x1200
 +@item qxga
 +2048x1536
 +@item sxga
 +1280x1024
 +@item qsxga
 +2560x2048
 +@item hsxga
 +5120x4096
 +@item wvga
 +852x480
 +@item wxga
 +1366x768
 +@item wsxga
 +1600x1024
 +@item wuxga
 +1920x1200
 +@item woxga
 +2560x1600
 +@item wqsxga
 +3200x2048
 +@item wquxga
 +3840x2400
 +@item whsxga
 +6400x4096
 +@item whuxga
 +7680x4800
 +@item cga
 +320x200
 +@item ega
 +640x350
 +@item hd480
 +852x480
 +@item hd720
 +1280x720
 +@item hd1080
 +1920x1080
 +@end table
 +
 +@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.
 +
 +@item -croptop @var{size}
 +@item -cropbottom @var{size}
 +@item -cropleft @var{size}
 +@item -cropright @var{size}
 +All the crop options have been removed. Use -vf
 +crop=width:height:x:y instead.
 +
 +@item -padtop @var{size}
 +@item -padbottom @var{size}
 +@item -padleft @var{size}
 +@item -padright @var{size}
 +@item -padcolor @var{hex_color}
 +All the pad options have been removed. Use -vf
 +pad=width:height:x:y:color instead.
 +
 +@item -vn (@emph{output})
 +Disable video recording.
 +@item -bt @var{tolerance}
 +Set video bitrate tolerance (in bits, default 4000k).
 +Has a minimum value of: (target_bitrate/target_framerate).
 +In 1-pass mode, bitrate tolerance specifies how far ratecontrol is
 +willing to deviate from the target average bitrate value. This is
 +not related to min/max bitrate. Lowering tolerance too much has
 +an adverse effect on quality.
 +@item -maxrate @var{bitrate}
 +Set max video bitrate (in bit/s).
 +Requires -bufsize to be set.
 +@item -minrate @var{bitrate}
 +Set min video bitrate (in bit/s).
 +Most useful in setting up a CBR encode:
 +@example
 +ffmpeg -i myfile.avi -b:v 4000k -minrate 4000k -maxrate 4000k -bufsize 1835k out.m2v
 +@end example
 +It is of little use elsewise.
 +@item -bufsize @var{size}
 +Set video buffer verifier buffer size (in bits).
 +@item -vcodec @var{codec} (@emph{output})
 +Set the video codec. This is an alias for @code{-codec:v}.
 +@item -same_quant
 +Use same quantizer as source (implies VBR).
 +
 +Note that this is NOT SAME QUALITY. Do not use this option unless you know you
 +need it.
 +
 +@item -pass @var{n}
 +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{prefix} (@emph{global})
 +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 -vlang @var{code}
 +Set the ISO 639 language code (3 letters) of the current video stream.
 +
 +@item -vf @var{filter_graph} (@emph{output})
 +@var{filter_graph} is a description of the filter graph to apply to
 +the input video.
 +Use the option "-filters" to show all the available filters (including
 +also sources and sinks).  This is an alias for @code{-filter:v}.
 +
 +@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.
 +@item -sws_flags @var{flags} (@emph{input/output})
 +Set SwScaler flags.
 +@item -g @var{gop_size}
 +Set the group of pictures size.
 +@item -intra
 +deprecated, use -g 1
 +@item -vdt @var{n}
 +Discard threshold.
 +@item -qmin @var{q}
 +minimum video quantizer scale (VBR)
 +@item -qmax @var{q}
 +maximum video quantizer scale (VBR)
 +@item -qdiff @var{q}
 +maximum difference between the quantizer scales (VBR)
 +@item -qblur @var{blur}
 +video quantizer scale blur (VBR) (range 0.0 - 1.0)
 +@item -qcomp @var{compression}
 +video quantizer scale compression (VBR) (default 0.5).
 +Constant of ratecontrol equation. Recommended range for default rc_eq: 0.0-1.0
 +
 +@item -lmin @var{lambda}
 +minimum video lagrange factor (VBR)
 +@item -lmax @var{lambda}
 +max video lagrange factor (VBR)
 +@item -mblmin @var{lambda}
 +minimum macroblock quantizer scale (VBR)
 +@item -mblmax @var{lambda}
 +maximum macroblock quantizer scale (VBR)
 +
 +These four options (lmin, lmax, mblmin, 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
 +
 +@item -rc_init_cplx @var{complexity}
 +initial complexity for single pass encoding
 +@item -b_qfactor @var{factor}
 +qp factor between P- and B-frames
 +@item -i_qfactor @var{factor}
 +qp factor between P- and I-frames
 +@item -b_qoffset @var{offset}
 +qp offset between P- and B-frames
 +@item -i_qoffset @var{offset}
 +qp offset between P- and I-frames
 +@item -rc_eq @var{equation}
 +Set rate control equation (see section "Expression Evaluation")
 +(default = @code{tex^qComp}).
 +
 +When computing the rate control equation expression, besides the
 +standard functions defined in the section "Expression Evaluation", the
 +following functions are available:
 +@table @var
 +@item bits2qp(bits)
 +@item qp2bits(qp)
 +@end table
 +
 +and the following constants are available:
 +@table @var
 +@item iTex
 +@item pTex
 +@item tex
 +@item mv
 +@item fCode
 +@item iCount
 +@item mcVar
 +@item var
 +@item isI
 +@item isP
 +@item isB
 +@item avgQP
 +@item qComp
 +@item avgIITex
 +@item avgPITex
 +@item avgPPTex
 +@item avgBPTex
 +@item avgTex
 +@end table
 +
 +@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 -me_method @var{method}
 +Set motion estimation method to @var{method}.
 +Available methods are (from lowest to best quality):
 +@table @samp
 +@item zero
 +Try just the (0, 0) vector.
 +@item phods
 +@item log
 +@item x1
 +@item hex
 +@item umh
 +@item epzs
 +(default method)
 +@item full
 +exhaustive search (slow and marginally better than epzs)
 +@end table
 +
 +@item -dct_algo @var{algo}
 +Set DCT algorithm to @var{algo}. Available values are:
 +@table @samp
 +@item 0
 +FF_DCT_AUTO (default)
 +@item 1
 +FF_DCT_FASTINT
 +@item 2
 +FF_DCT_INT
 +@item 3
 +FF_DCT_MMX
 +@item 4
 +FF_DCT_MLIB
 +@item 5
 +FF_DCT_ALTIVEC
 +@end table
 +
 +@item -idct_algo @var{algo}
 +Set IDCT algorithm to @var{algo}. Available values are:
 +@table @samp
 +@item 0
 +FF_IDCT_AUTO (default)
 +@item 1
 +FF_IDCT_INT
 +@item 2
 +FF_IDCT_SIMPLE
 +@item 3
 +FF_IDCT_SIMPLEMMX
 +@item 4
 +FF_IDCT_LIBMPEG2MMX
 +@item 5
 +FF_IDCT_PS2
 +@item 6
 +FF_IDCT_MLIB
 +@item 7
 +FF_IDCT_ARM
 +@item 8
 +FF_IDCT_ALTIVEC
 +@item 9
 +FF_IDCT_SH4
 +@item 10
 +FF_IDCT_SIMPLEARM
 +@end table
 +
 +@item -er @var{n}
 +Set error resilience to @var{n}.
 +@table @samp
 +@item 1
 +FF_ER_CAREFUL (default)
 +@item 2
 +FF_ER_COMPLIANT
 +@item 3
 +FF_ER_AGGRESSIVE
 +@item 4
 +FF_ER_VERY_AGGRESSIVE
 +@end table
 +
 +@item -ec @var{bit_mask}
 +Set error concealment to @var{bit_mask}. @var{bit_mask} is a bit mask of
 +the following values:
 +@table @samp
 +@item 1
 +FF_EC_GUESS_MVS (default = enabled)
 +@item 2
 +FF_EC_DEBLOCK (default = enabled)
 +@end table
 +
 +@item -bf @var{frames}
 +Use 'frames' B-frames (supported for MPEG-1, MPEG-2 and MPEG-4).
 +@item -mbd @var{mode}
 +macroblock decision
 +@table @samp
 +@item 0
 +FF_MB_DECISION_SIMPLE: Use mb_cmp (cannot change it yet in ffmpeg).
 +@item 1
 +FF_MB_DECISION_BITS: Choose the one which needs the fewest bits.
 +@item 2
 +FF_MB_DECISION_RD: rate distortion
 +@end table
 +
 +@item -4mv
 +Use four motion vector by macroblock (MPEG-4 only).
 +@item -part
 +Use data partitioning (MPEG-4 only).
 +@item -bug @var{param}
 +Work around encoder bugs that are not auto-detected.
 +@item -strict @var{strictness}
 +How strictly to follow the standards.
 +@item -aic
 +Enable Advanced intra coding (h263+).
 +@item -umv
 +Enable Unlimited Motion Vector (h263+)
 +
 +@item -deinterlace
 +Deinterlace pictures.
 +This option is deprecated since the deinterlacing is very low quality.
 +Use the yadif filter with @code{-filter:v yadif}.
 +@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})
 +Force key frames at the specified timestamps, more precisely at the first
 +frames after each specified time.
 +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.
 +The timestamps must be specified in ascending order.
 +
 +@item -copyinkf[:@var{stream_specifier}] (@emph{output,per-stream})
 +When doing stream copy, copy also non-key frames found at the
 +beginning.
 +@end table
 +
 +@section Audio Options
 +
 +@table @option
 +@item -aframes @var{number} (@emph{output})
 +Set the number of audio frames to record. 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.
 +@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 -audio_service_type @var{type}
 +Set the type of service that the audio stream contains.
 +@table @option
 +@item ma
 +Main Audio Service (default)
 +@item ef
 +Effects
 +@item vi
 +Visually Impaired
 +@item hi
 +Hearing Impaired
 +@item di
 +Dialogue
 +@item co
 +Commentary
 +@item em
 +Emergency
 +@item vo
 +Voice Over
 +@item ka
 +Karaoke
 +@end table
 +@item -absf @var{bitstream_filter}
 +Deprecated, see -bsf
 +@end table
 +
 +@section Subtitle options:
 +
 +@table @option
 +@item -slang @var{code}
 +Set the ISO 639 language code (3 letters) of the current subtitle stream.
 +@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 Audio/Video grab options
 +
 +@table @option
 +@item -isync (@emph{global})
 +Synchronize read on input.
 +@end table
 +
 +@section Advanced options
 +
 +@table @option
 +@item -map [-]@var{input_file_id}[:@var{stream_specifier}][,@var{sync_file_id}[:@var{stream_specifier}]] (@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.
 +
 +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
 +
 +Note that using this option disables the default mappings for this output file.
 +
 +@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} are 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
 +channel layouts don't match (for instance two "-map_channel" options and "-ac
 +6").
 +
 +You can also extract each channel of an @var{INPUT} to specific outputs; the
 +following command extract each channel of the audio stream (file 0, stream 0)
 +to the respective @var{OUTPUT_CH0} and @var{OUTPUT_CH1}:
 +@example
 +ffmpeg -i INPUT -map_channel 0.0.0 OUTPUT_CH0 -map_channel 0.0.1 OUTPUT_CH1
 +@end example
 +
 +The following example split the channels of a stereo input into streams:
 +
 +@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 spliting 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):
 +
 +@example
 +ffmpeg -i input.mkv -f lavfi -i "
 +amovie=input.mkv:si=1 [a1];
 +amovie=input.mkv:si=2 [a2];
 +[a1][a2] 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 -debug @var{category}
 +Print specific debug info.
 +@var{category} is a number or a string containing one of the following values:
 +@table @samp
 +@item bitstream
 +@item buffers
 +picture buffer allocations
 +@item bugs
 +@item dct_coeff
 +@item er
 +error recognition
 +@item mb_type
 +macroblock (MB) type
 +@item mmco
 +memory management control operations (H.264)
 +@item mv
 +motion vector
 +@item pict
 +picture info
 +@item pts
 +@item qp
 +per-block quantization parameter (QP)
 +@item rc
 +rate control
 +@item skip
 +@item startcode
 +@item thread_ops
 +threading operations
 +@item vis_mb_type
 +visualize block types
 +@item vis_qp
 +visualize quantization parameter (QP), lower QP are tinted greener
 +@end table
 +@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 -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 -ps @var{size}
 +Set RTP payload size in bytes.
 +@item -re (@emph{input})
 +Read input at native frame rate. Mainly used to simulate a grab device.
 +@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 -threads @var{count}
 +Thread count.
 +@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 framerate.
 +@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
 +
 +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 -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.
 +@item -copyts
 +Copy timestamps from input to output.
 +@item -copytb
 +Copy input stream time base from input to output when stream copying.
 +@item -shortest
 +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{bistream_filters} is
 +a comma-separated list of bitstream filters. Use the @code{-bsfs} option
 +to get the list of bitstream filters.
 +@example
- ffmpeg -i file.mov -an -vn -sbsf mov2textsub -c:s copy -f rawvideo sub.txt
++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{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
 +@end table
 +
 +@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.
 +
 +Preset 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{libx264-max}, it will
 +search for the file @file{libx264-max.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 libx264} and use @code{-vpre max},
 +then it will search for the file @file{libx264-max.ffpreset}.
 +@c man end OPTIONS
 +
 +@chapter Tips
 +@c man begin TIPS
 +
 +@itemize
 +@item
 +For streaming at very low bitrate application, use a low frame rate
 +and a small GOP size. This is especially true for RealVideo where
 +the Linux player does not seem to be very fast, so it can miss
 +frames. An example is:
 +
 +@example
 +ffmpeg -g 3 -r 3 -t 10 -b:v 50k -s qcif -f rv10 /tmp/b.rm
 +@end example
 +
 +@item
 +The parameter 'q' which is displayed while encoding is the current
 +quantizer. The value 1 indicates that a very good quality could
 +be achieved. The value 31 indicates the worst quality. If q=31 appears
 +too often, it means that the encoder cannot compress enough to meet
 +your bitrate. You must either increase the bitrate, decrease the
 +frame rate or decrease the frame size.
 +
 +@item
 +If your computer is not fast enough, you can speed up the
 +compression at the expense of the compression ratio. You can use
 +'-me zero' to speed up motion estimation, and '-intra' to disable
 +motion estimation completely (you have only I-frames, which means it
 +is about as good as JPEG compression).
 +
 +@item
 +To have very low audio bitrates, reduce the sampling frequency
 +(down to 22050 Hz for MPEG audio, 22050 or 11025 for AC-3).
 +
 +@item
 +To have a constant quality (but a variable bitrate), use the option
 +'-qscale n' when 'n' is between 1 (excellent quality) and 31 (worst
 +quality).
 +
 +@end itemize
 +@c man end TIPS
 +
 +@chapter Examples
 +@c man begin EXAMPLES
 +
 +@section Preset files
 +
 +A preset file contains a sequence of @var{option=value} pairs, one for
 +each line, specifying a sequence of options which can be specified also on
 +the command line. Lines starting with the hash ('#') character are ignored and
 +are used to provide comments. Empty lines are also ignored. Check the
 +@file{presets} directory in the FFmpeg source tree for examples.
 +
 +Preset files are specified with the @code{pre} option, this option takes a
 +preset name as input.  FFmpeg searches for a file named @var{preset_name}.avpreset in
 +the directories @file{$AVCONV_DATADIR} (if set), and @file{$HOME/.ffmpeg}, and in
 +the data directory defined at configuration time (usually @file{$PREFIX/share/ffmpeg})
 +in that order.  For example, if the argument is @code{libx264-max}, it will
 +search for the file @file{libx264-max.avpreset}.
 +
 +@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 -s cif -r 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 -s cif -r 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 -i foo-%03d.jpeg -r 12 -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.
 +
 +@item
 +You can put many streams of the same type in the output:
 +
 +@example
 +ffmpeg -i test1.avi -i test2.avi -map 0.3 -map 0.2 -map 0.1 -map 0.0 -c copy test12.nut
 +@end example
 +
 +The resulting output file @file{test12.avi} will contain first four streams from
 +the input file in reverse order.
 +
 +@end itemize
 +@c man end EXAMPLES
 +
 +@include eval.texi
 +@include decoders.texi
 +@include encoders.texi
 +@include demuxers.texi
 +@include muxers.texi
 +@include indevs.texi
 +@include outdevs.texi
 +@include protocols.texi
 +@include bitstream_filters.texi
 +@include filters.texi
 +@include metadata.texi
 +
 +@ignore
 +
 +@setfilename ffmpeg
 +@settitle ffmpeg video converter
 +
 +@c man begin SEEALSO
 +ffplay(1), ffprobe(1), ffserver(1) and the FFmpeg HTML documentation
 +@c man end
 +
 +@c man begin AUTHORS
 +See git history
 +@c man end
 +
 +@end ignore
 +
 +@bye
@@@ -118,10 -120,23 +118,23 @@@ for examples see get_bits, show_bits, s
  #   define MIN_CACHE_BITS 25
  #endif
  
+ #if UNCHECKED_BITSTREAM_READER
  #define OPEN_READER(name, gb)                   \
      unsigned int name##_index = (gb)->index;    \
 -    unsigned int av_unused name##_cache = 0
 +    av_unused unsigned int name##_cache
  
+ #define HAVE_BITS_REMAINING(name, gb) 1
+ #else
+ #define OPEN_READER(name, gb)                   \
+     unsigned int name##_index = (gb)->index;    \
+     unsigned int av_unused name##_cache = 0;    \
+     unsigned int av_unused name##_size_plus8 =  \
+                 (gb)->size_in_bits_plus8
+ #define HAVE_BITS_REMAINING(name, gb)           \
+     name##_index < name##_size_plus8
+ #endif
  #define CLOSE_READER(name, gb) (gb)->index = name##_index
  
  #ifdef BITSTREAM_READER_LE
@@@ -135,7 -135,7 +135,7 @@@ static inline int svq3_get_ue_golomb(Ge
              ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
              UPDATE_CACHE(re, gb);
              buf = GET_CACHE(re, gb);
-         } while(ret<0x8000000U);
 -        } while (HAVE_BITS_REMAINING(re, gb));
++        } while (ret<0x8000000U && HAVE_BITS_REMAINING(re, gb));
  
          CLOSE_READER(re, gb);
          return ret - 1;
Simple merge
Simple merge
@@@ -1378,8 -1377,10 +1379,9 @@@ static int mp_decode_layer3(MPADecodeCo
      }
  
      if (!s->adu_mode) {
 -        int skip;
          const uint8_t *ptr = s->gb.buffer + (get_bits_count(&s->gb)>>3);
-         int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0, EXTRABYTES);
+         int extrasize = av_clip(get_bits_left(&s->gb) >> 3, 0,
+                                 FFMAX(0, LAST_BUF_SIZE - s->last_buf_size));
          assert((get_bits_count(&s->gb) & 7) == 0);
          /* now we get bits from the main_data_begin offset */
          av_dlog(s->avctx, "seekback: %d\n", main_data_begin);
Simple merge
@@@ -53,10 -47,9 +53,12 @@@ YASM-OBJS-$(CONFIG_PNG_DECODER)        
  MMX-OBJS-$(CONFIG_PNG_DECODER)         += x86/pngdsp-init.o
  YASM-OBJS-$(CONFIG_PRORES_DECODER)     += x86/proresdsp.o
  MMX-OBJS-$(CONFIG_PRORES_DECODER)      += x86/proresdsp-init.o
 -MMX-OBJS-$(CONFIG_DWT)                 += x86/snowdsp_mmx.o
+ MMX-OBJS-$(CONFIG_AAC_DECODER)         += x86/sbrdsp_init.o
+ YASM-OBJS-$(CONFIG_AAC_DECODER)        += x86/sbrdsp.o
 +MMX-OBJS-$(CONFIG_DWT)                 += x86/snowdsp_mmx.o \
 +                                          x86/dwt.o
 +YASM-OBJS-$(CONFIG_V210_DECODER)       += x86/v210.o
 +MMX-OBJS-$(CONFIG_V210_DECODER)        += x86/v210-init.o
  MMX-OBJS-$(CONFIG_VC1_DECODER)         += x86/vc1dsp_mmx.o
  YASM-OBJS-$(CONFIG_VP3_DECODER)        += x86/vp3dsp.o
  YASM-OBJS-$(CONFIG_VP5_DECODER)        += x86/vp3dsp.o
Simple merge
@@@ -528,11 -496,9 +528,9 @@@ static int ogg_write_trailer(AVFormatCo
          OGGStreamContext *oggstream = st->priv_data;
          if (st->codec->codec_id == CODEC_ID_FLAC ||
              st->codec->codec_id == CODEC_ID_SPEEX) {
 -            av_free(oggstream->header[0]);
 +            av_freep(&oggstream->header[0]);
-             av_freep(&oggstream->header[1]);
          }
-         else
-             av_freep(&oggstream->header[1]);
+         av_freep(&oggstream->header[1]);
          av_freep(&st->priv_data);
      }
      return 0;
Simple merge