Merge commit '129bb238430ec45a3b5f8f1d384df590ddf7b62f'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 24 May 2013 11:47:45 +0000 (13:47 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 24 May 2013 12:07:00 +0000 (14:07 +0200)
* commit '129bb238430ec45a3b5f8f1d384df590ddf7b62f':
  lavfi: add a slice threading infrastructure

Conflicts:
Changelog
cmdutils.c
doc/APIchanges
libavfilter/Makefile
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/internal.h
libavfilter/version.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
Changelog
cmdutils.c
doc/APIchanges
libavfilter/Makefile
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/internal.h
libavfilter/pthread.c
libavfilter/thread.h
libavfilter/version.h

diff --combined Changelog
+++ b/Changelog
  Entries are sorted chronologically from oldest to youngest within each release,
  releases are sorted from youngest to oldest.
  
 -version 10:
 -- av_strnstr
 -- support ID3v2 tags in ASF files
 +version <next>:
 +- curves filter
  - reference-counting for AVFrame and AVPacket data
 -- avconv now fails when input options are used for output file
 +- ffmpeg now fails when input options are used for output file
    or vice versa
 -- new avconv options -filter_script and -filter_complex_script, which allow a
 +- support for Monkey's Audio versions from 3.93
 +- perms and aperms filters
 +- audio filtering support in ffplay
 +- 10% faster aac encoding on x86 and MIPS
 +- sine audio filter source
 +- WebP demuxing and decoding support
 +- new ffmpeg options -filter_script and -filter_complex_script, which allow a
    filtergraph description to be read from a file
 +- OpenCL support
 +- audio phaser filter
 +- separatefields filter
 +- libquvi demuxer
  - uniform options syntax across all filters
 +- telecine filter
  - new interlace filter
 -- JPEG 2000 decoder
 -- new asetpts filter (same as setpts, but for audio)
 -- new trim and atrim filters
 -- avconv -t and -ss (output-only) options are now sample-accurate when
 +- smptehdbars source
 +- inverse telecine filters (fieldmatch and decimate)
 +- colorbalance filter
 +- colorchannelmixer filter
 +- The matroska demuxer can now output proper verbatim ASS packets. It will
 +  become the default at the next libavformat major bump.
 +- decent native animated GIF encoding
 +- asetrate filter
 +- interleave filter
 +- timeline editing with filters
 +- vidstabdetect and vidstabtransform filters for video stabilization using
 +  the vid.stab library
 +- astats filter
 +- trim and atrim filters
 +- ffmpeg -t and -ss (output-only) options are now sample-accurate when
    transcoding audio
  - Matroska muxer can now put the index at the beginning of the file.
 -- avconv -deinterlace option removed, the yadif filter should be used instead
 +- extractplanes filter
 +- avectorscope filter
 +- ADPCM DTK decoder
 +- ADP demuxer
 +- RSD demuxer
 +- RedSpark demuxer
 +- ADPCM IMA Radical decoder
 +- zmq filters
 +- DCT denoiser filter (dctdnoiz)
 +- Wavelet denoiser filter ported from libmpcodecs as owdenoise (formerly "ow")
  - Apple Intermediate Codec decoder
  - Escape 130 video decoder
 +- FTP protocol support
 +- V4L2 output device
 +- 3D LUT filter (lut3d)
 +- SMPTE 302M audio encoder
+ - support for slice multithreading in libavfilter
  
  
 -version 9:
 -- av_basename and av_dirname
 -- adobe and limelight publisher authentication in RTMP
 +version 1.2:
 +
  - VDPAU hardware acceleration through normal hwaccel
  - SRTP support
 -
 -
 -version 9_beta3:
 -- ashowinfo audio filter
 +- Error diffusion dither in Swscale
 +- Chained Ogg support
 +- Theora Midstream reconfiguration support
 +- EVRC decoder
 +- audio fade filter
 +- filtering audio with unknown channel layout
 +- allpass, bass, bandpass, bandreject, biquad, equalizer, highpass, lowpass
 +  and treble audio filter
 +- improved showspectrum filter, with multichannel support and sox-like colors
 +- histogram filter
 +- tee muxer
 +- il filter ported from libmpcodecs
 +- support ID3v2 tags in ASF files
 +- encrypted TTA stream decoding support
 +- RF64 support in WAV muxer
 +- noise filter ported from libmpcodecs
 +- Subtitles character encoding conversion
 +- blend filter
 +- stereo3d filter ported from libmpcodecs
 +
 +
 +version 1.1:
 +
 +- stream disposition information printing in ffprobe
 +- filter for loudness analysis following EBU R128
 +- Opus encoder using libopus
 +- ffprobe -select_streams option
 +- Pinnacle TARGA CineWave YUV16 decoder
 +- TAK demuxer, decoder and parser
 +- DTS-HD demuxer
 +- remove -same_quant, it hasn't worked for years
 +- FFM2 support
 +- X-Face image encoder and decoder
  - 24-bit FLAC encoding
 -- audio volume filter
 -- deprecated the avconv -vol option. the volume filter is to be used instead.
  - multi-channel ALAC encoding up to 7.1
 -- TAK demuxer, parser, and decoder
 -- adaptive frame-level multithreading for H.264
 -
 -
 -version 9_beta2:
  - metadata (INFO tag) support in WAV muxer
 +- subtitles raw text decoder
  - support for building DLLs using MSVC
 -- remove avserver daemon mode
 +- LVF demuxer
 +- ffescape tool
 +- metadata (info chunk) support in CAF muxer
 +- field filter ported from libmpcodecs
 +- AVR demuxer
 +- geq filter ported from libmpcodecs
 +- remove ffserver daemon mode
 +- AST muxer/demuxer
 +- new expansion syntax for drawtext
 +- BRender PIX image decoder
 +- ffprobe -show_entries option
 +- ffprobe -sections option
 +- ADPCM IMA Dialogic decoder
 +- BRSTM demuxer
 +- animated GIF decoder and demuxer
 +- PVF demuxer
 +- subtitles filter
 +- IRCAM muxer/demuxer
 +- Paris Audio File demuxer
 +- Virtual concatenation demuxer
 +- VobSub demuxer
 +- JSON captions for TED talks decoding support
 +- SOX Resampler support in libswresample
 +- aselect filter
 +- SGI RLE 8-bit decoder
 +- Silicon Graphics Motion Video Compressor 1 & 2 decoder
 +- Silicon Graphics Movie demuxer
 +- apad filter
 +- Resolution & pixel format change support with multithreading for H.264
 +- documentation split into per-component manuals
 +- pp (postproc) filter ported from MPlayer
 +- NIST Sphere demuxer
 +- MPL2, VPlayer, MPlayer, AQTitle, PJS and SubViewer v1 subtitles demuxers and decoders
 +- Sony Wave64 muxer
 +- adobe and limelight publisher authentication in RTMP
 +- data: URI scheme
  - support building on the Plan 9 operating system
 -- ffv1: support version 1.3
 +- kerndeint filter ported from MPlayer
 +- histeq filter ported from VirtualDub
 +- Megalux Frame demuxer
 +- 012v decoder
 +- Improved AVC Intra decoding support
  
  
 -version 9_beta1:
 +version 1.0:
  
 -- XWD encoder and decoder
 -- Support for fragmentation in the mov/mp4 muxer
 -- ISMV (Smooth Streaming) muxer
 -- CDXL demuxer and decoder
 -- Apple ProRes encoder
 -- Sun Rasterfile Encoder
 -- remove libpostproc
 -- ID3v2 attached pictures reading and writing
 -- WMA Lossless decoder
 -- XBM encoder
 -- RealAudio Lossless decoder
 -- ZeroCodec decoder
 -- drop support for avconv without libavfilter
 -- add libavresample audio conversion library
 -- audio filters support in libavfilter and avconv
 -- add fps filter
 -- audio split filter
 -- audio mix filter
 -- avprobe output is now standard INI or JSON. The old format can still
 -  be used with -of old.
 +- INI and flat output in ffprobe
 +- Scene detection in libavfilter
  - Indeo Audio decoder
  - channelsplit audio filter
 +- setnsamples audio filter
 +- atempo filter
 +- ffprobe -show_data option
  - RTMPT protocol support
  - iLBC encoding/decoding via libilbc
  - Microsoft Screen 1 decoder
  - Microsoft Expression Encoder Screen decoder
  - RTMPS protocol support
  - RTMPTS protocol support
 -- JPEG 2000 encoding support through OpenJPEG
 -- G.723.1 demuxer and decoder
  - RTMPE protocol support
  - RTMPTE protocol support
 +- showwaves and showspectrum filter
 +- LucasArts SMUSH playback support
 +- SAMI, RealText and SubViewer demuxers and decoders
 +- Heart Of Darkness PAF playback support
 +- iec61883 device
 +- asettb filter
 +- new option: -progress
 +- 3GPP Timed Text encoder/decoder
 +- GeoTIFF decoder support
 +- ffmpeg -(no)stdin option
 +- Opus decoder using libopus
 +- caca output device using libcaca
 +- alphaextract and alphamerge filters
 +- concat filter
 +- flite filter
  - Canopus Lossless Codec decoder
 -- avconv -shortest option is now per-output file,
 +- bitmap subtitles in filters (experimental and temporary)
 +- MP2 encoding via TwoLAME
 +- bmp parser
 +- smptebars source
 +- asetpts filter
 +- hue filter
 +- ICO muxer
 +- SubRip encoder and decoder without embedded timing
 +- edge detection filter
 +- framestep filter
 +- ffmpeg -shortest option is now per-output file
    -pass and -passlogfile are now per-output stream
 +- volume measurement filter
  - Ut Video encoder
  - Microsoft Screen 2 decoder
 +- smartblur filter ported from MPlayer
 +- CPiA decoder
 +- decimate filter ported from MPlayer
  - RTP depacketization of JPEG
  - Smooth Streaming live segmenter muxer
 +- F4V muxer
 +- sendcmd and asendcmd filters
 +- WebVTT demuxer and decoder (simple tags supported)
  - RTP packetization of JPEG
 -- Opus decoder and encoder using libopus
 -- remove -same_quant, it hasn't worked for years
 +- faststart option in the MOV/MP4 muxer
  - support for building with MSVC
  
  
 -version 0.8:
 +version 0.11:
  
 -- GSM audio parser
 -- SMJPEG muxer
 +- Fixes: CVE-2012-2772, CVE-2012-2774, CVE-2012-2775, CVE-2012-2776, CVE-2012-2777,
 +         CVE-2012-2779, CVE-2012-2782, CVE-2012-2783, CVE-2012-2784, CVE-2012-2785,
 +         CVE-2012-2786, CVE-2012-2787, CVE-2012-2788, CVE-2012-2789, CVE-2012-2790,
 +         CVE-2012-2791, CVE-2012-2792, CVE-2012-2793, CVE-2012-2794, CVE-2012-2795,
 +         CVE-2012-2796, CVE-2012-2797, CVE-2012-2798, CVE-2012-2799, CVE-2012-2800,
 +         CVE-2012-2801, CVE-2012-2802, CVE-2012-2803, CVE-2012-2804,
 +- v408 Quicktime and Microsoft AYUV Uncompressed 4:4:4:4 encoder and decoder
 +- setfield filter
 +- CDXL demuxer and decoder
 +- Apple ProRes encoder
 +- ffprobe -count_packets and -count_frames options
 +- Sun Rasterfile Encoder
 +- ID3v2 attached pictures reading and writing
 +- WMA Lossless decoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
 +- RealAudio Lossless decoder
 +- ZeroCodec decoder
 +- tile video filter
 +- Metal Gear Solid: The Twin Snakes demuxer
 +- OpenEXR image decoder
 +- removelogo filter
 +- drop support for ffmpeg without libavfilter
 +- drawtext video filter: fontconfig support
 +- ffmpeg -benchmark_all option
 +- super2xsai filter ported from libmpcodecs
 +- add libavresample audio conversion library for compatibility
 +- MicroDVD decoder
 +- Avid Meridien (AVUI) encoder and decoder
 +- accept + prefix to -pix_fmt option to disable automatic conversions.
 +- complete audio filtering in libavfilter and ffmpeg
 +- add fps filter
 +- vorbis parser
 +- png parser
 +- audio mix filter
 +- ffv1: support (draft) version 1.3
  
  
 -version 0.8_beta2:
 +version 0.10:
  
 +- Fixes: CVE-2011-3929, CVE-2011-3934, CVE-2011-3935, CVE-2011-3936,
 +         CVE-2011-3937, CVE-2011-3940, CVE-2011-3941, CVE-2011-3944,
 +         CVE-2011-3945, CVE-2011-3946, CVE-2011-3947, CVE-2011-3949,
 +         CVE-2011-3950, CVE-2011-3951, CVE-2011-3952
 +- v410 Quicktime Uncompressed 4:4:4 10-bit encoder and decoder
 +- SBaGen (SBG) binaural beats script demuxer
 +- OpenMG Audio muxer
 +- Timecode extraction in DV and MOV
 +- thumbnail video filter
 +- XML output in ffprobe
 +- asplit audio filter
 +- tinterlace video filter
 +- astreamsync audio filter
 +- amerge audio filter
 +- ISMV (Smooth Streaming) muxer
 +- GSM audio parser
 +- SMJPEG muxer
 +- XWD encoder and decoder
  - Automatic thread count based on detection number of (available) CPU cores
 -- Deprecate libpostproc. If desired, the switch --enable-postproc will
 -  enable it but it may be removed in a later Libav release.
 +- y41p Brooktree Uncompressed 4:1:1 12-bit encoder and decoder
 +- ffprobe -show_error option
 +- Avid 1:1 10-bit RGB Packer codec
 +- v308 Quicktime Uncompressed 4:4:4 encoder and decoder
 +- yuv4 libquicktime packed 4:2:0 encoder and decoder
 +- ffprobe -show_frames option
 +- silencedetect audio filter
 +- ffprobe -show_program_version, -show_library_versions, -show_versions options
  - rv34: frame-level multi-threading
  - optimized iMDCT transform on x86 using SSE for for mpegaudiodec
 +- Improved PGS subtitle decoder
 +- dumpgraph option to lavfi device
 +- r210 and r10k encoders
 +- ffwavesynth decoder
 +- aviocat tool
 +- ffeval tool
  
  
 -version 0.8_beta1:
 +version 0.9:
  
 +- openal input device added
 +- boxblur filter added
  - BWF muxer
  - Flash Screen Video 2 decoder
 -- ffplay/ffprobe/ffserver renamed to avplay/avprobe/avserver
 -- ffmpeg deprecated, added avconv, which is almost the same for now, except
 +- lavfi input device added
 +- added avconv, which is almost the same for now, except
  for a few incompatible changes in the options, which will hopefully make them
  easier to use. The changes are:
      * The options placement is now strictly enforced! While in theory the
      * -vframes/-aframes/-dframes options are now aliases to the new -frames option.
      * -vtag/-atag/-stag options are now aliases to the new -tag option.
  - XMV demuxer
 +- LOAS demuxer
 +- ashowinfo filter added
  - Windows Media Image decoder
 +- amovie source added
  - LATM muxer/demuxer
 -- showinfo filter
 -- split filter
 +- Speex encoder via libspeex
 +- JSON output in ffprobe
 +- WTV muxer
 +- Optional C++ Support (needed for libstagefright)
 +- H.264 Decoding on Android via Stagefright
 +- Prores decoder
 +- BIN/XBIN/ADF/IDF text file decoder
 +- aconvert audio filter added
 +- audio support to lavfi input device added
  - libcdio-paranoia input device for audio CD grabbing
 -- select filter
  - Apple ProRes decoder
  - CELT in Ogg demuxing
 +- G.723.1 demuxer and decoder
 +- libmodplug support (--enable-libmodplug)
  - VC-1 interlaced decoding
 -- lut, lutrgb, and lutyuv filters
 -- boxblur filter
 +- libutvideo wrapper (--enable-libutvideo)
 +- aevalsrc audio source added
  - Ut Video decoder
  - Speex encoding via libspeex
  - 4:2:2 H.264 decoding support
  - 4:2:2 and 4:4:4 H.264 encoding with libx264
  - Pulseaudio input device
 +- Prores encoder
 +- Video Decoder Acceleration (VDA) HWAccel module.
  - replacement Indeo 3 decoder
 +- new ffmpeg option: -map_channel
 +- volume audio filter added
 +- earwax audio filter added
 +- libv4l2 support (--enable-libv4l2)
  - TLS/SSL and HTTPS protocol support
  - AVOptions API rewritten and documented
  - most of CODEC_FLAG2_*, some CODEC_FLAG_* and many codec-specific fields in
  - Discworld II BMV decoding support
  - VBLE Decoder
  - OS X Video Decoder Acceleration (VDA) support
 +- compact and csv output in ffprobe
 +- pan audio filter
 +- IFF Amiga Continuous Bitmap (ACBM) decoder
 +- ass filter
  - CRI ADX audio format muxer and demuxer
  - Playstation Portable PMP format demuxer
 +- Microsoft Windows ICO demuxer
 +- life source
  - PCM format support in OMA demuxer
  - CLJR encoder
 +- new option: -report
  - Dxtory capture format decoder
 -- v410 QuickTime uncompressed 4:4:4 10-bit encoder and decoder
 -- OpenMG Audio muxer
 +- cellauto source
  - Simple segmenting muxer
  - Indeo 4 decoder
  - SMJPEG demuxer
  
  
 -version 0.7:
 -
 -- E-AC-3 audio encoder
 -- ac3enc: add channel coupling support
 -- floating-point sample format support for (E-)AC-3, DCA, AAC, Vorbis decoders
 -- H.264/MPEG frame-level multithreading
 -- 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
 -- bump libswscale for recently reported ABI break
 -
 -
 -version 0.7_beta2:
 -
 -- VP8 frame-level multithreading
 -- NEON optimizations for VP8
 -- removed a lot of deprecated API cruft
 -- FFT and IMDCT optimizations for AVX (Sandy Bridge) processors
 -- DPX image encoder
 -- SMPTE 302M AES3 audio decoder
 -- ffmpeg no longer quits after the 'q' key is pressed; use 'ctrl+c' instead
 -- 9bit and 10bit per sample support in the H.264 decoder
 -
 -
 -version 0.7_beta1:
 +version 0.8:
  
 +- many many things we forgot because we rather write code than changelogs
  - WebM support in Matroska de/muxer
  - low overhead Ogg muxing
  - MMS-TCP support
  - Demuxer for On2's IVF format
  - Pictor/PC Paint decoder
  - HE-AAC v2 decoder
 +- HE-AAC v2 encoding with libaacplus
  - libfaad2 wrapper removed
  - DTS-ES extension (XCh) decoding support
  - native VP8 decoder
  - RTP depacketization of QDM2
  - ANSI/ASCII art playback system
  - Lego Mindstorms RSO de/muxer
 +- libavcore added (and subsequently removed)
  - SubRip subtitle file muxer and demuxer
  - Chinese AVS encoding via libxavs
  - ffprobe -show_packets option added
  - replace the ocv_smooth filter with a more generic ocv filter
  - Windows Televison (WTV) demuxer
  - FFmpeg metadata format muxer and demuxer
 -- SubRip (srt) subtitle decoder
 +- SubRip (srt) subtitle encoder and decoder
  - floating-point AC-3 encoder added
  - Lagarith decoder
  - ffmpeg -copytb option added
  - sndio support for playback and record
  - Linux framebuffer input device added
  - Chronomaster DFA decoder
 -- Mobotix MxPEG decoder
 +- DPX image encoder
 +- MicroDVD subtitle file muxer and demuxer
 +- Playstation Portable PMP format demuxer
 +- fieldorder video filter added
  - 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
 +- 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:
@@@ -792,7 -577,6 +793,7 @@@ version 0.5
  - Gopher client support
  - MXF D-10 muxer
  - generic metadata API
 +- flash ScreenVideo2 encoder
  
  
  version 0.4.9-pre1:
@@@ -995,7 -779,7 +996,7 @@@ version 0.4.5
  - MPEG-4 vol header fixes (Jonathan Marsden <snmjbm at pacbell.net>)
  - ARM optimizations (Lionel Ulmer <lionel.ulmer at free.fr>).
  - Windows porting of file converter
 -- added MJPEG raw format (input/ouput)
 +- added MJPEG raw format (input/output)
  - added JPEG image format support (input/output)
  
  
diff --combined cmdutils.c
@@@ -2,20 -2,20 +2,20 @@@
   * Various utilities for command line tools
   * Copyright (c) 2000-2003 Fabrice Bellard
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
     references to libraries that are not being built. */
  
  #include "config.h"
 +#include "compat/va_copy.h"
  #include "libavformat/avformat.h"
  #include "libavfilter/avfilter.h"
  #include "libavdevice/avdevice.h"
  #include "libavresample/avresample.h"
  #include "libswscale/swscale.h"
 +#include "libswresample/swresample.h"
 +#include "libpostproc/postprocess.h"
  #include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
  #include "libavutil/mathematics.h"
  #include "libavutil/imgutils.h"
  #include "libavutil/parseutils.h"
  #include <sys/time.h>
  #include <sys/resource.h>
  #endif
 +#if CONFIG_OPENCL
 +#include "libavutil/opencl.h"
 +#endif
 +
 +
 +static int init_report(const char *env);
  
  struct SwsContext *sws_opts;
 +AVDictionary *swr_opts;
  AVDictionary *format_opts, *codec_opts, *resample_opts;
  
 -static const int this_year = 2013;
 +const int this_year = 2013;
 +
 +static FILE *report_file;
  
  void init_opts(void)
  {
 -#if CONFIG_SWSCALE
 -    sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
 +
 +    if(CONFIG_SWSCALE)
 +        sws_opts = sws_getContext(16, 16, 0, 16, 16, 0, SWS_BICUBIC,
                                NULL, NULL, NULL);
 -#endif
  }
  
  void uninit_opts(void)
@@@ -85,8 -72,6 +85,8 @@@
      sws_freeContext(sws_opts);
      sws_opts = NULL;
  #endif
 +
 +    av_dict_free(&swr_opts);
      av_dict_free(&format_opts);
      av_dict_free(&codec_opts);
      av_dict_free(&resample_opts);
@@@ -97,20 -82,6 +97,20 @@@ void log_callback_help(void *ptr, int l
      vfprintf(stdout, fmt, vl);
  }
  
 +static void log_callback_report(void *ptr, int level, const char *fmt, va_list vl)
 +{
 +    va_list vl2;
 +    char line[1024];
 +    static int print_prefix = 1;
 +
 +    va_copy(vl2, vl);
 +    av_log_default_callback(ptr, level, fmt, vl);
 +    av_log_format_line(ptr, level, fmt, vl2, line, sizeof(line), &print_prefix);
 +    va_end(vl2);
 +    fputs(line, report_file);
 +    fflush(report_file);
 +}
 +
  double parse_number_or_die(const char *context, const char *numstr, int type,
                             double min, double max)
  {
@@@ -176,10 -147,8 +176,10 @@@ void show_help_options(const OptionDef 
  void show_help_children(const AVClass *class, int flags)
  {
      const AVClass *child = NULL;
 -    av_opt_show2(&class, NULL, flags, 0);
 -    printf("\n");
 +    if (class->option) {
 +        av_opt_show2(&class, NULL, flags, 0);
 +        printf("\n");
 +    }
  
      while (child = av_opt_child_class_next(class, child))
          show_help_children(child, flags);
@@@ -298,8 -267,7 +298,8 @@@ static int write_option(void *optctx, c
          int ret = po->u.func_arg(optctx, opt, arg);
          if (ret < 0) {
              av_log(NULL, AV_LOG_ERROR,
 -                   "Failed to set value '%s' for option '%s'\n", arg, opt);
 +                   "Failed to set value '%s' for option '%s': %s\n",
 +                   arg, opt, av_err2str(ret));
              return ret;
          }
      }
@@@ -426,74 -394,34 +426,74 @@@ int locate_option(int argc, char **argv
               (po->name && !strcmp(optname, po->name)))
              return i;
  
 -        if (!po || po->flags & HAS_ARG)
 +        if (po->flags & HAS_ARG)
              i++;
      }
      return 0;
  }
  
 +static void dump_argument(const char *a)
 +{
 +    const unsigned char *p;
 +
 +    for (p = a; *p; p++)
 +        if (!((*p >= '+' && *p <= ':') || (*p >= '@' && *p <= 'Z') ||
 +              *p == '_' || (*p >= 'a' && *p <= 'z')))
 +            break;
 +    if (!*p) {
 +        fputs(a, report_file);
 +        return;
 +    }
 +    fputc('"', report_file);
 +    for (p = a; *p; p++) {
 +        if (*p == '\\' || *p == '"' || *p == '$' || *p == '`')
 +            fprintf(report_file, "\\%c", *p);
 +        else if (*p < ' ' || *p > '~')
 +            fprintf(report_file, "\\x%02x", *p);
 +        else
 +            fputc(*p, report_file);
 +    }
 +    fputc('"', report_file);
 +}
 +
  void parse_loglevel(int argc, char **argv, const OptionDef *options)
  {
      int idx = locate_option(argc, argv, options, "loglevel");
 +    const char *env;
      if (!idx)
          idx = locate_option(argc, argv, options, "v");
      if (idx && argv[idx + 1])
          opt_loglevel(NULL, "loglevel", argv[idx + 1]);
 +    idx = locate_option(argc, argv, options, "report");
 +    if ((env = getenv("FFREPORT")) || idx) {
 +        init_report(env);
 +        if (report_file) {
 +            int i;
 +            fprintf(report_file, "Command line:\n");
 +            for (i = 0; i < argc; i++) {
 +                dump_argument(argv[i]);
 +                fputc(i < argc - 1 ? ' ' : '\n', report_file);
 +            }
 +            fflush(report_file);
 +        }
 +    }
  }
  
  #define FLAGS (o->type == AV_OPT_TYPE_FLAGS) ? AV_DICT_APPEND : 0
  int opt_default(void *optctx, const char *opt, const char *arg)
  {
      const AVOption *o;
 +    int consumed = 0;
      char opt_stripped[128];
      const char *p;
      const AVClass *cc = avcodec_get_class(), *fc = avformat_get_class();
  #if CONFIG_AVRESAMPLE
      const AVClass *rc = avresample_get_class();
  #endif
 -#if CONFIG_SWSCALE
 -    const AVClass *sc = sws_get_class();
 -#endif
 +    const AVClass *sc, *swr_class;
 +
 +    if (!strcmp(opt, "debug") || !strcmp(opt, "fdebug"))
 +        av_log_set_level(AV_LOG_DEBUG);
  
      if (!(p = strchr(opt, ':')))
          p = opt + strlen(opt);
      if ((o = av_opt_find(&cc, opt_stripped, NULL, 0,
                           AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) ||
          ((opt[0] == 'v' || opt[0] == 'a' || opt[0] == 's') &&
 -         (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ))))
 +         (o = av_opt_find(&cc, opt + 1, NULL, 0, AV_OPT_SEARCH_FAKE_OBJ)))) {
          av_dict_set(&codec_opts, opt, arg, FLAGS);
 -    else if ((o = av_opt_find(&fc, opt, NULL, 0,
 -                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
 +        consumed = 1;
 +    }
 +    if ((o = av_opt_find(&fc, opt, NULL, 0,
 +                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
          av_dict_set(&format_opts, opt, arg, FLAGS);
 -#if CONFIG_AVRESAMPLE
 -    else if ((o = av_opt_find(&rc, opt, NULL, 0,
 -                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)))
 -        av_dict_set(&resample_opts, opt, arg, FLAGS);
 -#endif
 +        if (consumed)
 +            av_log(NULL, AV_LOG_VERBOSE, "Routing option %s to both codec and muxer layer\n", opt);
 +        consumed = 1;
 +    }
  #if CONFIG_SWSCALE
 -    else if ((o = av_opt_find(&sc, opt, NULL, 0,
 -                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 +    sc = sws_get_class();
 +    if (!consumed && av_opt_find(&sc, opt, NULL, 0,
 +                         AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
          // XXX we only support sws_flags, not arbitrary sws options
          int ret = av_opt_set(sws_opts, opt, arg, 0);
          if (ret < 0) {
              av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
              return ret;
          }
 +        consumed = 1;
 +    }
 +#endif
 +#if CONFIG_SWRESAMPLE
 +    swr_class = swr_get_class();
 +    if (!consumed && (o=av_opt_find(&swr_class, opt, NULL, 0,
 +                                    AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 +        struct SwrContext *swr = swr_alloc();
 +        int ret = av_opt_set(swr, opt, arg, 0);
 +        swr_free(&swr);
 +        if (ret < 0) {
 +            av_log(NULL, AV_LOG_ERROR, "Error setting option %s.\n", opt);
 +            return ret;
 +        }
 +        av_dict_set(&swr_opts, opt, arg, FLAGS);
 +        consumed = 1;
 +    }
 +#endif
 +#if CONFIG_AVRESAMPLE
 +    if ((o=av_opt_find(&rc, opt, NULL, 0,
 +                       AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ))) {
 +        av_dict_set(&resample_opts, opt, arg, FLAGS);
 +        consumed = 1;
      }
  #endif
  
 -    if (o)
 +    if (consumed)
          return 0;
      return AVERROR_OPTION_NOT_FOUND;
  }
@@@ -594,7 -497,6 +594,7 @@@ static void finish_group(OptionParseCon
  #if CONFIG_SWSCALE
      g->sws_opts    = sws_opts;
  #endif
 +    g->swr_opts    = swr_opts;
      g->codec_opts  = codec_opts;
      g->format_opts = format_opts;
      g->resample_opts = resample_opts;
  #if CONFIG_SWSCALE
      sws_opts    = NULL;
  #endif
 +    swr_opts    = NULL;
      init_opts();
  
      memset(&octx->cur_group, 0, sizeof(octx->cur_group));
@@@ -663,7 -564,6 +663,7 @@@ void uninit_parse_context(OptionParseCo
  #if CONFIG_SWSCALE
              sws_freeContext(l->groups[j].sws_opts);
  #endif
 +            av_dict_free(&l->groups[j].swr_opts);
          }
          av_freep(&l->groups);
      }
@@@ -680,7 -580,6 +680,7 @@@ int split_commandline(OptionParseContex
                        const OptionGroupDef *groups, int nb_groups)
  {
      int optindex = 1;
 +    int dashdash = -2;
  
      /* perform system-dependent conversions for arguments list */
      prepare_app_arguments(&argc, &argv);
  
          av_log(NULL, AV_LOG_DEBUG, "Reading option '%s' ...", opt);
  
 +        if (opt[0] == '-' && opt[1] == '-' && !opt[2]) {
 +            dashdash = optindex;
 +            continue;
 +        }
          /* unnamed group separators, e.g. output filename */
 -        if (opt[0] != '-' || !opt[1]) {
 +        if (opt[0] != '-' || !opt[1] || dashdash+1 == optindex) {
              finish_group(octx, 0, opt);
              av_log(NULL, AV_LOG_DEBUG, " matched as %s.\n", groups[0].name);
              continue;
@@@ -797,13 -692,6 +797,13 @@@ int opt_loglevel(void *optctx, const ch
      int level;
      int i;
  
 +    tail = strstr(arg, "repeat");
 +    av_log_set_flags(tail ? 0 : AV_LOG_SKIP_REPEATED);
 +    if (tail == arg)
 +        arg += 6 + (arg[6]=='+');
 +    if(tail && !*arg)
 +        return 0;
 +
      for (i = 0; i < FF_ARRAY_ELEMS(log_levels); i++) {
          if (!strcmp(log_levels[i].name, arg)) {
              av_log_set_level(log_levels[i].level);
      return 0;
  }
  
 +static void expand_filename_template(AVBPrint *bp, const char *template,
 +                                     struct tm *tm)
 +{
 +    int c;
 +
 +    while ((c = *(template++))) {
 +        if (c == '%') {
 +            if (!(c = *(template++)))
 +                break;
 +            switch (c) {
 +            case 'p':
 +                av_bprintf(bp, "%s", program_name);
 +                break;
 +            case 't':
 +                av_bprintf(bp, "%04d%02d%02d-%02d%02d%02d",
 +                           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 +                           tm->tm_hour, tm->tm_min, tm->tm_sec);
 +                break;
 +            case '%':
 +                av_bprint_chars(bp, c, 1);
 +                break;
 +            }
 +        } else {
 +            av_bprint_chars(bp, c, 1);
 +        }
 +    }
 +}
 +
 +static int init_report(const char *env)
 +{
 +    char *filename_template = NULL;
 +    char *key, *val;
 +    int ret, count = 0;
 +    time_t now;
 +    struct tm *tm;
 +    AVBPrint filename;
 +
 +    if (report_file) /* already opened */
 +        return 0;
 +    time(&now);
 +    tm = localtime(&now);
 +
 +    while (env && *env) {
 +        if ((ret = av_opt_get_key_value(&env, "=", ":", 0, &key, &val)) < 0) {
 +            if (count)
 +                av_log(NULL, AV_LOG_ERROR,
 +                       "Failed to parse FFREPORT environment variable: %s\n",
 +                       av_err2str(ret));
 +            break;
 +        }
 +        if (*env)
 +            env++;
 +        count++;
 +        if (!strcmp(key, "file")) {
 +            av_free(filename_template);
 +            filename_template = val;
 +            val = NULL;
 +        } else {
 +            av_log(NULL, AV_LOG_ERROR, "Unknown key '%s' in FFREPORT\n", key);
 +        }
 +        av_free(val);
 +        av_free(key);
 +    }
 +
 +    av_bprint_init(&filename, 0, 1);
 +    expand_filename_template(&filename,
 +                             av_x_if_null(filename_template, "%p-%t.log"), tm);
 +    av_free(filename_template);
 +    if (!av_bprint_is_complete(&filename)) {
 +        av_log(NULL, AV_LOG_ERROR, "Out of memory building report file name\n");
 +        return AVERROR(ENOMEM);
 +    }
 +
 +    report_file = fopen(filename.str, "w");
 +    if (!report_file) {
 +        av_log(NULL, AV_LOG_ERROR, "Failed to open report \"%s\": %s\n",
 +               filename.str, strerror(errno));
 +        return AVERROR(errno);
 +    }
 +    av_log_set_callback(log_callback_report);
 +    av_log(NULL, AV_LOG_INFO,
 +           "%s started on %04d-%02d-%02d at %02d:%02d:%02d\n"
 +           "Report written to \"%s\"\n",
 +           program_name,
 +           tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
 +           tm->tm_hour, tm->tm_min, tm->tm_sec,
 +           filename.str);
 +    av_log_set_level(FFMAX(av_log_get_level(), AV_LOG_VERBOSE));
 +    av_bprint_finalize(&filename, NULL);
 +    return 0;
 +}
 +
 +int opt_report(const char *opt)
 +{
 +    return init_report(NULL);
 +}
 +
 +int opt_max_alloc(void *optctx, const char *opt, const char *arg)
 +{
 +    char *tail;
 +    size_t max;
 +
 +    max = strtol(arg, &tail, 10);
 +    if (*tail) {
 +        av_log(NULL, AV_LOG_FATAL, "Invalid max_alloc \"%s\".\n", arg);
 +        exit(1);
 +    }
 +    av_max_alloc(max);
 +    return 0;
 +}
 +
 +int opt_cpuflags(void *optctx, const char *opt, const char *arg)
 +{
 +    int ret;
 +    unsigned flags = av_get_cpu_flags();
 +
 +    if ((ret = av_parse_cpu_caps(&flags, arg)) < 0)
 +        return ret;
 +
 +    av_force_cpu_flags(flags);
 +    return 0;
 +}
 +
  int opt_timelimit(void *optctx, const char *opt, const char *arg)
  {
  #if HAVE_SETRLIMIT
      return 0;
  }
  
 +#if CONFIG_OPENCL
 +int opt_opencl(void *optctx, const char *opt, const char *arg)
 +{
 +    char *key, *value;
 +    const char *opts = arg;
 +    int ret = 0;
 +    while (*opts) {
 +        ret = av_opt_get_key_value(&opts, "=", ":", 0, &key, &value);
 +        if (ret < 0)
 +            return ret;
 +        ret = av_opencl_set_option(key, value);
 +        if (ret < 0)
 +            return ret;
 +        if (*opts)
 +            opts++;
 +    }
 +    return ret;
 +}
 +#endif
 +
  void print_error(const char *filename, int err)
  {
      char errbuf[128];
@@@ -994,7 -739,6 +994,7 @@@ static int warned_cfg = 0
  #define INDENT        1
  #define SHOW_VERSION  2
  #define SHOW_CONFIG   4
 +#define SHOW_COPYRIGHT 8
  
  #define PRINT_LIB_INFO(libname, LIBNAME, flags, level)                  \
      if (CONFIG_##LIBNAME) {                                             \
          if (flags & SHOW_VERSION) {                                     \
              unsigned int version = libname##_version();                 \
              av_log(NULL, level,                                         \
 -                   "%slib%-10s %2d.%3d.%2d / %2d.%3d.%2d\n",            \
 +                   "%slib%-11s %2d.%3d.%3d / %2d.%3d.%3d\n",            \
                     indent, #libname,                                    \
                     LIB##LIBNAME##_VERSION_MAJOR,                        \
                     LIB##LIBNAME##_VERSION_MINOR,                        \
          }                                                               \
          if (flags & SHOW_CONFIG) {                                      \
              const char *cfg = libname##_configuration();                \
 -            if (strcmp(LIBAV_CONFIGURATION, cfg)) {                     \
 +            if (strcmp(FFMPEG_CONFIGURATION, cfg)) {                    \
                  if (!warned_cfg) {                                      \
                      av_log(NULL, level,                                 \
                              "%sWARNING: library configuration mismatch\n", \
@@@ -1033,40 -777,24 +1033,40 @@@ static void print_all_libs_info(int fla
      PRINT_LIB_INFO(avfilter, AVFILTER, flags, level);
      PRINT_LIB_INFO(avresample, AVRESAMPLE, flags, level);
      PRINT_LIB_INFO(swscale,  SWSCALE,  flags, level);
 +    PRINT_LIB_INFO(swresample,SWRESAMPLE,  flags, level);
 +    PRINT_LIB_INFO(postproc, POSTPROC, flags, level);
  }
  
 -void show_banner(void)
 +static void print_program_info(int flags, int level)
  {
 -    av_log(NULL, AV_LOG_INFO,
 -           "%s version " LIBAV_VERSION ", Copyright (c) %d-%d the Libav developers\n",
 -           program_name, program_birth_year, this_year);
 -    av_log(NULL, AV_LOG_INFO, "  built on %s %s with %s\n",
 -           __DATE__, __TIME__, CC_IDENT);
 -    av_log(NULL, AV_LOG_VERBOSE, "  configuration: " LIBAV_CONFIGURATION "\n");
 -    print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_VERBOSE);
 -    print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_VERBOSE);
 +    const char *indent = flags & INDENT? "  " : "";
 +
 +    av_log(NULL, level, "%s version " FFMPEG_VERSION, program_name);
 +    if (flags & SHOW_COPYRIGHT)
 +        av_log(NULL, level, " Copyright (c) %d-%d the FFmpeg developers",
 +               program_birth_year, this_year);
 +    av_log(NULL, level, "\n");
 +    av_log(NULL, level, "%sbuilt on %s %s with %s\n",
 +           indent, __DATE__, __TIME__, CC_IDENT);
 +
 +    av_log(NULL, level, "%sconfiguration: " FFMPEG_CONFIGURATION "\n", indent);
 +}
 +
 +void show_banner(int argc, char **argv, const OptionDef *options)
 +{
 +    int idx = locate_option(argc, argv, options, "version");
 +    if (idx)
 +        return;
 +
 +    print_program_info (INDENT|SHOW_COPYRIGHT, AV_LOG_INFO);
 +    print_all_libs_info(INDENT|SHOW_CONFIG,  AV_LOG_INFO);
 +    print_all_libs_info(INDENT|SHOW_VERSION, AV_LOG_INFO);
  }
  
  int show_version(void *optctx, const char *opt, const char *arg)
  {
      av_log_set_callback(log_callback_help);
 -    printf("%s " LIBAV_VERSION "\n", program_name);
 +    print_program_info (0           , AV_LOG_INFO);
      print_all_libs_info(SHOW_VERSION, AV_LOG_INFO);
  
      return 0;
  
  int show_license(void *optctx, const char *opt, const char *arg)
  {
 -    printf(
  #if CONFIG_NONFREE
 +    printf(
      "This version of %s has nonfree parts compiled in.\n"
      "Therefore it is not legally redistributable.\n",
 -    program_name
 +    program_name );
  #elif CONFIG_GPLV3
 +    printf(
      "%s is free software; you can redistribute it and/or modify\n"
      "it under the terms of the GNU General Public License as published by\n"
      "the Free Software Foundation; either version 3 of the License, or\n"
      "\n"
      "You should have received a copy of the GNU General Public License\n"
      "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 -    program_name, program_name, program_name
 +    program_name, program_name, program_name );
  #elif CONFIG_GPL
 +    printf(
      "%s is free software; you can redistribute it and/or modify\n"
      "it under the terms of the GNU General Public License as published by\n"
      "the Free Software Foundation; either version 2 of the License, or\n"
      "You should have received a copy of the GNU General Public License\n"
      "along with %s; if not, write to the Free Software\n"
      "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 -    program_name, program_name, program_name
 +    program_name, program_name, program_name );
  #elif CONFIG_LGPLV3
 +    printf(
      "%s is free software; you can redistribute it and/or modify\n"
      "it under the terms of the GNU Lesser General Public License as published by\n"
      "the Free Software Foundation; either version 3 of the License, or\n"
      "\n"
      "You should have received a copy of the GNU Lesser General Public License\n"
      "along with %s.  If not, see <http://www.gnu.org/licenses/>.\n",
 -    program_name, program_name, program_name
 +    program_name, program_name, program_name );
  #else
 +    printf(
      "%s is free software; you can redistribute it and/or\n"
      "modify it under the terms of the GNU Lesser General Public\n"
      "License as published by the Free Software Foundation; either\n"
      "You should have received a copy of the GNU Lesser General Public\n"
      "License along with %s; if not, write to the Free Software\n"
      "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n",
 -    program_name, program_name, program_name
 +    program_name, program_name, program_name );
  #endif
 -    );
  
      return 0;
  }
@@@ -1196,7 -921,7 +1196,7 @@@ int show_formats(void *optctx, const ch
  
  #define PRINT_CODEC_SUPPORTED(codec, field, type, list_name, term, get_name) \
      if (codec->field) {                                                      \
 -        const type *p = c->field;                                            \
 +        const type *p = codec->field;                                        \
                                                                               \
          printf("    Supported " list_name ":");                              \
          while (*p != term) {                                                 \
@@@ -1258,9 -983,7 +1258,9 @@@ static char get_media_type_char(enum AV
      switch (type) {
          case AVMEDIA_TYPE_VIDEO:    return 'V';
          case AVMEDIA_TYPE_AUDIO:    return 'A';
 +        case AVMEDIA_TYPE_DATA:     return 'D';
          case AVMEDIA_TYPE_SUBTITLE: return 'S';
 +        case AVMEDIA_TYPE_ATTACHMENT:return 'T';
          default:                    return '?';
      }
  }
@@@ -1276,36 -999,6 +1276,36 @@@ static const AVCodec *next_codec_for_id
      return NULL;
  }
  
 +static int compare_codec_desc(const void *a, const void *b)
 +{
 +    const AVCodecDescriptor * const *da = a;
 +    const AVCodecDescriptor * const *db = b;
 +
 +    return (*da)->type != (*db)->type ? (*da)->type - (*db)->type :
 +           strcmp((*da)->name, (*db)->name);
 +}
 +
 +static unsigned get_codecs_sorted(const AVCodecDescriptor ***rcodecs)
 +{
 +    const AVCodecDescriptor *desc = NULL;
 +    const AVCodecDescriptor **codecs;
 +    unsigned nb_codecs = 0, i = 0;
 +
 +    while ((desc = avcodec_descriptor_next(desc)))
 +        nb_codecs++;
 +    if (!(codecs = av_calloc(nb_codecs, sizeof(*codecs)))) {
 +        av_log(NULL, AV_LOG_ERROR, "Out of memory\n");
 +        exit(1);
 +    }
 +    desc = NULL;
 +    while ((desc = avcodec_descriptor_next(desc)))
 +        codecs[i++] = desc;
 +    av_assert0(i == nb_codecs);
 +    qsort(codecs, nb_codecs, sizeof(*codecs), compare_codec_desc);
 +    *rcodecs = codecs;
 +    return nb_codecs;
 +}
 +
  static void print_codecs_for_id(enum AVCodecID id, int encoder)
  {
      const AVCodec *codec = NULL;
  
  int show_codecs(void *optctx, const char *opt, const char *arg)
  {
 -    const AVCodecDescriptor *desc = NULL;
 +    const AVCodecDescriptor **codecs;
 +    unsigned i, nb_codecs = get_codecs_sorted(&codecs);
  
      printf("Codecs:\n"
             " D..... = Decoding supported\n"
             " ....L. = Lossy compression\n"
             " .....S = Lossless compression\n"
             " -------\n");
 -    while ((desc = avcodec_descriptor_next(desc))) {
 +    for (i = 0; i < nb_codecs; i++) {
 +        const AVCodecDescriptor *desc = codecs[i];
          const AVCodec *codec = NULL;
  
 +        printf(" ");
          printf(avcodec_find_decoder(desc->id) ? "D" : ".");
          printf(avcodec_find_encoder(desc->id) ? "E" : ".");
  
  
          printf("\n");
      }
 +    av_free(codecs);
      return 0;
  }
  
  static void print_codecs(int encoder)
  {
 -    const AVCodecDescriptor *desc = NULL;
 +    const AVCodecDescriptor **codecs;
 +    unsigned i, nb_codecs = get_codecs_sorted(&codecs);
  
      printf("%s:\n"
 -           " V... = Video\n"
 -           " A... = Audio\n"
 -           " S... = Subtitle\n"
 -           " .F.. = Frame-level multithreading\n"
 -           " ..S. = Slice-level multithreading\n"
 -           " ...X = Codec is experimental\n"
 -           " ---\n",
 +           " V..... = Video\n"
 +           " A..... = Audio\n"
 +           " S..... = Subtitle\n"
 +           " .F.... = Frame-level multithreading\n"
 +           " ..S... = Slice-level multithreading\n"
 +           " ...X.. = Codec is experimental\n"
 +           " ....B. = Supports draw_horiz_band\n"
 +           " .....D = Supports direct rendering method 1\n"
 +           " ------\n",
             encoder ? "Encoders" : "Decoders");
 -    while ((desc = avcodec_descriptor_next(desc))) {
 +    for (i = 0; i < nb_codecs; i++) {
 +        const AVCodecDescriptor *desc = codecs[i];
          const AVCodec *codec = NULL;
  
          while ((codec = next_codec_for_id(desc->id, codec, encoder))) {
 -            printf("%c", get_media_type_char(desc->type));
 +            printf(" %c", get_media_type_char(desc->type));
              printf((codec->capabilities & CODEC_CAP_FRAME_THREADS) ? "F" : ".");
              printf((codec->capabilities & CODEC_CAP_SLICE_THREADS) ? "S" : ".");
              printf((codec->capabilities & CODEC_CAP_EXPERIMENTAL)  ? "X" : ".");
 +            printf((codec->capabilities & CODEC_CAP_DRAW_HORIZ_BAND)?"B" : ".");
 +            printf((codec->capabilities & CODEC_CAP_DR1)           ? "D" : ".");
  
              printf(" %-20s %s", codec->name, codec->long_name ? codec->long_name : "");
              if (strcmp(codec->name, desc->name))
              printf("\n");
          }
      }
 +    av_free(codecs);
  }
  
  int show_decoders(void *optctx, const char *opt, const char *arg)
@@@ -1449,38 -1131,11 +1449,38 @@@ int show_protocols(void *optctx, const 
  int show_filters(void *optctx, const char *opt, const char *arg)
  {
      const AVFilter av_unused(*filter) = NULL;
 -
 -    printf("Filters:\n");
 +    char descr[64], *descr_cur;
 +    int i, j;
 +    const AVFilterPad *pad;
 +
 +    printf("Filters:\n"
 +           "  T = Timeline support\n"
 +           "  A = Audio input/output\n"
 +           "  V = Video input/output\n"
 +           "  N = Dynamic number and/or type of input/output\n"
 +           "  | = Source or sink filter\n");
  #if CONFIG_AVFILTER
 -    while ((filter = avfilter_next(filter)))
 -        printf("%-16s %s\n", filter->name, filter->description);
 +    while ((filter = avfilter_next(filter))) {
 +        descr_cur = descr;
 +        for (i = 0; i < 2; i++) {
 +            if (i) {
 +                *(descr_cur++) = '-';
 +                *(descr_cur++) = '>';
 +            }
 +            pad = i ? filter->outputs : filter->inputs;
 +            for (j = 0; pad && pad[j].name; j++) {
 +                if (descr_cur >= descr + sizeof(descr) - 4)
 +                    break;
 +                *(descr_cur++) = get_media_type_char(pad[j].type);
 +            }
 +            if (!j)
 +                *(descr_cur++) = ((!i && (filter->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)) ||
 +                                  ( i && (filter->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS))) ? 'N' : '|';
 +        }
 +        *descr_cur = 0;
 +        printf(" %c %-16s %-10s %s\n", filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE ? 'T' : '.',
 +               filter->name, descr, filter->description);
 +    }
  #endif
      return 0;
  }
@@@ -1518,35 -1173,6 +1518,35 @@@ int show_pix_fmts(void *optctx, const c
      return 0;
  }
  
 +int show_layouts(void *optctx, const char *opt, const char *arg)
 +{
 +    int i = 0;
 +    uint64_t layout, j;
 +    const char *name, *descr;
 +
 +    printf("Individual channels:\n"
 +           "NAME        DESCRIPTION\n");
 +    for (i = 0; i < 63; i++) {
 +        name = av_get_channel_name((uint64_t)1 << i);
 +        if (!name)
 +            continue;
 +        descr = av_get_channel_description((uint64_t)1 << i);
 +        printf("%-12s%s\n", name, descr);
 +    }
 +    printf("\nStandard channel layouts:\n"
 +           "NAME        DECOMPOSITION\n");
 +    for (i = 0; !av_get_standard_channel_layout(i, &layout, &name); i++) {
 +        if (name) {
 +            printf("%-12s", name);
 +            for (j = 1; j; j <<= 1)
 +                if ((layout & j))
 +                    printf("%s%s", (layout & (j - 1)) ? "+" : "", av_get_channel_name(j));
 +            printf("\n");
 +        }
 +    }
 +    return 0;
 +}
 +
  int show_sample_fmts(void *optctx, const char *opt, const char *arg)
  {
      int i;
@@@ -1580,13 -1206,13 +1580,13 @@@ static void show_help_codec(const char 
          }
  
          if (!printed) {
 -            av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to Libav, "
 -                   "but no %s for it are available. Libav might need to be "
 +            av_log(NULL, AV_LOG_ERROR, "Codec '%s' is known to FFmpeg, "
 +                   "but no %s for it are available. FFmpeg might need to be "
                     "recompiled with additional external libraries.\n",
                     name, encoder ? "encoders" : "decoders");
          }
      } else {
 -        av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by Libav.\n",
 +        av_log(NULL, AV_LOG_ERROR, "Codec '%s' is not recognized by FFmpeg.\n",
                 name);
      }
  }
@@@ -1645,7 -1271,6 +1645,7 @@@ static void show_help_muxer(const char 
  #if CONFIG_AVFILTER
  static void show_help_filter(const char *name)
  {
 +#if CONFIG_AVFILTER
      const AVFilter *f = avfilter_get_by_name(name);
      int i, count;
  
          return;
      }
  
 -    printf("Filter %s [%s]:\n", f->name, f->description);
 +    printf("Filter %s\n", f->name);
 +    if (f->description)
 +        printf("  %s\n", f->description);
+     if (f->flags & AVFILTER_FLAG_SLICE_THREADS)
+         printf("    slice threading supported\n");
      printf("    Inputs:\n");
      count = avfilter_pad_count(f->inputs);
      for (i = 0; i < count; i++) {
 -        printf("        %d %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
 +        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->inputs, i),
                 media_type_string(avfilter_pad_get_type(f->inputs, i)));
      }
      if (f->flags & AVFILTER_FLAG_DYNAMIC_INPUTS)
          printf("        dynamic (depending on the options)\n");
 +    else if (!count)
 +        printf("        none (source filter)\n");
  
      printf("    Outputs:\n");
      count = avfilter_pad_count(f->outputs);
      for (i = 0; i < count; i++) {
 -        printf("        %d %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
 +        printf("       #%d: %s (%s)\n", i, avfilter_pad_get_name(f->outputs, i),
                 media_type_string(avfilter_pad_get_type(f->outputs, i)));
      }
      if (f->flags & AVFILTER_FLAG_DYNAMIC_OUTPUTS)
          printf("        dynamic (depending on the options)\n");
 +    else if (!count)
 +        printf("        none (sink filter)\n");
  
      if (f->priv_class)
 -        show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM |
 +        show_help_children(f->priv_class, AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
                                            AV_OPT_FLAG_AUDIO_PARAM);
 +    if (f->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)
 +        printf("This filter has support for timeline through the 'enable' option.\n");
 +#else
 +    av_log(NULL, AV_LOG_ERROR, "Build without libavfilter; "
 +           "can not to satisfy request\n");
 +#endif
  }
  #endif
  
@@@ -1750,11 -1367,6 +1754,11 @@@ int cmdutils_read_file(const char *file
      fseek(f, 0, SEEK_END);
      *size = ftell(f);
      fseek(f, 0, SEEK_SET);
 +    if (*size == (size_t)-1) {
 +        av_log(NULL, AV_LOG_ERROR, "IO error: %s\n", strerror(errno));
 +        fclose(f);
 +        return AVERROR(errno);
 +    }
      *bufptr = av_malloc(*size + 1);
      if (!*bufptr) {
          av_log(NULL, AV_LOG_ERROR, "Could not allocate file buffer\n");
      return ret;
  }
  
 -void init_pts_correction(PtsCorrectionContext *ctx)
 -{
 -    ctx->num_faulty_pts = ctx->num_faulty_dts = 0;
 -    ctx->last_pts = ctx->last_dts = INT64_MIN;
 -}
 -
 -int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts,
 -                          int64_t dts)
 -{
 -    int64_t pts = AV_NOPTS_VALUE;
 -
 -    if (dts != AV_NOPTS_VALUE) {
 -        ctx->num_faulty_dts += dts <= ctx->last_dts;
 -        ctx->last_dts = dts;
 -    }
 -    if (reordered_pts != AV_NOPTS_VALUE) {
 -        ctx->num_faulty_pts += reordered_pts <= ctx->last_pts;
 -        ctx->last_pts = reordered_pts;
 -    }
 -    if ((ctx->num_faulty_pts<=ctx->num_faulty_dts || dts == AV_NOPTS_VALUE)
 -        && reordered_pts != AV_NOPTS_VALUE)
 -        pts = reordered_pts;
 -    else
 -        pts = dts;
 -
 -    return pts;
 -}
 -
  FILE *get_preset_file(char *filename, size_t filename_size,
                        const char *preset_name, int is_path,
                        const char *codec_name)
  {
      FILE *f = NULL;
      int i;
 -    const char *base[3] = { getenv("AVCONV_DATADIR"),
 +    const char *base[3] = { getenv("FFMPEG_DATADIR"),
                              getenv("HOME"),
 -                            AVCONV_DATADIR, };
 +                            FFMPEG_DATADIR, };
  
      if (is_path) {
          av_strlcpy(filename, preset_name, filename_size);
          f = fopen(filename, "r");
      } else {
 +#ifdef _WIN32
 +        char datadir[MAX_PATH], *ls;
 +        base[2] = NULL;
 +
 +        if (GetModuleFileNameA(GetModuleHandleA(NULL), datadir, sizeof(datadir) - 1))
 +        {
 +            for (ls = datadir; ls < datadir + strlen(datadir); ls++)
 +                if (*ls == '\\') *ls = '/';
 +
 +            if (ls = strrchr(datadir, '/'))
 +            {
 +                *ls = 0;
 +                strncat(datadir, "/ffpresets",  sizeof(datadir) - 1 - strlen(datadir));
 +                base[2] = datadir;
 +            }
 +        }
 +#endif
          for (i = 0; i < 3 && !f; i++) {
              if (!base[i])
                  continue;
 -            snprintf(filename, filename_size, "%s%s/%s.avpreset", base[i],
 -                     i != 1 ? "" : "/.avconv", preset_name);
 +            snprintf(filename, filename_size, "%s%s/%s.ffpreset", base[i],
 +                     i != 1 ? "" : "/.ffmpeg", preset_name);
              f = fopen(filename, "r");
              if (!f && codec_name) {
                  snprintf(filename, filename_size,
 -                         "%s%s/%s-%s.avpreset",
 -                         base[i], i != 1 ? "" : "/.avconv", codec_name,
 +                         "%s%s/%s-%s.ffpreset",
 +                         base[i], i != 1 ? "" : "/.ffmpeg", codec_name,
                           preset_name);
                  f = fopen(filename, "r");
              }
  
  int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
  {
 -    if (*spec <= '9' && *spec >= '0') /* opt:index */
 -        return strtol(spec, NULL, 0) == st->index;
 -    else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
 -             *spec == 't') { /* opt:[vasdt] */
 -        enum AVMediaType type;
 -
 -        switch (*spec++) {
 -        case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
 -        case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
 -        case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
 -        case 'd': type = AVMEDIA_TYPE_DATA;       break;
 -        case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
 -        default:  av_assert0(0);
 -        }
 -        if (type != st->codec->codec_type)
 -            return 0;
 -        if (*spec++ == ':') { /* possibly followed by :index */
 -            int i, index = strtol(spec, NULL, 0);
 -            for (i = 0; i < s->nb_streams; i++)
 -                if (s->streams[i]->codec->codec_type == type && index-- == 0)
 -                   return i == st->index;
 -            return 0;
 -        }
 -        return 1;
 -    } else if (*spec == 'p' && *(spec + 1) == ':') {
 -        int prog_id, i, j;
 -        char *endptr;
 -        spec += 2;
 -        prog_id = strtol(spec, &endptr, 0);
 -        for (i = 0; i < s->nb_programs; i++) {
 -            if (s->programs[i]->id != prog_id)
 -                continue;
 -
 -            if (*endptr++ == ':') {
 -                int stream_idx = strtol(endptr, NULL, 0);
 -                return stream_idx >= 0 &&
 -                    stream_idx < s->programs[i]->nb_stream_indexes &&
 -                    st->index == s->programs[i]->stream_index[stream_idx];
 -            }
 -
 -            for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
 -                if (st->index == s->programs[i]->stream_index[j])
 -                    return 1;
 -        }
 -        return 0;
 -    } else if (!*spec) /* empty specifier, matches everything */
 -        return 1;
 -
 -    av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
 -    return AVERROR(EINVAL);
 +    int ret = avformat_match_stream_specifier(s, st, spec);
 +    if (ret < 0)
 +        av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
 +    return ret;
  }
  
  AVDictionary *filter_codec_opts(AVDictionary *opts, enum AVCodecID codec_id,
@@@ -1931,3 -1600,15 +1935,3 @@@ void *grow_array(void *array, int elem_
      }
      return array;
  }
 -
 -const char *media_type_string(enum AVMediaType media_type)
 -{
 -    switch (media_type) {
 -    case AVMEDIA_TYPE_VIDEO:      return "video";
 -    case AVMEDIA_TYPE_AUDIO:      return "audio";
 -    case AVMEDIA_TYPE_DATA:       return "data";
 -    case AVMEDIA_TYPE_SUBTITLE:   return "subtitle";
 -    case AVMEDIA_TYPE_ATTACHMENT: return "attachment";
 -    default:                      return "unknown";
 -    }
 -}
diff --combined doc/APIchanges
@@@ -1,5 -1,5 +1,5 @@@
  Never assume the API of libav* to be stable unless at least 1 month has passed
 -since the last major version increase.
 +since the last major version increase or the API was added.
  
  The last version increases were:
  libavcodec:    2013-03-xx
@@@ -7,182 -7,25 +7,189 @@@ libavdevice:   2013-03-x
  libavfilter:   2012-06-22
  libavformat:   2013-03-xx
  libavresample: 2012-10-05
 +libpostproc:   2011-04-18
 +libswresample: 2011-09-19
  libswscale:    2011-06-20
  libavutil:     2012-10-22
  
  
  API changes, most recent first:
  
 -2013-05-xx - xxxxxxx - lavfi 3.10.0 - avfilter.h
 +
++2013-05-24 - xxxxxxx - lavfi 3.70.100 - avfilter.h
+   Add support for slice multithreading to lavfi. Filters supporting threading
+   are marked with AVFILTER_FLAG_SLICE_THREADS.
+   New fields AVFilterContext.thread_type, AVFilterGraph.thread_type and
+   AVFilterGraph.nb_threads (accessible directly or through AVOptions) may be
+   used to configure multithreading.
 -2013-xx-xx - xxxxxxx - lavu 52.12.0 - cpu.h
 +2013-05-24 - xxxxxxx - lavu 52.34.100 - cpu.h
    Add av_cpu_count() function for getting the number of logical CPUs.
  
 -2013-05-xx - xxxxxxx - lavc 55.7.0 - avcodec.h
 +2013-05-24 - xxxxxxx - lavc 55.12.100 - avcodec.h
    Add picture_structure to AVCodecParserContext.
  
 +2013-05-17 - xxxxxxx - lavu 52.33.100 - opt.h
 +  Add AV_OPT_TYPE_COLOR value to AVOptionType enum.
 +
 +2013-05-13 - xxxxxxx - lavu 52.31.100 - mem.h
 +  Add av_dynarray2_add().
 +
 +2013-05-12 - xxxxxxx - lavfi 3.65.100
 +  Add AVFILTER_FLAG_SUPPORT_TIMELINE* filter flags.
 +
 +2013-04-19 - xxxxxxx - lavc 55.4.100
 +  Add AV_CODEC_PROP_TEXT_SUB property for text based subtitles codec.
 +
 +2013-04-18 - xxxxxxx - lavf 55.3.100
 +  The matroska demuxer can now output proper verbatim ASS packets. It will
 +  become the default starting lavf 56.0.100.
 +
 +2013-04-10 - xxxxxxx - lavu 25.26.100 - avutil.h,opt.h
 +  Add av_int_list_length()
 +  and av_opt_set_int_list().
 +
 +2013-03-30 - xxxxxxx - lavu 52.24.100 - samplefmt.h
 +  Add av_samples_alloc_array_and_samples().
 +
 +2013-03-29 - xxxxxxx - lavf 55.1.100 - avformat.h
 +  Add av_guess_frame_rate()
 +
 +2013-03-20 - xxxxxxx - lavu 52.22.100 - opt.h
 +  Add AV_OPT_TYPE_DURATION value to AVOptionType enum.
 +
 +2013-03-17 - xxxxxx - lavu 52.20.100 - opt.h
 +  Add AV_OPT_TYPE_VIDEO_RATE value to AVOptionType enum.
 +
 +2013-03-07 - xxxxxx - lavu 52.18.100 - avstring.h,bprint.h
 +  Add av_escape() and av_bprint_escape() API.
 +
 +2013-02-24 - xxxxxx - lavfi 3.41.100 - buffersink.h
 +  Add sample_rates field to AVABufferSinkParams.
 +
 +2013-01-17 - a1a707f - lavf 54.61.100
 +  Add av_codec_get_tag2().
 +
 +2013-01-01 - 2eb2e17 - lavfi 3.34.100
 +  Add avfilter_get_audio_buffer_ref_from_arrays_channels.
 +
 +2012-12-20 - 34de47aa - lavfi 3.29.100 - avfilter.h
 +  Add AVFilterLink.channels, avfilter_link_get_channels()
 +  and avfilter_ref_get_channels().
 +
 +2012-12-15 - 2ada584d - lavc 54.80.100 - avcodec.h
 +  Add pkt_size field to AVFrame.
 +
 +2012-11-25 - c70ec631 - lavu 52.9.100 - opt.h
 +  Add the following convenience functions to opt.h:
 +   av_opt_get_image_size
 +   av_opt_get_pixel_fmt
 +   av_opt_get_sample_fmt
 +   av_opt_set_image_size
 +   av_opt_set_pixel_fmt
 +   av_opt_set_sample_fmt
 +
 +2012-11-17 - 4cd74c81 - lavu 52.8.100 - bprint.h
 +  Add av_bprint_strftime().
 +
 +2012-11-15 - 92648107 - lavu 52.7.100 - opt.h
 +  Add av_opt_get_key_value().
 +
 +2012-11-13 - 79456652 - lavfi 3.23.100 - avfilter.h
 +  Add channels field to AVFilterBufferRefAudioProps.
 +
 +2012-11-03 - 481fdeee - lavu 52.3.100 - opt.h
 +  Add AV_OPT_TYPE_SAMPLE_FMT value to AVOptionType enum.
 +
 +2012-10-21 - 6fb2fd8 - lavc  54.68.100 - avcodec.h
 +                       lavfi  3.20.100 - avfilter.h
 +  Add AV_PKT_DATA_STRINGS_METADATA side data type, used to transmit key/value
 +  strings between AVPacket and AVFrame, and add metadata field to
 +  AVCodecContext (which shall not be accessed by users; see AVFrame metadata
 +  instead).
 +
 +2012-09-27 - a70b493 - lavd 54.3.100 - version.h
 +  Add LIBAVDEVICE_IDENT symbol.
 +
 +2012-09-27 - a70b493 - lavfi 3.18.100 - version.h
 +  Add LIBAVFILTER_IDENT symbol.
 +
 +2012-09-27 - a70b493 - libswr 0.16.100 - version.h
 +  Add LIBSWRESAMPLE_VERSION, LIBSWRESAMPLE_BUILD
 +  and LIBSWRESAMPLE_IDENT symbols.
 +
 +2012-09-06 - 29e972f - lavu 51.72.100 - parseutils.h
 +  Add av_small_strptime() time parsing function.
 +
 +  Can be used as a stripped-down replacement for strptime(), on
 +  systems which do not support it.
 +
 +2012-08-25 - 2626cc4 - lavf 54.28.100
 +  Matroska demuxer now identifies SRT subtitles as AV_CODEC_ID_SUBRIP instead
 +  of AV_CODEC_ID_TEXT.
 +
 +2012-08-13 - 5c0d8bc - lavfi 3.8.100 - avfilter.h
 +  Add avfilter_get_class() function, and priv_class field to AVFilter
 +  struct.
 +
 +2012-08-12 - a25346e - lavu 51.69.100 - opt.h
 +  Add AV_OPT_FLAG_FILTERING_PARAM symbol in opt.h.
 +
 +2012-07-31 - 23fc4dd - lavc 54.46.100
 +  Add channels field to AVFrame.
 +
 +2012-07-30 - f893904 - lavu 51.66.100
 +  Add av_get_channel_description()
 +  and av_get_standard_channel_layout() functions.
 +
 +2012-07-21 - 016a472 - lavc 54.43.100
 +  Add decode_error_flags field to AVFrame.
 +
 +2012-07-20 - b062936 - lavf 54.18.100
 +  Add avformat_match_stream_specifier() function.
 +
 +2012-07-14 - f49ec1b - lavc 54.38.100 - avcodec.h
 +  Add metadata to AVFrame, and the accessor functions
 +  av_frame_get_metadata() and av_frame_set_metadata().
 +
 +2012-07-10 - 0e003d8 - lavc 54.33.100
 +  Add av_fast_padded_mallocz().
 +
 +2012-07-10 - 21d5609 - lavfi 3.2.0 - avfilter.h
 +  Add init_opaque() callback to AVFilter struct.
 +
 +2012-06-26 - e6674e4 - lavu 51.63.100 - imgutils.h
 +  Add functions to libavutil/imgutils.h:
 +  av_image_get_buffer_size()
 +  av_image_fill_arrays()
 +  av_image_copy_to_buffer()
 +
 +2012-06-24 - c41899a - lavu 51.62.100 - version.h
 +  version moved from avutil.h to version.h
 +
 +2012-04-11 - 359abb1 - lavu 51.58.100 - error.h
 +  Add av_make_error_string() and av_err2str() utilities to
 +  libavutil/error.h.
 +
 +2012-06-05 - 62b39d4 - lavc 54.24.100
 +  Add pkt_duration field to AVFrame.
 +
 +2012-05-24 - f2ee065 - lavu 51.54.100
 +  Move AVPALETTE_SIZE and AVPALETTE_COUNT macros from
 +  libavcodec/avcodec.h to libavutil/pixfmt.h.
 +
 +2012-05-14 - 94a9ac1 - lavf 54.5.100
 +  Add av_guess_sample_aspect_ratio() function.
 +
 +2012-04-20 - 65fa7bc - lavfi 2.70.100
 +  Add avfilter_unref_bufferp() to avfilter.h.
 +
 +2012-04-13 - 162e400 - lavfi 2.68.100
 +  Install libavfilter/asrc_abuffer.h public header.
 +
 +2012-03-26 - a67d9cf - lavfi 2.66.100
 +  Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
 +
  2013-05-xx - xxxxxxx - lavu 52.11.0 - pixdesc.h
    Replace PIX_FMT_* flags with AV_PIX_FMT_FLAG_*.
  
@@@ -269,40 -112,41 +276,40 @@@ lavd 54.0.0, lavfi 3.5.
  2013-01-15 - 8ee288d - lavu 52.5.0 - hmac.h
    Add AVHMAC.
  
 -2013-01-13 - 44e065d - lavc 54.36.0 - vdpau.h
 +2013-01-13 - 44e065d - lavc 54.87.100 / 54.36.0 - vdpau.h
    Add AVVDPAUContext struct for VDPAU hardware-accelerated decoding.
  
 -2013-01-12 - 169fb94 - lavu 52.4.0 - pixdesc.h
 +2013-01-12 - dae382b / 169fb94 - lavu 52.14.100 / 52.4.0 - pixdesc.h
    Add AV_PIX_FMT_VDPAU flag.
  
 -2013-01-07 - 074a00d - lavr 1.1.0
 +2013-01-07 - 249fca3 / 074a00d - lavr 1.1.0
    Add avresample_set_channel_mapping() for input channel reordering,
    duplication, and silencing.
  
 -2012-12-29 - d8fd06c - lavu 52.3.0 - avstring.h
 +2012-12-29 - 2ce43b3 / d8fd06c - lavu 52.13.100 / 52.3.0 - avstring.h
    Add av_basename() and av_dirname().
  
 -2012-11-11 - 5980f5d - lavu 52.2.0 - audioconvert.h
 +2012-11-11 - 03b0787 / 5980f5d - lavu 52.6.100 / 52.2.0 - audioconvert.h
    Rename audioconvert.h to channel_layout.h. audioconvert.h is now deprecated.
  
 -2012-11-05 - dfde8a3 - lavu 52.1.0 - intmath.h
 +2012-11-05 - 7d26be6 / dfde8a3 - lavu 52.5.100 / 52.1.0 - intmath.h
    Add av_ctz() for trailing zero bit count
  
 -2012-10-21 - a893655 - lavu 51.45.0 - error.h
 +2012-10-21 - e3a91c5 / a893655 - lavu 51.77.100 / 51.45.0 - error.h
    Add AVERROR_EXPERIMENTAL
  
 -2012-10-12 - d2fcb35 - lavu 51.44.0 - pixdesc.h
 +2012-10-12 - a33ed6b / d2fcb35 - lavu 51.76.100 / 51.44.0 - pixdesc.h
    Add functions for accessing pixel format descriptors.
    Accessing the av_pix_fmt_descriptors array directly is now
    deprecated.
  
 -2012-10-11 - 9a92aea - lavu 51.43.0 - aes.h, md5.h, sha.h, tree.h
 +2012-10-11 - f391e40 / 9a92aea - lavu 51.75.100 / 51.43.0 - aes.h, md5.h, sha.h, tree.h
    Add functions for allocating the opaque contexts for the algorithms,
 -  deprecate the context size variables.
  
 -2012-10-10 - b522000 - lavf 54.18.0 - avio.h
 +2012-10-10 - de31814 / b522000 - lavf 54.32.100 / 54.18.0 - avio.h
    Add avio_closep to complement avio_close.
  
 -2012-10-08 - 78071a1 - lavu 51.42.0 - pixfmt.h
 +2012-10-08 - ae77266 / 78071a1 - lavu 51.74.100 / 51.42.0 - pixfmt.h
    Rename PixelFormat to AVPixelFormat and all PIX_FMT_* to AV_PIX_FMT_*.
    To provide backwards compatibility, PixelFormat is now #defined as
    AVPixelFormat.
    'PixelFormat' identifier. Such code should either #undef PixelFormat
    or stop using the PixelFormat name.
  
 -2012-10-05 - e7ba5b1 - lavr 1.0.0 - avresample.h
 +2012-10-05 - 55c49af / e7ba5b1 - lavr 1.0.0 - avresample.h
    Data planes parameters to avresample_convert() and
    avresample_read() are now uint8_t** instead of void**.
    Libavresample is now stable.
  
 -2012-09-24 - a42aada - lavc 54.28.0 - avcodec.h
 +2012-09-24 - 46a3595 / a42aada - lavc 54.59.100 / 54.28.0 - avcodec.h
    Add avcodec_free_frame(). This function must now
    be used for freeing an AVFrame.
  
 -2012-09-12 - 8919fee - lavu 51.41.0 - audioconvert.h
 +2012-09-12 - e3e09f2 / 8919fee - lavu 51.73.100 / 51.41.0 - audioconvert.h
    Added AV_CH_LOW_FREQUENCY_2 channel mask value.
  
 -2012-09-04 - 686a329 - lavu 51.40.0 - opt.h
 +2012-09-04 - b21b5b0 / 686a329 - lavu 51.71.100 / 51.40.0 - opt.h
    Reordered the fields in default_val in AVOption, changed which
    default_val field is used for which AVOptionType.
  
 -2012-08-30 - a231832 - lavc 54.26.1 - avcodec.h
 +2012-08-30 - 98298eb / a231832 - lavc 54.54.101 / 54.26.1 - avcodec.h
    Add codec descriptor properties AV_CODEC_PROP_LOSSY and
    AV_CODEC_PROP_LOSSLESS.
  
    Add codec descriptors for accessing codec properties without having
    to refer to a specific decoder or encoder.
  
 -  c223d79 - Add an AVCodecDescriptor struct and functions
 +  f5f3684 / c223d79 - Add an AVCodecDescriptor struct and functions
              avcodec_descriptor_get() and avcodec_descriptor_next().
 -  51efed1 - Add AVCodecDescriptor.props and AV_CODEC_PROP_INTRA_ONLY.
 -  91e59fe - Add avcodec_descriptor_get_by_name().
 -
 -
 -2012-08-08 - 1d9c2dc - lavu 51.39 - avutil.h
 -  Don't implicitly include libavutil/common.h in avutil.h
 +  f5f3684 / 51efed1 - Add AVCodecDescriptor.props and AV_CODEC_PROP_INTRA_ONLY.
 +  6c180b3 / 91e59fe - Add avcodec_descriptor_get_by_name().
  
 -2012-08-08 - 987170c - lavu 51.38 - dict.h
 +2012-08-08 - f5f3684 / 987170c - lavu 51.68.100 / 51.38.0 - dict.h
    Add av_dict_count().
  
 -2012-08-07 - 104e10f - lavc 54.25 - avcodec.h
 +2012-08-07 - 7a72695 / 104e10f - lavc 54.51.100 / 54.25.0 - avcodec.h
    Rename CodecID to AVCodecID and all CODEC_ID_* to AV_CODEC_ID_*.
    To provide backwards compatibility, CodecID is now #defined as AVCodecID.
    Note that this can break user code that includes avcodec.h and uses the
    'CodecID' identifier. Such code should either #undef CodecID or stop using the
    CodecID name.
  
 -2012-08-03 - 239fdf1 - lavu 51.37.1 - cpu.h
 +2012-08-03 - e776ee8 / 239fdf1 - lavu 51.66.101 / 51.37.1 - cpu.h
                         lsws 2.1.1   - swscale.h
    Rename AV_CPU_FLAG_MMX2  ---> AV_CPU_FLAG_MMXEXT.
    Rename SWS_CPU_CAPS_MMX2 ---> SWS_CPU_CAPS_MMXEXT.
  
 -2012-07-29 - 681ed00 - lavf 54.13.0 - avformat.h
 +2012-07-29 - 7c26761 / 681ed00 - lavf 54.22.100 / 54.13.0 - avformat.h
    Add AVFMT_FLAG_NOBUFFER for low latency use cases.
  
 -2012-07-20 - b70d89a - lavfi 3.0.0 - avfilter.h
 -  Add avfilter_unref_bufferp().
 -
  2012-07-10 - 5fade8a - lavu 51.37.0
    Add av_malloc_array() and av_mallocz_array()
  
 -2012-06-22 - d3d3a32 - lavu 51.34.0
 +2012-06-22 - e847f41 / d3d3a32 - lavu 51.61.100 / 51.34.0
    Add av_usleep()
  
 -2012-06-20 - ae0a301 - lavu 51.33.0
 +2012-06-20 - 4da42eb / ae0a301 - lavu 51.60.100 / 51.33.0
    Move av_gettime() to libavutil, add libavutil/time.h
  
 -2012-06-09 - 3971be0 - lavr 0.0.3
 +2012-06-09 - 82edf67 / 3971be0 - lavr 0.0.3
    Add a parameter to avresample_build_matrix() for Dolby/DPLII downmixing.
  
 -2012-06-12 - 9baeff9 - lavfi 2.23.0 - avfilter.h
 +2012-06-12 - c7b9eab / 9baeff9 - lavfi 2.79.100 / 2.23.0 - avfilter.h
    Add AVFilterContext.nb_inputs/outputs. Deprecate
    AVFilterContext.input/output_count.
  
 -2012-06-12 - 84b9fbe - lavfi 2.22.0 - avfilter.h
 +2012-06-12 - c7b9eab / 84b9fbe - lavfi 2.79.100 / 2.22.0 - avfilter.h
    Add avfilter_pad_get_type() and avfilter_pad_get_name(). Those
    should now be used instead of accessing AVFilterPad members
    directly.
  
 -2012-06-12 - b0f0dfc - lavu 51.32.0 - audioconvert.h
 +2012-06-12 - 3630a07 / b0f0dfc - lavu 51.57.100 / 51.32.0 - audioconvert.h
    Add av_get_channel_layout_channel_index(), av_get_channel_name()
    and av_channel_layout_extract_channel().
  
 -2012-05-25 - 154486f - lavu 51.31.0 - opt.h
 +2012-05-25 - 53ce990 / 154486f - lavu 51.55.100 / 51.31.0 - opt.h
    Add av_opt_set_bin()
  
 -2012-05-26 - e9cef89 - lavf 54.3.0
 -  Add AVFMT_TS_NONSTRICT format flag to indicate that a muxer supports
 -  non-increasing monotone timestamps.
 -
 -2012-05-15 - lavfi 2.17.0
 +2012-05-15 - lavfi 2.74.100 / 2.17.0
    Add support for audio filters
 -  ac71230/a2cd9be - add video/audio buffer sink in a new installed
 +  61930bd / ac71230, 1cbf7fb / a2cd9be - add video/audio buffer sink in a new installed
                      header buffersink.h
 -  720c6b7 - add av_buffersrc_write_frame(), deprecate
 +  1cbf7fb / 720c6b7 - add av_buffersrc_write_frame(), deprecate
              av_vsrc_buffer_add_frame()
 -  ab16504 - add avfilter_copy_buf_props()
 -  9453c9e - add extended_data to AVFilterBuffer
 -  1b8c927 - add avfilter_get_audio_buffer_ref_from_arrays()
 +  61930bd / ab16504 - add avfilter_copy_buf_props()
 +  61930bd / 9453c9e - add extended_data to AVFilterBuffer
 +  61930bd / 1b8c927 - add avfilter_get_audio_buffer_ref_from_arrays()
  
 -2012-05-09 - lavu 51.30.0 - samplefmt.h
 -  142e740 - add av_samples_copy()
 -  6d7f617 - add av_samples_set_silence()
 +2012-05-09 - lavu 51.53.100 / 51.30.0 - samplefmt.h
 +  61930bd / 142e740 - add av_samples_copy()
 +  61930bd / 6d7f617 - add av_samples_set_silence()
  
 -2012-05-09 - a5117a2 - lavc 54.13.1
 +2012-05-09 - 61930bd / a5117a2 - lavc 54.21.101 / 54.13.1
    For audio formats with fixed frame size, the last frame
    no longer needs to be padded with silence, libavcodec
    will handle this internally (effectively all encoders
    behave as if they had CODEC_CAP_SMALL_LAST_FRAME set).
  
 -2012-05-07 - 828bd08 - lavc 54.13.0 - avcodec.h
 +2012-05-07 - 653d117 / 828bd08 - lavc 54.20.100 / 54.13.0 - avcodec.h
    Add sample_rate and channel_layout fields to AVFrame.
  
 -2012-05-01 - 4010d72 - lavr 0.0.1
 +2012-05-01 - 2330eb1 / 4010d72 - lavr 0.0.1
    Change AV_MIX_COEFF_TYPE_Q6 to AV_MIX_COEFF_TYPE_Q8.
  
 -2012-04-25 - 3527a73 - lavu 51.29.0 - cpu.h
 +2012-04-25 - e890b68 / 3527a73 - lavu 51.48.100 / 51.29.0 - cpu.h
    Add av_parse_cpu_flags()
  
 -2012-04-24 - c8af852 - lavr 0.0.0
 +2012-04-24 - 3ead79e / c8af852 - lavr 0.0.0
    Add libavresample audio conversion library
  
 -2012-04-20 - 0c0d1bc - lavu 51.28.0 - audio_fifo.h
 +2012-04-20 - 3194ab7 / 0c0d1bc - lavu 51.47.100 / 51.28.0 - audio_fifo.h
    Add audio FIFO functions:
      av_audio_fifo_free()
      av_audio_fifo_alloc()
      av_audio_fifo_size()
      av_audio_fifo_space()
  
 -2012-04-14 - lavfi 2.16.0 - avfiltergraph.h
 -  d7bcc71 Add avfilter_graph_parse2().
 -  91d3cbe Add avfilter_inout_alloc() and avfilter_inout_free().
 +2012-04-14 - lavfi 2.70.100 / 2.16.0 - avfiltergraph.h
 +  7432bcf / d7bcc71 Add avfilter_graph_parse2().
  
 -2012-04-08 - 4d693b0 - lavu 51.27.0 - samplefmt.h
 +2012-04-08 - 6bfb304 / 4d693b0 - lavu 51.46.100 / 51.27.0 - samplefmt.h
    Add av_get_packed_sample_fmt() and av_get_planar_sample_fmt()
  
 -2012-04-05 - 5cc51a5 - lavu 51.26.0 - audioconvert.h
 -  Add av_get_default_channel_layout()
 +2012-03-21 - b75c67d - lavu 51.43.100
 +  Add bprint.h for bprint API.
 +
 +2012-02-21 - 9cbf17e - lavc 54.4.100
 +  Add av_get_pcm_codec() function.
 +
 +2012-02-16 - 560b224 - libswr 0.7.100
 +  Add swr_set_matrix() function.
  
 -2012-03-20 - 3c90cc2 - lavfo 54.2.0
 +2012-02-09 - c28e7af - lavu 51.39.100
 +  Add a new installed header libavutil/timestamp.h with timestamp
 +  utilities.
 +
 +2012-02-06 - 70ffda3 - lavu 51.38.100
 +  Add av_parse_ratio() function to parseutils.h.
 +
 +2012-02-06 - 70ffda3 - lavu 51.38.100
 +  Add AV_LOG_MAX_OFFSET macro to log.h.
 +
 +2012-02-02 - 0eaa123 - lavu 51.37.100
 +  Add public timecode helpers.
 +
 +2012-01-24 - 0c3577b - lavfi 2.60.100
 +  Add avfilter_graph_dump.
 +
 +2012-03-20 - 0ebd836 / 3c90cc2 - lavfo 54.2.0
    Deprecate av_read_packet(), use av_read_frame() with
    AVFMT_FLAG_NOPARSE | AVFMT_FLAG_NOFILLIN in AVFormatContext.flags
  
 -2012-03-06 - 4d851f8 - lavu 51.25.0 - cpu.h
 -  Add av_set_cpu_flags_mask().
 -
 -2012-03-05 - lavc 54.8.0
 -  6699d07 Add av_get_exact_bits_per_sample()
 -  9524cf7 Add av_get_audio_frame_duration()
 +2012-03-05 - lavc 54.10.100 / 54.8.0
 +  f095391 / 6699d07 Add av_get_exact_bits_per_sample()
 +  f095391 / 9524cf7 Add av_get_audio_frame_duration()
  
 -2012-03-04 - 44fe77b - lavc 54.7.0 - avcodec.h
 +2012-03-04 - 2af8f2c / 44fe77b - lavc 54.8.100 / 54.7.0 - avcodec.h
    Add av_codec_is_encoder/decoder().
  
 -2012-03-01 - 442c132 - lavc 54.3.0 - avcodec.h
 +2012-03-01 - 1eb7f39 / 442c132 - lavc 54.5.100 / 54.3.0 - avcodec.h
    Add av_packet_shrink_side_data.
  
 -2012-02-29 - dd2a4bc - lavf 54.2.0 - avformat.h
 +2012-02-29 - 79ae084 / dd2a4bc - lavf 54.2.100 / 54.2.0 - avformat.h
    Add AVStream.attached_pic and AV_DISPOSITION_ATTACHED_PIC,
    used for dealing with attached pictures/cover art.
  
 -2012-02-25 - c9bca80 - lavu 51.24.0 - error.h
 +2012-02-25 - 305e4b3 / c9bca80 - lavu 51.41.100 / 51.24.0 - error.h
    Add AVERROR_UNKNOWN
    NOTE: this was backported to 0.8
  
 -2012-02-20 - e9cda85 - lavc 54.2.0
 +2012-02-20 - eadd426 / e9cda85 - lavc 54.2.100 / 54.2.0
    Add duration field to AVCodecParserContext
  
 -2012-02-20 - 0b42a93 - lavu 51.23.1 - mathematics.h
 +2012-02-20 - eadd426 / 0b42a93 - lavu 51.40.100 / 51.23.1 - mathematics.h
    Add av_rescale_q_rnd()
  
 -2012-02-08 - 38d5533 - lavu 51.22.1 - pixdesc.h
 +2012-02-08 - f2b20b7 / 38d5533 - lavu 51.38.101 / 51.22.1 - pixdesc.h
    Add PIX_FMT_PSEUDOPAL flag.
  
 -2012-02-08 - 52f82a1 - lavc 54.01.0
 +2012-02-08 - f2b20b7 / 52f82a1 - lavc 54.2.100 / 54.1.0
    Add avcodec_encode_video2() and deprecate avcodec_encode_video().
  
 -2012-02-01 - 316fc74 - lavc 54.01.0
 +2012-02-01 - 4c677df / 316fc74 - lavc 54.1.0
    Add av_fast_padded_malloc() as alternative for av_realloc() when aligned
    memory is required. The buffer will always have FF_INPUT_BUFFER_PADDING_SIZE
    zero-padded bytes at the end.
  
 -2012-01-31 - dd6d3b0 - lavf 54.01.0
 +2012-01-31 - a369a6b / dd6d3b0 - lavf 54.1.0
    Add avformat_get_riff_video_tags() and avformat_get_riff_audio_tags().
    NOTE: this was backported to 0.8
  
 -2012-01-31 - af08d9a - lavc 54.01.0
 +2012-01-31 - a369a6b / af08d9a - lavc 54.1.0
    Add avcodec_is_open() function.
    NOTE: this was backported to 0.8
  
 -2012-01-30 - 8b93312 - lavu 51.22.0 - intfloat.h
 +2012-01-30 - 151ecc2 / 8b93312 - lavu 51.36.100 / 51.22.0 - intfloat.h
    Add a new installed header libavutil/intfloat.h with int/float punning
    functions.
    NOTE: this was backported to 0.8
  
 -2012-01-25 - lavf 53.22.0
 -  f1caf01 Allow doing av_write_frame(ctx, NULL) for flushing possible
 +2012-01-25 - lavf 53.31.100 / 53.22.0
 +  3c5fe5b / f1caf01 Allow doing av_write_frame(ctx, NULL) for flushing possible
            buffered data within a muxer. Added AVFMT_ALLOW_FLUSH for
            muxers supporting it (av_write_frame makes sure it is called
            only for muxers with this flag).
  
 -------------------------------8<-------------------------------------
 -                   0.8 branch was cut here
 ------------------------------>8--------------------------------------
 -
 -2012-01-15 - lavc 53.34.0
 +2012-01-15 - lavc 53.56.105 / 53.34.0
    New audio encoding API:
 -  b2c75b6 Add CODEC_CAP_VARIABLE_FRAME_SIZE capability for use by audio
 +  67f5650 / b2c75b6 Add CODEC_CAP_VARIABLE_FRAME_SIZE capability for use by audio
            encoders.
 -  5ee5fa0 Add avcodec_fill_audio_frame() as a convenience function.
 -  b2c75b6 Add avcodec_encode_audio2() and deprecate avcodec_encode_audio().
 +  67f5650 / 5ee5fa0 Add avcodec_fill_audio_frame() as a convenience function.
 +  67f5650 / b2c75b6 Add avcodec_encode_audio2() and deprecate avcodec_encode_audio().
            Add AVCodec.encode2().
  
 -2012-01-12 - 3167dc9 - lavfi 2.15.0
 +2012-01-12 - b18e17e / 3167dc9 - lavfi 2.59.100 / 2.15.0
    Add a new installed header -- libavfilter/version.h -- with version macros.
  
 -2011-01-03 - b73ec05 - lavu 51.21.0
 +2011-12-08 - a502939 - lavfi 2.52.0
 +  Add av_buffersink_poll_frame() to buffersink.h.
 +
 +2011-12-08 - 26c6fec - lavu 51.31.0
 +  Add av_log_format_line.
 +
 +2011-12-03 - 976b095 - lavu 51.30.0
 +  Add AVERROR_BUG.
 +
 +2011-11-24 - 573ffbb - lavu 51.28.1
 +  Add av_get_alt_sample_fmt() to samplefmt.h.
 +
 +2011-11-03 - 96949da - lavu 51.23.0
 +  Add av_strcasecmp() and av_strncasecmp() to avstring.h.
 +
 +2011-10-20 - b35e9e1 - lavu 51.22.0
 +  Add av_strtok() to avstring.h.
 +
 +2012-01-03 - ad1c8dd / b73ec05 - lavu 51.34.100 / 51.21.0
    Add av_popcount64
  
 -2011-12-25 - lavfi 2.14.0
 -  e1d9dbf Add a new installed header - buffersrc.h
 -  It contains a new function av_buffersrc_buffer() that allows passing
 -  frames to the 'buffer' filter, but unlike av_vsrc_buffer_add_frame()
 -  it allows for direct rendering.
 -  1c9e340 Add avfilter_copy_frame_props() for copying properties from
 -  AVFrame to AVFilterBufferRef.
 -
 -2011-12-25 - lavc 53.31.0
 -  Add the following new fields to AVFrame:
 -    b58dbb5 sample_aspect_ratio
 -    3a2ddf7 width, height
 -    8a4a5f6 format
 -
 -2011-12-18 - 8400b12 - lavc 53.28.1
 +2011-12-18 - 7c29313 / 8400b12 - lavc 53.46.1 / 53.28.1
    Deprecate AVFrame.age. The field is unused.
  
 -2011-12-12 - 5266045 - lavf 53.17.0
 +2011-12-12 - 8bc7fe4 / 5266045 - lavf 53.25.0 / 53.17.0
    Add avformat_close_input().
    Deprecate av_close_input_file() and av_close_input_stream().
  
 -2011-12-02 - 0eea212 - lavc 53.25.0
 +2011-12-02 - e4de716 / 0eea212 - lavc 53.40.0 / 53.25.0
    Add nb_samples and extended_data fields to AVFrame.
    Deprecate AVCODEC_MAX_AUDIO_FRAME_SIZE.
    Deprecate avcodec_decode_audio3() in favor of avcodec_decode_audio4().
    avcodec_decode_audio4() writes output samples to an AVFrame, which allows
    audio decoders to use get_buffer().
  
 -2011-12-04 - 560f773 - lavc 53.24.0
 +2011-12-04 - e4de716 / 560f773 - lavc 53.40.0 / 53.24.0
    Change AVFrame.data[4]/base[4]/linesize[4]/error[4] to [8] at next major bump.
    Change AVPicture.data[4]/linesize[4] to [8] at next major bump.
    Change AVCodecContext.error[4] to [8] at next major bump.
    Add AV_NUM_DATA_POINTERS to simplify the bump transition.
  
 -2011-11-23 - bbb46f3 - lavu 51.18.0
 +2011-11-23 - 8e576d5 / bbb46f3 - lavu 51.27.0 / 51.18.0
    Add av_samples_get_buffer_size(), av_samples_fill_arrays(), and
    av_samples_alloc(), to samplefmt.h.
  
 -2011-11-23 - 8889cc4 - lavu 51.17.0
 +2011-11-23 - 8e576d5 / 8889cc4 - lavu 51.27.0 / 51.17.0
    Add planar sample formats and av_sample_fmt_is_planar() to samplefmt.h.
  
 -2011-11-19 - f3a29b7 - lavc 53.21.0
 +2011-11-19 - dbb38bc / f3a29b7 - lavc 53.36.0 / 53.21.0
    Move some AVCodecContext fields to a new private struct, AVCodecInternal,
    which is accessed from a new field, AVCodecContext.internal.
    - fields moved:
        AVCodecContext.internal_buffer_count --> AVCodecInternal.buffer_count
        AVCodecContext.is_copy               --> AVCodecInternal.is_copy
  
 -2011-11-16 - 6270671 - lavu 51.16.0
 +2011-11-16 - 8709ba9 / 6270671 - lavu 51.26.0 / 51.16.0
    Add av_timegm()
  
 -2011-11-13 - lavf 53.15.0
 +2011-11-13 - lavf 53.21.0 / 53.15.0
    New interrupt callback API, allowing per-AVFormatContext/AVIOContext
    interrupt callbacks.
 -  6aa0b98 Add AVIOInterruptCB struct and the interrupt_callback field to
 +  5f268ca / 6aa0b98 Add AVIOInterruptCB struct and the interrupt_callback field to
            AVFormatContext.
 -  1dee0ac Add avio_open2() with additional parameters. Those are
 +  5f268ca / 1dee0ac Add avio_open2() with additional parameters. Those are
            an interrupt callback and an options AVDictionary.
            This will allow passing AVOptions to protocols after lavf
            54.0.
  
 -2011-11-06 - ba04ecf - lavu 51.14.0
 +2011-11-06 - 13b7781 / ba04ecf - lavu 51.24.0 / 51.14.0
    Add av_strcasecmp() and av_strncasecmp() to avstring.h.
  
 -2011-11-06 - 07b172f - lavu 51.13.0
 +2011-11-06 - 13b7781 / 07b172f - lavu 51.24.0 / 51.13.0
    Add av_toupper()/av_tolower()
  
 -2011-11-05 - b6d08f4 - lavf 53.13.0
 +2011-11-05 - d8cab5c / b6d08f4 - lavf 53.19.0 / 53.13.0
    Add avformat_network_init()/avformat_network_deinit()
  
 -2011-10-27 - 512557b - lavc 53.15.0
 +2011-10-27 - 6faf0a2 / 512557b - lavc 53.24.0 / 53.15.0
    Remove avcodec_parse_frame.
    Deprecate AVCodecContext.parse_only and CODEC_CAP_PARSE_ONLY.
  
 -2011-10-19 - 569129a - lavf 53.10.0
 +2011-10-19 - d049257 / 569129a - lavf 53.17.0 / 53.10.0
    Add avformat_new_stream(). Deprecate av_new_stream().
  
 -2011-10-13 - b631fba - lavf 53.9.0
 +2011-10-13 - 91eb1b1 / b631fba - lavf 53.16.0 / 53.9.0
    Add AVFMT_NO_BYTE_SEEK AVInputFormat flag.
  
 -2011-10-12 - lavu 51.12.0
 +2011-10-12 - lavu 51.21.0 / 51.12.0
    AVOptions API rewrite.
  
 -  - 145f741 FF_OPT_TYPE* renamed to AV_OPT_TYPE_*
 +  - f884ef0 / 145f741 FF_OPT_TYPE* renamed to AV_OPT_TYPE_*
    - new setting/getting functions with slightly different semantics:
 -        dac66da av_set_string3 -> av_opt_set
 +        f884ef0 / dac66da av_set_string3 -> av_opt_set
                  av_set_double  -> av_opt_set_double
                  av_set_q       -> av_opt_set_q
                  av_set_int     -> av_opt_set_int
  
 -        41d9d51 av_get_string  -> av_opt_get
 +        f884ef0 / 41d9d51 av_get_string  -> av_opt_get
                  av_get_double  -> av_opt_get_double
                  av_get_q       -> av_opt_get_q
                  av_get_int     -> av_opt_get_int
  
 -  - 8c5dcaa trivial rename av_next_option -> av_opt_next
 -  - 641c7af new functions - av_opt_child_next, av_opt_child_class_next
 +  - f884ef0 / 8c5dcaa trivial rename av_next_option -> av_opt_next
 +  - f884ef0 / 641c7af new functions - av_opt_child_next, av_opt_child_class_next
      and av_opt_find2()
  
 -2011-09-03 - fb4ca26 - lavc 53.10.0
 -                       lavf 53.6.0
 +2011-09-22 - a70e787 - lavu 51.17.0
 +  Add av_x_if_null().
 +
 +2011-09-18 - 645cebb - lavc 53.16.0
 +  Add showall flag2
 +
 +2011-09-16 - ea8de10 - lavfi 2.42.0
 +  Add avfilter_all_channel_layouts.
 +
 +2011-09-16 - 9899037 - lavfi 2.41.0
 +  Rename avfilter_all_* function names to avfilter_make_all_*.
 +
 +  In particular, apply the renames:
 +  avfilter_all_formats         -> avfilter_make_all_formats
 +  avfilter_all_channel_layouts -> avfilter_make_all_channel_layouts
 +  avfilter_all_packing_formats -> avfilter_make_all_packing_formats
 +
 +2011-09-12 - 4381bdd - lavfi 2.40.0
 +  Change AVFilterBufferRefAudioProps.sample_rate type from uint32_t to int.
 +
 +2011-09-12 - 2c03174 - lavfi 2.40.0
 +  Simplify signature for avfilter_get_audio_buffer(), make it
 +  consistent with avfilter_get_video_buffer().
 +
 +2011-09-06 - 4f7dfe1 - lavfi 2.39.0
 +  Rename libavfilter/vsink_buffer.h to libavfilter/buffersink.h.
 +
 +2011-09-06 - c4415f6 - lavfi 2.38.0
 +  Unify video and audio sink API.
 +
 +  In particular, add av_buffersink_get_buffer_ref(), deprecate
 +  av_vsink_buffer_get_video_buffer_ref() and change the value for the
 +  opaque field passed to the abuffersink init function.
 +
 +2011-09-04 - 61e2e29 - lavu 51.16.0
 +  Add av_asprintf().
 +
 +2011-08-22 - dacd827 - lavf 53.10.0
 +  Add av_find_program_from_stream().
 +
 +2011-08-20 - 69e2c1a - lavu 51.13.0
 +  Add av_get_media_type_string().
 +
 +2011-09-03 - 1889c67 / fb4ca26 - lavc 53.13.0
 +                       lavf 53.11.0
                         lsws  2.1.0
    Add {avcodec,avformat,sws}_get_class().
  
 -2011-09-03 - c11fb82 - lavu 51.10.0
 +2011-08-03 - 1889c67 / c11fb82 - lavu 51.15.0
    Add AV_OPT_SEARCH_FAKE_OBJ flag for av_opt_find() function.
  
 -2011-08-26 - lavu 51.9.0
 -  - f2011ed Add av_fifo_peek2(), deprecate av_fifo_peek().
 -  - add41de..abc78a5 Do not include intfloat_readwrite.h,
 +2011-08-14 - 323b930 - lavu 51.12.0
 +  Add av_fifo_peek2(), deprecate av_fifo_peek().
 +
 +2011-08-26 - lavu 51.14.0 / 51.9.0
 +  - 976a8b2 / add41de..976a8b2 / abc78a5 Do not include intfloat_readwrite.h,
      mathematics.h, rational.h, pixfmt.h, or log.h from avutil.h.
  
 -2011-08-16 - 48f9e45 - lavf 53.4.0
 +2011-08-16 - 27fbe31 / 48f9e45 - lavf 53.11.0 / 53.8.0
    Add avformat_query_codec().
  
 -2011-08-16 - bca06e7 - lavc 53.8.0
 +2011-08-16 - 27fbe31 / bca06e7 - lavc 53.11.0
    Add avcodec_get_type().
  
 -2011-08-06 - 2f63440 - lavf 53.4.0
 +2011-08-06 - 0cb233c / 2f63440 - lavf 53.7.0
    Add error_recognition to AVFormatContext.
  
 -2011-08-02 - 9d39cbf - lavc 53.7.1
 +2011-08-02 - 1d186e9 / 9d39cbf - lavc 53.9.1
    Add AV_PKT_FLAG_CORRUPT AVPacket flag.
  
 -2011-07-10 - a67c061 - lavf 53.3.0
 +2011-07-16 - b57df29 - lavfi 2.27.0
 +  Add audio packing negotiation fields and helper functions.
 +
 +  In particular, add AVFilterPacking enum, planar, in_packings and
 +  out_packings fields to AVFilterLink, and the functions:
 +  avfilter_set_common_packing_formats()
 +  avfilter_all_packing_formats()
 +
 +2011-07-10 - 3602ad7 / a67c061 - lavf 53.6.0
    Add avformat_find_stream_info(), deprecate av_find_stream_info().
    NOTE: this was backported to 0.7
  
 -2011-07-10 - 0b950fe - lavc 53.6.0
 +2011-07-10 - 3602ad7 / 0b950fe - lavc 53.8.0
    Add avcodec_open2(), deprecate avcodec_open().
    NOTE: this was backported to 0.7
  
    Add avcodec_alloc_context3. Deprecate avcodec_alloc_context() and
    avcodec_alloc_context2().
  
 -2011-06-23 - 67e9ae1 - lavu 51.8.0 - attributes.h
 -  Add av_printf_format().
 +2011-07-01 - b442ca6 - lavf 53.5.0 - avformat.h
 +  Add function av_get_output_timestamp().
 +
 +2011-06-28 - 5129336 - lavu 51.11.0 - avutil.h
 +  Define the AV_PICTURE_TYPE_NONE value in AVPictureType enum.
 +
 +2011-06-19 - fd2c0a5 - lavfi 2.23.0 - avfilter.h
 +  Add layout negotiation fields and helper functions.
 +
 +  In particular, add in_chlayouts and out_chlayouts to AVFilterLink,
 +  and the functions:
 +  avfilter_set_common_sample_formats()
 +  avfilter_set_common_channel_layouts()
 +  avfilter_all_channel_layouts()
 +
 +2011-06-19 - 527ca39 - lavfi 2.22.0 - AVFilterFormats
 +  Change type of AVFilterFormats.formats from int * to int64_t *,
 +  and update formats handling API accordingly.
 +
 +  avfilter_make_format_list() still takes a int32_t array and converts
 +  it to int64_t. A new function, avfilter_make_format64_list(), that
 +  takes int64_t arrays has been added.
 +
 +2011-06-19 - 44f669e - lavfi 2.21.0 - vsink_buffer.h
 +  Add video sink buffer and vsink_buffer.h public header.
  
 -------------------------------8<-------------------------------------
 -                   0.7 branch was cut here
 ------------------------------>8--------------------------------------
 +2011-06-12 - 9fdf772 - lavfi 2.18.0 - avcodec.h
 +  Add avfilter_get_video_buffer_ref_from_frame() function in
 +  libavfilter/avcodec.h.
  
 -2011-06-16 - 05e84c9, 25de595 - lavf 53.2.0 - avformat.h
 +2011-06-12 - c535494 - lavfi 2.17.0 - avfiltergraph.h
 +  Add avfilter_inout_alloc() and avfilter_inout_free() functions.
 +
 +2011-06-12 - 6119b23 - lavfi 2.16.0 - avfilter_graph_parse()
 +  Change avfilter_graph_parse() signature.
 +
 +2011-06-23 - 686959e / 67e9ae1 - lavu 51.10.0 / 51.8.0 - attributes.h
 +  Add av_printf_format().
 +
 +2011-06-16 - 2905e3f / 05e84c9, 2905e3f / 25de595 - lavf 53.4.0 / 53.2.0 - avformat.h
    Add avformat_open_input and avformat_write_header().
    Deprecate av_open_input_stream, av_open_input_file,
    AVFormatParameters and av_write_header.
  
 -2011-06-16 - 7e83e1c, dc59ec5 - lavu 51.7.0 - opt.h
 +2011-06-16 - 2905e3f / 7e83e1c, 2905e3f / dc59ec5 - lavu 51.9.0 / 51.7.0 - opt.h
    Add av_opt_set_dict() and av_opt_find().
    Deprecate av_find_opt().
    Add AV_DICT_APPEND flag.
  
 -2011-06-10 - cb7c11c - lavu 51.6.0 - opt.h
 +2011-06-10 - 45fb647 / cb7c11c - lavu 51.6.0 - opt.h
    Add av_opt_flag_is_set().
  
 -2011-06-08 - d9f80ea - lavu 51.5.0 - AVMetadata
 +2011-06-10 - c381960 - lavfi 2.15.0 - avfilter_get_audio_buffer_ref_from_arrays
 +  Add avfilter_get_audio_buffer_ref_from_arrays() to avfilter.h.
 +
 +2011-06-09 - f9ecb84 / d9f80ea - lavu 51.8.0 - AVMetadata
    Move AVMetadata from lavf to lavu and rename it to
    AVDictionary -- new installed header dict.h.
    All av_metadata_* functions renamed to av_dict_*.
  
 -2011-06-07 - a6703fa - lavu 51.4.0 - av_get_bytes_per_sample()
 +2011-06-07 - d552f61 / a6703fa - lavu 51.8.0 - av_get_bytes_per_sample()
    Add av_get_bytes_per_sample() in libavutil/samplefmt.h.
    Deprecate av_get_bits_per_sample_fmt().
  
 -2011-06-05 - b39b062 - lavu 51.3.0 - opt.h
 +2011-06-05 - f956924 / b39b062 - lavu 51.8.0 - opt.h
    Add av_opt_free convenience function.
  
 -2011-05-28 - 0420bd7 - lavu 51.2.0 - pixdesc.h
 +2011-06-06 - 95a0242 - lavfi 2.14.0 - AVFilterBufferRefAudioProps
 +  Remove AVFilterBufferRefAudioProps.size, and use nb_samples in
 +  avfilter_get_audio_buffer() and avfilter_default_get_audio_buffer() in
 +  place of size.
 +
 +2011-06-06 - 0bc2cca - lavu 51.6.0 - av_samples_alloc()
 +  Switch nb_channels and nb_samples parameters order in
 +  av_samples_alloc().
 +
 +2011-06-06 - e1c7414 - lavu 51.5.0 - av_samples_*
 +  Change the data layout created by av_samples_fill_arrays() and
 +  av_samples_alloc().
 +
 +2011-06-06 - 27bcf55 - lavfi 2.13.0 - vsrc_buffer.h
 +  Make av_vsrc_buffer_add_video_buffer_ref() accepts an additional
 +  flags parameter in input.
 +
 +2011-06-03 - e977ca2 - lavfi 2.12.0 - avfilter_link_free()
 +  Add avfilter_link_free() function.
 +
 +2011-06-02 - 5ad38d9 - lavu 51.4.0 - av_force_cpu_flags()
 +  Add av_cpu_flags() in libavutil/cpu.h.
 +
 +2011-05-28 - e71f260 - lavu 51.3.0 - pixdesc.h
    Add av_get_pix_fmt_name() in libavutil/pixdesc.h, and deprecate
    avcodec_get_pix_fmt_name() in libavcodec/avcodec.h in its favor.
  
 -2011-05-25 - 30315a8 - lavf 53.1.0 - avformat.h
 +2011-05-25 - 39e4206 / 30315a8 - lavf 53.3.0 - avformat.h
    Add fps_probe_size to AVFormatContext.
  
 -2011-05-18 - 64150ff - lavc 53.4.0 - AVCodecContext.request_sample_fmt
 +2011-05-22 - 5ecdfd0 - lavf 53.2.0 - avformat.h
 +  Introduce avformat_alloc_output_context2() and deprecate
 +  avformat_alloc_output_context().
 +
 +2011-05-22 - 83db719 - lavfi 2.10.0 - vsrc_buffer.h
 +  Make libavfilter/vsrc_buffer.h public.
 +
 +2011-05-19 - c000a9f - lavfi 2.8.0 - avcodec.h
 +  Add av_vsrc_buffer_add_frame() to libavfilter/avcodec.h.
 +
 +2011-05-14 - 9fdf772 - lavfi 2.6.0 - avcodec.h
 +  Add avfilter_get_video_buffer_ref_from_frame() to libavfilter/avcodec.h.
 +
 +2011-05-18 - 75a37b5 / 64150ff - lavc 53.7.0 - AVCodecContext.request_sample_fmt
    Add request_sample_fmt field to AVCodecContext.
  
 -2011-05-10 - 188dea1 - lavc 53.3.0 - avcodec.h
 +2011-05-10 - 59eb12f / 188dea1 - lavc 53.6.0 - avcodec.h
    Deprecate AVLPCType and the following fields in
    AVCodecContext: lpc_coeff_precision, prediction_order_method,
    min_partition_order, max_partition_order, lpc_type, lpc_passes.
    Corresponding FLAC encoder options should be used instead.
  
 -2011-04-26 - bebe72f - lavu 51.1.0 - avutil.h
 +2011-05-07 - 9fdf772 - lavfi 2.5.0 - avcodec.h
 +  Add libavfilter/avcodec.h header and avfilter_copy_frame_props()
 +  function.
 +
 +2011-05-07 - 18ded93 - lavc 53.5.0 - AVFrame
 +  Add format field to AVFrame.
 +
 +2011-05-07 - 22333a6 - lavc 53.4.0 - AVFrame
 +  Add width and height fields to AVFrame.
 +
 +2011-05-01 - 35fe66a - lavfi 2.4.0 - avfilter.h
 +  Rename AVFilterBufferRefVideoProps.pixel_aspect to
 +  sample_aspect_ratio.
 +
 +2011-05-01 - 77e9dee - lavc 53.3.0 - AVFrame
 +  Add a sample_aspect_ratio field to AVFrame.
 +
 +2011-05-01 - 1ba5727 - lavc 53.2.0 - AVFrame
 +  Add a pkt_pos field to AVFrame.
 +
 +2011-04-29 - 35ceaa7 - lavu 51.2.0 - mem.h
 +  Add av_dynarray_add function for adding
 +  an element to a dynamic array.
 +
 +2011-04-26 - d7e5aeb / bebe72f - lavu 51.1.0 - avutil.h
    Add AVPictureType enum and av_get_picture_type_char(), deprecate
    FF_*_TYPE defines and av_get_pict_type_char() defined in
    libavcodec/avcodec.h.
  
 -2011-04-26 - 10d3940 - lavfi 2.3.0 - avfilter.h
 +2011-04-26 - d7e5aeb / 10d3940 - lavfi 2.3.0 - avfilter.h
    Add pict_type and key_frame fields to AVFilterBufferRefVideo.
  
 -2011-04-26 - 7a11c82 - lavfi 2.2.0 - vsrc_buffer
 +2011-04-26 - d7e5aeb / 7a11c82 - lavfi 2.2.0 - vsrc_buffer
    Add sample_aspect_ratio fields to vsrc_buffer arguments
  
 -2011-04-21 - 94f7451 - lavc 53.1.0 - avcodec.h
 +2011-04-21 - 8772156 / 94f7451 - lavc 53.1.0 - avcodec.h
    Add CODEC_CAP_SLICE_THREADS for codecs supporting sliced threading.
  
  2011-04-15 - lavc 52.120.0 - avcodec.h
    AVPacket structure got additional members for passing side information:
 -    4de339e introduce side information for AVPacket
 -    2d8591c make containers pass palette change in AVPacket
 +    c407984 / 4de339e introduce side information for AVPacket
 +    c407984 / 2d8591c make containers pass palette change in AVPacket
  
  2011-04-12 - lavf 52.107.0 - avio.h
    Avio cleanup, part II - deprecate the entire URLContext API:
 -    175389c add avio_check as a replacement for url_exist
 -    ff1ec0c add avio_pause and avio_seek_time as replacements
 +    c55780d / 175389c add avio_check as a replacement for url_exist
 +    9891004 / ff1ec0c add avio_pause and avio_seek_time as replacements
              for _av_url_read_fseek/fpause
 -    cdc6a87 deprecate av_protocol_next(), avio_enum_protocols
 +    d4d0932 / cdc6a87 deprecate av_protocol_next(), avio_enum_protocols
              should be used instead.
 -    80c6e23 rename url_set_interrupt_cb->avio_set_interrupt_cb.
 -    f87b1b3 rename open flags: URL_* -> AVIO_*
 -    f8270bb add avio_enum_protocols.
 -    5593f03 deprecate URLProtocol.
 -    c486dad deprecate URLContext.
 -    026e175 deprecate the typedef for URLInterruptCB
 -    8e76a19 deprecate av_register_protocol2.
 -    b840484 deprecate URL_PROTOCOL_FLAG_NESTED_SCHEME
 -    1305d93 deprecate av_url_read_seek
 -    fa104e1 deprecate av_url_read_pause
 -    727c7aa deprecate url_get_filename().
 -    5958df3 deprecate url_max_packet_size().
 -    1869ea0 deprecate url_get_file_handle().
 -    32a97d4 deprecate url_filesize().
 -    e52a914 deprecate url_close().
 -    58a48c6 deprecate url_seek().
 -    925e908 deprecate url_write().
 -    dce3756 deprecate url_read_complete().
 -    bc371ac deprecate url_read().
 -    0589da0 deprecate url_open().
 -    62eaaea deprecate url_connect.
 -    5652bb9 deprecate url_alloc.
 -    333e894 deprecate url_open_protocol
 -    e230705 deprecate url_poll and URLPollEntry
 -
 -2011-04-10 - lavu  50.40.0 - pixfmt.h
 -  Add PIX_FMT_BGR48LE and PIX_FMT_BGR48BE pixel formats
 +    c88caa5 / 80c6e23 rename url_set_interrupt_cb->avio_set_interrupt_cb.
 +    c88caa5 / f87b1b3 rename open flags: URL_* -> AVIO_*
 +    d4d0932 / f8270bb add avio_enum_protocols.
 +    d4d0932 / 5593f03 deprecate URLProtocol.
 +    d4d0932 / c486dad deprecate URLContext.
 +    d4d0932 / 026e175 deprecate the typedef for URLInterruptCB
 +    c88caa5 / 8e76a19 deprecate av_register_protocol2.
 +    11d7841 / b840484 deprecate URL_PROTOCOL_FLAG_NESTED_SCHEME
 +    11d7841 / 1305d93 deprecate av_url_read_seek
 +    11d7841 / fa104e1 deprecate av_url_read_pause
 +    434f248 / 727c7aa deprecate url_get_filename().
 +    434f248 / 5958df3 deprecate url_max_packet_size().
 +    434f248 / 1869ea0 deprecate url_get_file_handle().
 +    434f248 / 32a97d4 deprecate url_filesize().
 +    434f248 / e52a914 deprecate url_close().
 +    434f248 / 58a48c6 deprecate url_seek().
 +    434f248 / 925e908 deprecate url_write().
 +    434f248 / dce3756 deprecate url_read_complete().
 +    434f248 / bc371ac deprecate url_read().
 +    434f248 / 0589da0 deprecate url_open().
 +    434f248 / 62eaaea deprecate url_connect.
 +    434f248 / 5652bb9 deprecate url_alloc.
 +    434f248 / 333e894 deprecate url_open_protocol
 +    434f248 / e230705 deprecate url_poll and URLPollEntry
  
  2011-04-08 - lavf 52.106.0 - avformat.h
    Minor avformat.h cleanup:
 -    a9bf9d8 deprecate av_guess_image2_codec
 -    c3675df rename avf_sdp_create->av_sdp_create
 +    d4d0932 / a9bf9d8 deprecate av_guess_image2_codec
 +    d4d0932 / c3675df rename avf_sdp_create->av_sdp_create
  
  2011-04-03 - lavf 52.105.0 - avio.h
    Large-scale renaming/deprecating of AVIOContext-related functions:
 -    724f6a0 deprecate url_fdopen
 -    403ee83 deprecate url_open_dyn_packet_buf
 -    6dc7d80 rename url_close_dyn_buf       -> avio_close_dyn_buf
 -    b92c545 rename url_open_dyn_buf        -> avio_open_dyn_buf
 -    8978fed introduce an AVIOContext.seekable field as a replacement for
 +    2cae980 / 724f6a0 deprecate url_fdopen
 +    2cae980 / 403ee83 deprecate url_open_dyn_packet_buf
 +    2cae980 / 6dc7d80 rename url_close_dyn_buf       -> avio_close_dyn_buf
 +    2cae980 / b92c545 rename url_open_dyn_buf        -> avio_open_dyn_buf
 +    2cae980 / 8978fed introduce an AVIOContext.seekable field as a replacement for
              AVIOContext.is_streamed and url_is_streamed()
 -    b64030f deprecate get_checksum()
 -    4c4427a deprecate init_checksum()
 -    4ec153b deprecate udp_set_remote_url/get_local_port
 -    933e90a deprecate av_url_read_fseek/fpause
 -    8d9769a deprecate url_fileno
 -    b7f2fdd rename put_flush_packet -> avio_flush
 -    35f1023 deprecate url_close_buf
 -    83fddae deprecate url_open_buf
 -    d9d86e0 rename url_fprintf -> avio_printf
 -    59f65d9 deprecate url_setbufsize
 -    3e68b3b deprecate url_ferror
 -    66e5b1d deprecate url_feof
 +    1caa412 / b64030f deprecate get_checksum()
 +    1caa412 / 4c4427a deprecate init_checksum()
 +    2fd41c9 / 4ec153b deprecate udp_set_remote_url/get_local_port
 +    4fa0e24 / 933e90a deprecate av_url_read_fseek/fpause
 +    4fa0e24 / 8d9769a deprecate url_fileno
 +    0fecf26 / b7f2fdd rename put_flush_packet -> avio_flush
 +    0fecf26 / 35f1023 deprecate url_close_buf
 +    0fecf26 / 83fddae deprecate url_open_buf
 +    0fecf26 / d9d86e0 rename url_fprintf -> avio_printf
 +    0fecf26 / 59f65d9 deprecate url_setbufsize
 +    6947b0c / 3e68b3b deprecate url_ferror
      e8bb2e2 deprecate url_fget_max_packet_size
      76aa876 rename url_fsize -> avio_size
      e519753 deprecate url_fgetc
      b3db9ce deprecate get_partial_buffer
      8d9ac96 rename av_alloc_put_byte -> avio_alloc_context
  
 -2011-03-25 - 34b47d7 - lavc 52.115.0 - AVCodecContext.audio_service_type
 +2011-03-25 - 27ef7b1 / 34b47d7 - lavc 52.115.0 - AVCodecContext.audio_service_type
    Add audio_service_type field to AVCodecContext.
  
 +2011-03-17 - e309fdc - lavu 50.40.0 - pixfmt.h
 +  Add PIX_FMT_BGR48LE and PIX_FMT_BGR48BE pixel formats
 +
  2011-03-02 - 863c471 - lavf  52.103.0 - av_pkt_dump2, av_pkt_dump_log2
    Add new functions av_pkt_dump2, av_pkt_dump_log2 that uses the
    source stream timebase for outputting timestamps. Deprecate
  2011-02-10 - 12c14cd - lavf 52.99.0 - AVStream.disposition
    Add AV_DISPOSITION_HEARING_IMPAIRED and AV_DISPOSITION_VISUAL_IMPAIRED.
  
 -2011-02-09 - 5592734 - lavc 52.112.0 - avcodec_thread_init()
 +2011-02-09 - c0b102c - lavc 52.112.0 - avcodec_thread_init()
    Deprecate avcodec_thread_init()/avcodec_thread_free() use; instead
    set thread_count before calling avcodec_open.
  
 -2011-02-09 - 778b08a - lavc 52.111.0 - threading API
 +2011-02-09 - 37b00b4 - lavc 52.111.0 - threading API
    Add CODEC_CAP_FRAME_THREADS with new restrictions on get_buffer()/
    release_buffer()/draw_horiz_band() callbacks for appropriate codecs.
    Add thread_type and active_thread_type fields to AVCodecContext.
  2011-02-02 - dfd2a00 - lavu 50.37.0 - log.h
    Make av_dlog public.
  
 +2011-01-31 - 7b3ea55 - lavfi 1.76.0 - vsrc_buffer
 +  Add sample_aspect_ratio fields to vsrc_buffer arguments
 +
 +2011-01-31 - 910b5b8 - lavfi 1.75.0 - AVFilterLink sample_aspect_ratio
 +  Add sample_aspect_ratio field to AVFilterLink.
 +
  2011-01-15 - a242ac3 - lavfi 1.74.0 - AVFilterBufferRefAudioProps
    Rename AVFilterBufferRefAudioProps.samples_nb to nb_samples.
  
diff --combined libavfilter/Makefile
@@@ -1,28 -1,11 +1,28 @@@
 +include $(SUBDIR)../config.mak
 +
  NAME = avfilter
  FFLIBS = avutil
 -FFLIBS-$(CONFIG_ASYNCTS_FILTER) += avresample
 -FFLIBS-$(CONFIG_MOVIE_FILTER) += avformat avcodec
 -FFLIBS-$(CONFIG_RESAMPLE_FILTER) += avresample
 -FFLIBS-$(CONFIG_SCALE_FILTER)   += swscale
 +FFLIBS-$(CONFIG_ACONVERT_FILTER)             += swresample
 +FFLIBS-$(CONFIG_AMOVIE_FILTER)               += avformat avcodec
 +FFLIBS-$(CONFIG_ARESAMPLE_FILTER)            += swresample
 +FFLIBS-$(CONFIG_ASYNCTS_FILTER)              += avresample
 +FFLIBS-$(CONFIG_ATEMPO_FILTER)               += avcodec
 +FFLIBS-$(CONFIG_DECIMATE_FILTER)             += avcodec
 +FFLIBS-$(CONFIG_DESHAKE_FILTER)              += avcodec
 +FFLIBS-$(CONFIG_MOVIE_FILTER)                += avformat avcodec
 +FFLIBS-$(CONFIG_MP_FILTER)                   += avcodec
 +FFLIBS-$(CONFIG_PAN_FILTER)                  += swresample
 +FFLIBS-$(CONFIG_PP_FILTER)                   += postproc
 +FFLIBS-$(CONFIG_REMOVELOGO_FILTER)           += avformat avcodec swscale
 +FFLIBS-$(CONFIG_RESAMPLE_FILTER)             += avresample
 +FFLIBS-$(CONFIG_SCALE_FILTER)                += swscale
 +FFLIBS-$(CONFIG_SHOWSPECTRUM_FILTER)         += avcodec
 +FFLIBS-$(CONFIG_SMARTBLUR_FILTER)            += swscale
 +FFLIBS-$(CONFIG_SUBTITLES_FILTER)            += avformat avcodec
  
 -HEADERS = avfilter.h                                                    \
 +HEADERS = asrc_abuffer.h                                                \
 +          avcodec.h                                                     \
 +          avfilter.h                                                    \
            avfiltergraph.h                                               \
            buffersink.h                                                  \
            buffersrc.h                                                   \
@@@ -38,212 -21,78 +38,214 @@@ OBJS = allfilters.
         drawutils.o                                                      \
         fifo.o                                                           \
         formats.o                                                        \
 +       graphdump.o                                                      \
         graphparser.o                                                    \
 +       opencl_allkernels.o                                              \
 +       transform.o                                                      \
         video.o                                                          \
  
 +
 +OBJS-$(CONFIG_AVCODEC)                       += avcodec.o
 +OBJS-$(CONFIG_AVFORMAT)                      += lavfutils.o
 +OBJS-$(CONFIG_SWSCALE)                       += lswsutils.o
 +
 +OBJS-$(CONFIG_ACONVERT_FILTER)               += af_aconvert.o
 +OBJS-$(CONFIG_AFADE_FILTER)                  += af_afade.o
  OBJS-$(CONFIG_AFORMAT_FILTER)                += af_aformat.o
 +OBJS-$(CONFIG_AINTERLEAVE_FILTER)            += f_interleave.o
 +OBJS-$(CONFIG_ALLPASS_FILTER)                += af_biquads.o
 +OBJS-$(CONFIG_AMERGE_FILTER)                 += af_amerge.o
  OBJS-$(CONFIG_AMIX_FILTER)                   += af_amix.o
  OBJS-$(CONFIG_ANULL_FILTER)                  += af_anull.o
 +OBJS-$(CONFIG_APAD_FILTER)                   += af_apad.o
 +OBJS-$(CONFIG_APERMS_FILTER)                 += f_perms.o
 +OBJS-$(CONFIG_APHASER_FILTER)                += af_aphaser.o
 +OBJS-$(CONFIG_ARESAMPLE_FILTER)              += af_aresample.o
 +OBJS-$(CONFIG_ASELECT_FILTER)                += f_select.o
 +OBJS-$(CONFIG_ASENDCMD_FILTER)               += f_sendcmd.o
 +OBJS-$(CONFIG_ASETNSAMPLES_FILTER)           += af_asetnsamples.o
  OBJS-$(CONFIG_ASETPTS_FILTER)                += setpts.o
 +OBJS-$(CONFIG_ASETRATE_FILTER)               += af_asetrate.o
 +OBJS-$(CONFIG_ASETTB_FILTER)                 += f_settb.o
  OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o
  OBJS-$(CONFIG_ASPLIT_FILTER)                 += split.o
 +OBJS-$(CONFIG_ASTATS_FILTER)                 += af_astats.o
 +OBJS-$(CONFIG_ASTREAMSYNC_FILTER)            += af_astreamsync.o
  OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o
 +OBJS-$(CONFIG_ATEMPO_FILTER)                 += af_atempo.o
  OBJS-$(CONFIG_ATRIM_FILTER)                  += trim.o
 +OBJS-$(CONFIG_AZMQ_FILTER)                   += f_zmq.o
 +OBJS-$(CONFIG_BANDPASS_FILTER)               += af_biquads.o
 +OBJS-$(CONFIG_BANDREJECT_FILTER)             += af_biquads.o
 +OBJS-$(CONFIG_BASS_FILTER)                   += af_biquads.o
 +OBJS-$(CONFIG_BIQUAD_FILTER)                 += af_biquads.o
  OBJS-$(CONFIG_CHANNELMAP_FILTER)             += af_channelmap.o
  OBJS-$(CONFIG_CHANNELSPLIT_FILTER)           += af_channelsplit.o
 +OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o
 +OBJS-$(CONFIG_EBUR128_FILTER)                += f_ebur128.o
 +OBJS-$(CONFIG_EQUALIZER_FILTER)              += af_biquads.o
 +OBJS-$(CONFIG_HIGHPASS_FILTER)               += af_biquads.o
  OBJS-$(CONFIG_JOIN_FILTER)                   += af_join.o
 +OBJS-$(CONFIG_LOWPASS_FILTER)                += af_biquads.o
 +OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o
  OBJS-$(CONFIG_RESAMPLE_FILTER)               += af_resample.o
 +OBJS-$(CONFIG_SILENCEDETECT_FILTER)          += af_silencedetect.o
 +OBJS-$(CONFIG_TREBLE_FILTER)                 += af_biquads.o
  OBJS-$(CONFIG_VOLUME_FILTER)                 += af_volume.o
 +OBJS-$(CONFIG_VOLUMEDETECT_FILTER)           += af_volumedetect.o
  
 +OBJS-$(CONFIG_AEVALSRC_FILTER)               += asrc_aevalsrc.o
  OBJS-$(CONFIG_ANULLSRC_FILTER)               += asrc_anullsrc.o
 +OBJS-$(CONFIG_FLITE_FILTER)                  += asrc_flite.o
 +OBJS-$(CONFIG_SINE_FILTER)                   += asrc_sine.o
  
  OBJS-$(CONFIG_ANULLSINK_FILTER)              += asink_anullsink.o
  
 +OBJS-$(CONFIG_ASS_FILTER)                    += vf_subtitles.o
 +OBJS-$(CONFIG_ALPHAEXTRACT_FILTER)           += vf_extractplanes.o
 +OBJS-$(CONFIG_ALPHAMERGE_FILTER)             += vf_alphamerge.o
 +OBJS-$(CONFIG_BBOX_FILTER)                   += bbox.o vf_bbox.o
 +OBJS-$(CONFIG_BLACKDETECT_FILTER)            += vf_blackdetect.o
  OBJS-$(CONFIG_BLACKFRAME_FILTER)             += vf_blackframe.o
 +OBJS-$(CONFIG_BLEND_FILTER)                  += vf_blend.o
  OBJS-$(CONFIG_BOXBLUR_FILTER)                += vf_boxblur.o
 +OBJS-$(CONFIG_COLORBALANCE_FILTER)           += vf_colorbalance.o
 +OBJS-$(CONFIG_COLORCHANNELMIXER_FILTER)      += vf_colorchannelmixer.o
 +OBJS-$(CONFIG_COLORMATRIX_FILTER)            += vf_colormatrix.o
  OBJS-$(CONFIG_COPY_FILTER)                   += vf_copy.o
  OBJS-$(CONFIG_CROP_FILTER)                   += vf_crop.o
  OBJS-$(CONFIG_CROPDETECT_FILTER)             += vf_cropdetect.o
 +OBJS-$(CONFIG_CURVES_FILTER)                 += vf_curves.o
 +OBJS-$(CONFIG_DCTDNOIZ_FILTER)               += vf_dctdnoiz.o
 +OBJS-$(CONFIG_DECIMATE_FILTER)               += vf_decimate.o
  OBJS-$(CONFIG_DELOGO_FILTER)                 += vf_delogo.o
 +OBJS-$(CONFIG_DESHAKE_FILTER)                += vf_deshake.o
  OBJS-$(CONFIG_DRAWBOX_FILTER)                += vf_drawbox.o
 +OBJS-$(CONFIG_DRAWGRID_FILTER)               += vf_drawbox.o
  OBJS-$(CONFIG_DRAWTEXT_FILTER)               += vf_drawtext.o
 +OBJS-$(CONFIG_EDGEDETECT_FILTER)             += vf_edgedetect.o
 +OBJS-$(CONFIG_EXTRACTPLANES_FILTER)          += vf_extractplanes.o
  OBJS-$(CONFIG_FADE_FILTER)                   += vf_fade.o
 +OBJS-$(CONFIG_FIELD_FILTER)                  += vf_field.o
 +OBJS-$(CONFIG_FIELDMATCH_FILTER)             += vf_fieldmatch.o
  OBJS-$(CONFIG_FIELDORDER_FILTER)             += vf_fieldorder.o
  OBJS-$(CONFIG_FORMAT_FILTER)                 += vf_format.o
 +OBJS-$(CONFIG_FRAMESTEP_FILTER)              += vf_framestep.o
  OBJS-$(CONFIG_FPS_FILTER)                    += vf_fps.o
  OBJS-$(CONFIG_FREI0R_FILTER)                 += vf_frei0r.o
 +OBJS-$(CONFIG_GEQ_FILTER)                    += vf_geq.o
  OBJS-$(CONFIG_GRADFUN_FILTER)                += vf_gradfun.o
  OBJS-$(CONFIG_HFLIP_FILTER)                  += vf_hflip.o
 +OBJS-$(CONFIG_HISTEQ_FILTER)                 += vf_histeq.o
 +OBJS-$(CONFIG_HISTOGRAM_FILTER)              += vf_histogram.o
  OBJS-$(CONFIG_HQDN3D_FILTER)                 += vf_hqdn3d.o
 +OBJS-$(CONFIG_HUE_FILTER)                    += vf_hue.o
 +OBJS-$(CONFIG_IDET_FILTER)                   += vf_idet.o
 +OBJS-$(CONFIG_IL_FILTER)                     += vf_il.o
  OBJS-$(CONFIG_INTERLACE_FILTER)              += vf_interlace.o
 +OBJS-$(CONFIG_INTERLEAVE_FILTER)             += f_interleave.o
 +OBJS-$(CONFIG_KERNDEINT_FILTER)              += vf_kerndeint.o
 +OBJS-$(CONFIG_LUT3D_FILTER)                  += vf_lut3d.o
  OBJS-$(CONFIG_LUT_FILTER)                    += vf_lut.o
  OBJS-$(CONFIG_LUTRGB_FILTER)                 += vf_lut.o
  OBJS-$(CONFIG_LUTYUV_FILTER)                 += vf_lut.o
 +OBJS-$(CONFIG_MP_FILTER)                     += vf_mp.o
 +OBJS-$(CONFIG_MPDECIMATE_FILTER)             += vf_mpdecimate.o
  OBJS-$(CONFIG_NEGATE_FILTER)                 += vf_lut.o
  OBJS-$(CONFIG_NOFORMAT_FILTER)               += vf_format.o
 +OBJS-$(CONFIG_NOISE_FILTER)                  += vf_noise.o
  OBJS-$(CONFIG_NULL_FILTER)                   += vf_null.o
  OBJS-$(CONFIG_OCV_FILTER)                    += vf_libopencv.o
 +OBJS-$(CONFIG_OPENCL)                        += deshake_opencl.o unsharp_opencl.o
  OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o
 +OBJS-$(CONFIG_OWDENOISE_FILTER)              += vf_owdenoise.o
  OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o
 +OBJS-$(CONFIG_PERMS_FILTER)                  += f_perms.o
  OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o
 +OBJS-$(CONFIG_PP_FILTER)                     += vf_pp.o
 +OBJS-$(CONFIG_REMOVELOGO_FILTER)             += bbox.o lswsutils.o lavfutils.o vf_removelogo.o
 +OBJS-$(CONFIG_SEPARATEFIELDS_FILTER)         += vf_separatefields.o
  OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o
 -OBJS-$(CONFIG_SELECT_FILTER)                 += vf_select.o
 +OBJS-$(CONFIG_SELECT_FILTER)                 += f_select.o
 +OBJS-$(CONFIG_SENDCMD_FILTER)                += f_sendcmd.o
  OBJS-$(CONFIG_SETDAR_FILTER)                 += vf_aspect.o
 +OBJS-$(CONFIG_SETFIELD_FILTER)               += vf_setfield.o
  OBJS-$(CONFIG_SETPTS_FILTER)                 += setpts.o
  OBJS-$(CONFIG_SETSAR_FILTER)                 += vf_aspect.o
 -OBJS-$(CONFIG_SETTB_FILTER)                  += vf_settb.o
 +OBJS-$(CONFIG_SETTB_FILTER)                  += f_settb.o
  OBJS-$(CONFIG_SHOWINFO_FILTER)               += vf_showinfo.o
 +OBJS-$(CONFIG_SMARTBLUR_FILTER)              += vf_smartblur.o
  OBJS-$(CONFIG_SPLIT_FILTER)                  += split.o
 +OBJS-$(CONFIG_STEREO3D_FILTER)               += vf_stereo3d.o
 +OBJS-$(CONFIG_SUBTITLES_FILTER)              += vf_subtitles.o
 +OBJS-$(CONFIG_SUPER2XSAI_FILTER)             += vf_super2xsai.o
 +OBJS-$(CONFIG_SWAPUV_FILTER)                 += vf_swapuv.o
 +OBJS-$(CONFIG_TELECINE_FILTER)               += vf_telecine.o
 +OBJS-$(CONFIG_THUMBNAIL_FILTER)              += vf_thumbnail.o
 +OBJS-$(CONFIG_TILE_FILTER)                   += vf_tile.o
 +OBJS-$(CONFIG_TINTERLACE_FILTER)             += vf_tinterlace.o
  OBJS-$(CONFIG_TRANSPOSE_FILTER)              += vf_transpose.o
  OBJS-$(CONFIG_TRIM_FILTER)                   += trim.o
  OBJS-$(CONFIG_UNSHARP_FILTER)                += vf_unsharp.o
  OBJS-$(CONFIG_VFLIP_FILTER)                  += vf_vflip.o
 +OBJS-$(CONFIG_VIDSTABDETECT_FILTER)          += vidstabutils.o vf_vidstabdetect.o
 +OBJS-$(CONFIG_VIDSTABTRANSFORM_FILTER)       += vidstabutils.o vf_vidstabtransform.o
  OBJS-$(CONFIG_YADIF_FILTER)                  += vf_yadif.o
 +OBJS-$(CONFIG_ZMQ_FILTER)                    += f_zmq.o
  
 -OBJS-$(CONFIG_COLOR_FILTER)                  += vsrc_color.o
 +OBJS-$(CONFIG_CELLAUTO_FILTER)               += vsrc_cellauto.o
 +OBJS-$(CONFIG_COLOR_FILTER)                  += vsrc_testsrc.o
  OBJS-$(CONFIG_FREI0R_SRC_FILTER)             += vf_frei0r.o
 -OBJS-$(CONFIG_MOVIE_FILTER)                  += vsrc_movie.o
 -OBJS-$(CONFIG_NULLSRC_FILTER)                += vsrc_nullsrc.o
 +OBJS-$(CONFIG_LIFE_FILTER)                   += vsrc_life.o
 +OBJS-$(CONFIG_MANDELBROT_FILTER)             += vsrc_mandelbrot.o
 +OBJS-$(CONFIG_MPTESTSRC_FILTER)              += vsrc_mptestsrc.o
 +OBJS-$(CONFIG_NULLSRC_FILTER)                += vsrc_testsrc.o
  OBJS-$(CONFIG_RGBTESTSRC_FILTER)             += vsrc_testsrc.o
 +OBJS-$(CONFIG_SMPTEBARS_FILTER)              += vsrc_testsrc.o
 +OBJS-$(CONFIG_SMPTEHDBARS_FILTER)            += vsrc_testsrc.o
  OBJS-$(CONFIG_TESTSRC_FILTER)                += vsrc_testsrc.o
  
  OBJS-$(CONFIG_NULLSINK_FILTER)               += vsink_nullsink.o
  
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/mp_image.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/img_format.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_dint.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_eq2.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_eq.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_fil.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_fspp.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_ilpack.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_mcdeint.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_perspective.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_phase.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_pp7.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_pullup.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_qp.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_sab.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_softpulldown.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_spp.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/vf_uspp.o
 +OBJS-$(CONFIG_MP_FILTER) += libmpcodecs/pullup.o
 +
 +# multimedia filters
 +OBJS-$(CONFIG_AVECTORSCOPE_FILTER)           += avf_avectorscope.o
 +OBJS-$(CONFIG_CONCAT_FILTER)                 += avf_concat.o
 +OBJS-$(CONFIG_SHOWSPECTRUM_FILTER)           += avf_showspectrum.o
 +OBJS-$(CONFIG_SHOWWAVES_FILTER)              += avf_showwaves.o
 +
 +# multimedia sources
 +OBJS-$(CONFIG_AMOVIE_FILTER)                 += src_movie.o
 +OBJS-$(CONFIG_MOVIE_FILTER)                  += src_movie.o
 +
 +SKIPHEADERS-$(CONFIG_LIBVIDSTAB)             += vidstabutils.h
 +SKIPHEADERS-$(CONFIG_OPENCL)                 += opencl_internal.h deshake_opencl_kernel.h unsharp_opencl_kernel.h
 +
+ OBJS-$(HAVE_THREADS)                         += pthread.o
  TOOLS     = graph2dot
 -TESTPROGS = filtfmts
 +TESTPROGS = drawutils filtfmts formats
 +
 +TOOLS-$(CONFIG_LIBZMQ) += zmqsend
 +
 +clean::
 +      $(RM) $(CLEANSUFFIXES:%=libavfilter/libmpcodecs/%)
diff --combined libavfilter/avfilter.c
@@@ -2,28 -2,26 +2,28 @@@
   * filter layer
   * Copyright (c) 2007 Bobby Bingham
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
  #include "libavutil/channel_layout.h"
  #include "libavutil/common.h"
 +#include "libavutil/eval.h"
  #include "libavutil/imgutils.h"
  #include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
  #include "avfilter.h"
  #include "formats.h"
  #include "internal.h"
 -#include "video.h"
 +#include "audio.h"
 +
 +static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame);
 +
 +void ff_tlog_ref(void *ctx, AVFrame *ref, int end)
 +{
 +    av_unused char buf[16];
 +    ff_tlog(ctx,
 +            "ref[%p buf:%p data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
 +            ref, ref->buf, ref->data[0],
 +            ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
 +            ref->pts, av_frame_get_pkt_pos(ref));
 +
 +    if (ref->width) {
 +        ff_tlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
 +                ref->sample_aspect_ratio.num, ref->sample_aspect_ratio.den,
 +                ref->width, ref->height,
 +                !ref->interlaced_frame     ? 'P' :         /* Progressive  */
 +                ref->top_field_first ? 'T' : 'B',    /* Top / Bottom */
 +                ref->key_frame,
 +                av_get_picture_type_char(ref->pict_type));
 +    }
 +    if (ref->nb_samples) {
 +        ff_tlog(ctx, " cl:%"PRId64"d n:%d r:%d",
 +                ref->channel_layout,
 +                ref->nb_samples,
 +                ref->sample_rate);
 +    }
 +
 +    ff_tlog(ctx, "]%s", end ? "\n" : "");
 +}
  
  unsigned avfilter_version(void)
  {
 +    av_assert0(LIBAVFILTER_VERSION_MICRO >= 100);
      return LIBAVFILTER_VERSION_INT;
  }
  
  const char *avfilter_configuration(void)
  {
 -    return LIBAV_CONFIGURATION;
 +    return FFMPEG_CONFIGURATION;
  }
  
  const char *avfilter_license(void)
  {
  #define LICENSE_PREFIX "libavfilter license: "
 -    return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +    return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
 +}
 +
 +void ff_command_queue_pop(AVFilterContext *filter)
 +{
 +    AVFilterCommand *c= filter->command_queue;
 +    av_freep(&c->arg);
 +    av_freep(&c->command);
 +    filter->command_queue= c->next;
 +    av_free(c);
  }
  
  void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
@@@ -124,9 -82,8 +124,9 @@@ int avfilter_link(AVFilterContext *src
  
      if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
          av_log(src, AV_LOG_ERROR,
 -               "Media type mismatch between the '%s' filter output pad %d and the '%s' filter input pad %d\n",
 -               src->name, srcpad, dst->name, dstpad);
 +               "Media type mismatch between the '%s' filter output pad %d (%s) and the '%s' filter input pad %d (%s)\n",
 +               src->name, srcpad, (char *)av_x_if_null(av_get_media_type_string(src->output_pads[srcpad].type), "?"),
 +               dst->name, dstpad, (char *)av_x_if_null(av_get_media_type_string(dst-> input_pads[dstpad].type), "?"));
          return AVERROR(EINVAL);
      }
  
      link->srcpad  = &src->output_pads[srcpad];
      link->dstpad  = &dst->input_pads[dstpad];
      link->type    = src->output_pads[srcpad].type;
 -    assert(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
 +    av_assert0(AV_PIX_FMT_NONE == -1 && AV_SAMPLE_FMT_NONE == -1);
      link->format  = -1;
  
      return 0;
  }
  
 +void avfilter_link_free(AVFilterLink **link)
 +{
 +    if (!*link)
 +        return;
 +
 +    av_frame_free(&(*link)->partial_buf);
 +
 +    av_freep(link);
 +}
 +
 +int avfilter_link_get_channels(AVFilterLink *link)
 +{
 +    return link->channels;
 +}
 +
 +void avfilter_link_set_closed(AVFilterLink *link, int closed)
 +{
 +    link->closed = closed;
 +}
 +
  int avfilter_insert_filter(AVFilterLink *link, AVFilterContext *filt,
                             unsigned filt_srcpad_idx, unsigned filt_dstpad_idx)
  {
@@@ -212,13 -149,9 +212,13 @@@ int avfilter_config_links(AVFilterConte
  
      for (i = 0; i < filter->nb_inputs; i ++) {
          AVFilterLink *link = filter->inputs[i];
 +        AVFilterLink *inlink;
  
          if (!link) continue;
  
 +        inlink = link->src->nb_inputs ? link->src->inputs[0] : NULL;
 +        link->current_pts = AV_NOPTS_VALUE;
 +
          switch (link->init_state) {
          case AVLINK_INIT:
              continue;
                  return ret;
              }
  
 -            if (link->time_base.num == 0 && link->time_base.den == 0)
 -                link->time_base = link->src && link->src->nb_inputs ?
 -                    link->src->inputs[0]->time_base : AV_TIME_BASE_Q;
 +            switch (link->type) {
 +            case AVMEDIA_TYPE_VIDEO:
 +                if (!link->time_base.num && !link->time_base.den)
 +                    link->time_base = inlink ? inlink->time_base : AV_TIME_BASE_Q;
  
 -            if (link->type == AVMEDIA_TYPE_VIDEO) {
                  if (!link->sample_aspect_ratio.num && !link->sample_aspect_ratio.den)
 -                    link->sample_aspect_ratio = link->src->nb_inputs ?
 -                        link->src->inputs[0]->sample_aspect_ratio : (AVRational){1,1};
 +                    link->sample_aspect_ratio = inlink ?
 +                        inlink->sample_aspect_ratio : (AVRational){1,1};
 +
 +                if (inlink && !link->frame_rate.num && !link->frame_rate.den)
 +                    link->frame_rate = inlink->frame_rate;
  
 -                if (link->src->nb_inputs) {
 +                if (inlink) {
                      if (!link->w)
 -                        link->w = link->src->inputs[0]->w;
 +                        link->w = inlink->w;
                      if (!link->h)
 -                        link->h = link->src->inputs[0]->h;
 +                        link->h = inlink->h;
                  } else if (!link->w || !link->h) {
                      av_log(link->src, AV_LOG_ERROR,
                             "Video source filters must set their output link's "
                             "width and height\n");
                      return AVERROR(EINVAL);
                  }
 +                break;
 +
 +            case AVMEDIA_TYPE_AUDIO:
 +                if (inlink) {
 +                    if (!link->time_base.num && !link->time_base.den)
 +                        link->time_base = inlink->time_base;
 +                }
 +
 +                if (!link->time_base.num && !link->time_base.den)
 +                    link->time_base = (AVRational) {1, link->sample_rate};
              }
  
              if ((config_link = link->dstpad->config_props))
      return 0;
  }
  
 -void ff_dlog_link(void *ctx, AVFilterLink *link, int end)
 +void ff_tlog_link(void *ctx, AVFilterLink *link, int end)
  {
      if (link->type == AVMEDIA_TYPE_VIDEO) {
 -        av_dlog(ctx,
 -                "link[%p s:%dx%d fmt:%-16s %-16s->%-16s]%s",
 +        ff_tlog(ctx,
 +                "link[%p s:%dx%d fmt:%s %s->%s]%s",
                  link, link->w, link->h,
                  av_get_pix_fmt_name(link->format),
                  link->src ? link->src->filter->name : "",
          char buf[128];
          av_get_channel_layout_string(buf, sizeof(buf), -1, link->channel_layout);
  
 -        av_dlog(ctx,
 -                "link[%p r:%d cl:%s fmt:%-16s %-16s->%-16s]%s",
 -                link, link->sample_rate, buf,
 +        ff_tlog(ctx,
 +                "link[%p r:%d cl:%s fmt:%s %s->%s]%s",
 +                link, (int)link->sample_rate, buf,
                  av_get_sample_fmt_name(link->format),
                  link->src ? link->src->filter->name : "",
                  link->dst ? link->dst->filter->name : "",
  
  int ff_request_frame(AVFilterLink *link)
  {
 -    FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);
 -
 -    if (link->srcpad->request_frame)
 -        return link->srcpad->request_frame(link);
 -    else if (link->src->inputs[0])
 -        return ff_request_frame(link->src->inputs[0]);
 -    else return -1;
 +    int ret = -1;
 +    FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1);
 +
 +    if (link->closed)
 +        return AVERROR_EOF;
 +    av_assert0(!link->frame_requested);
 +    link->frame_requested = 1;
 +    while (link->frame_requested) {
 +        if (link->srcpad->request_frame)
 +            ret = link->srcpad->request_frame(link);
 +        else if (link->src->inputs[0])
 +            ret = ff_request_frame(link->src->inputs[0]);
 +        if (ret == AVERROR_EOF && link->partial_buf) {
 +            AVFrame *pbuf = link->partial_buf;
 +            link->partial_buf = NULL;
 +            ret = ff_filter_frame_framed(link, pbuf);
 +        }
 +        if (ret < 0) {
 +            link->frame_requested = 0;
 +            if (ret == AVERROR_EOF)
 +                link->closed = 1;
 +        } else {
 +            av_assert0(!link->frame_requested ||
 +                       link->flags & FF_LINK_FLAG_REQUEST_LOOP);
 +        }
 +    }
 +    return ret;
  }
  
  int ff_poll_frame(AVFilterLink *link)
      return min;
  }
  
 +static const char *const var_names[] = {   "t",   "n",   "pos",        NULL };
 +enum                                   { VAR_T, VAR_N, VAR_POS, VAR_VARS_NB };
 +
 +static int set_enable_expr(AVFilterContext *ctx, const char *expr)
 +{
 +    int ret;
 +    char *expr_dup;
 +    AVExpr *old = ctx->enable;
 +
 +    if (!(ctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE)) {
 +        av_log(ctx, AV_LOG_ERROR, "Timeline ('enable' option) not supported "
 +               "with filter '%s'\n", ctx->filter->name);
 +        return AVERROR_PATCHWELCOME;
 +    }
 +
 +    expr_dup = av_strdup(expr);
 +    if (!expr_dup)
 +        return AVERROR(ENOMEM);
 +
 +    if (!ctx->var_values) {
 +        ctx->var_values = av_calloc(VAR_VARS_NB, sizeof(*ctx->var_values));
 +        if (!ctx->var_values) {
 +            av_free(expr_dup);
 +            return AVERROR(ENOMEM);
 +        }
 +    }
 +
 +    ret = av_expr_parse((AVExpr**)&ctx->enable, expr_dup, var_names,
 +                        NULL, NULL, NULL, NULL, 0, ctx->priv);
 +    if (ret < 0) {
 +        av_log(ctx->priv, AV_LOG_ERROR,
 +               "Error when evaluating the expression '%s' for enable\n",
 +               expr_dup);
 +        av_free(expr_dup);
 +        return ret;
 +    }
 +
 +    av_expr_free(old);
 +    av_free(ctx->enable_str);
 +    ctx->enable_str = expr_dup;
 +    return 0;
 +}
 +
 +void ff_update_link_current_pts(AVFilterLink *link, int64_t pts)
 +{
 +    if (pts == AV_NOPTS_VALUE)
 +        return;
 +    link->current_pts = av_rescale_q(pts, link->time_base, AV_TIME_BASE_Q);
 +    /* TODO use duration */
 +    if (link->graph && link->age_index >= 0)
 +        ff_avfilter_graph_update_heap(link->graph, link);
 +}
 +
 +int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags)
 +{
 +    if(!strcmp(cmd, "ping")){
 +        av_strlcatf(res, res_len, "pong from:%s %s\n", filter->filter->name, filter->name);
 +        return 0;
 +    }else if(!strcmp(cmd, "enable")) {
 +        return set_enable_expr(filter, arg);
 +    }else if(filter->filter->process_command) {
 +        return filter->filter->process_command(filter, cmd, arg, res, res_len, flags);
 +    }
 +    return AVERROR(ENOSYS);
 +}
 +
  static AVFilter *first_filter;
  
  AVFilter *avfilter_get_by_name(const char *name)
  {
 -    AVFilter *f = NULL;
 +    const AVFilter *f = NULL;
  
      if (!name)
          return NULL;
  
      while ((f = avfilter_next(f)))
          if (!strcmp(f->name, name))
 -            return f;
 +            return (AVFilter *)f;
  
      return NULL;
  }
  int avfilter_register(AVFilter *filter)
  {
      AVFilter **f = &first_filter;
 +    int i;
 +
 +    /* the filter must select generic or internal exclusively */
 +    av_assert0((filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE) != AVFILTER_FLAG_SUPPORT_TIMELINE);
 +
 +    for(i=0; filter->inputs && filter->inputs[i].name; i++) {
 +        const AVFilterPad *input = &filter->inputs[i];
 +        av_assert0(     !input->filter_frame
 +                    || (!input->start_frame && !input->end_frame));
 +    }
 +
      while (*f)
          f = &(*f)->next;
      *f = filter;
      filter->next = NULL;
 +
      return 0;
  }
  
@@@ -501,10 -323,10 +501,10 @@@ int avfilter_pad_count(const AVFilterPa
      return count;
  }
  
 -static const char *filter_name(void *p)
 +static const char *default_filter_name(void *filter_ctx)
  {
 -    AVFilterContext *filter = p;
 -    return filter->filter->name;
 +    AVFilterContext *ctx = filter_ctx;
 +    return ctx->name ? ctx->name : ctx->filter->name;
  }
  
  static void *filter_child_next(void *obj, void *prev)
  
  static const AVClass *filter_child_class_next(const AVClass *prev)
  {
 -    AVFilter *f = NULL;
 +    const AVFilter *f = NULL;
  
 +    /* find the filter that corresponds to prev */
      while (prev && (f = avfilter_next(f)))
          if (f->priv_class == prev)
              break;
  
 +    /* could not find filter corresponding to prev */
 +    if (prev && !f)
 +        return NULL;
 +
 +    /* find next filter with specific options */
      while ((f = avfilter_next(f)))
          if (f->priv_class)
              return f->priv_class;
  }
  
  #define OFFSET(x) offsetof(AVFilterContext, x)
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
 +#define FLAGS AV_OPT_FLAG_FILTERING_PARAM
- static const AVOption filters_common_options[] = {
+ static const AVOption options[] = {
+     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
+         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
+         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .unit = "thread_type" },
 +    { "enable", "set enable expression", OFFSET(enable_str), AV_OPT_TYPE_STRING, {.str=NULL}, .flags = FLAGS },
-     { NULL }
+     { NULL },
  };
  
  static const AVClass avfilter_class = {
      .class_name = "AVFilter",
 -    .item_name  = filter_name,
 +    .item_name  = default_filter_name,
      .version    = LIBAVUTIL_VERSION_INT,
 +    .category   = AV_CLASS_CATEGORY_FILTER,
      .child_next = filter_child_next,
-     .option     = filters_common_options,
      .child_class_next = filter_child_class_next,
+     .option           = options,
  };
  
+ static int default_execute(AVFilterContext *ctx, action_func *func, void *arg,
+                            int *ret, int nb_jobs)
+ {
+     int i;
+     for (i = 0; i < nb_jobs; i++) {
+         int r = func(ctx, arg, i, nb_jobs);
+         if (ret)
+             ret[i] = r;
+     }
+     return 0;
+ }
  AVFilterContext *ff_filter_alloc(const AVFilter *filter, const char *inst_name)
  {
      AVFilterContext *ret;
              goto err;
      }
  
+     av_opt_set_defaults(ret);
      if (filter->priv_class) {
          *(const AVClass**)ret->priv = filter->priv_class;
          av_opt_set_defaults(ret->priv);
      }
  
+     ret->internal = av_mallocz(sizeof(*ret->internal));
+     if (!ret->internal)
+         goto err;
+     ret->internal->execute = default_execute;
      ret->nb_inputs = avfilter_pad_count(filter->inputs);
      if (ret->nb_inputs ) {
          ret->input_pads   = av_malloc(sizeof(AVFilterPad) * ret->nb_inputs);
@@@ -614,6 -450,7 +636,7 @@@ err
      av_freep(&ret->output_pads);
      ret->nb_outputs = 0;
      av_freep(&ret->priv);
+     av_freep(&ret->internal);
      av_free(ret);
      return NULL;
  }
@@@ -642,16 -479,13 +665,16 @@@ static void free_link(AVFilterLink *lin
      ff_formats_unref(&link->out_samplerates);
      ff_channel_layouts_unref(&link->in_channel_layouts);
      ff_channel_layouts_unref(&link->out_channel_layouts);
 -    av_freep(&link);
 +    avfilter_link_free(&link);
  }
  
  void avfilter_free(AVFilterContext *filter)
  {
      int i;
  
 +    if (!filter)
 +        return;
 +
      if (filter->graph)
          ff_filter_graph_remove_filter(filter->graph, filter);
  
      av_freep(&filter->inputs);
      av_freep(&filter->outputs);
      av_freep(&filter->priv);
 +    while(filter->command_queue){
 +        ff_command_queue_pop(filter);
 +    }
 +    av_opt_free(filter);
 +    av_expr_free(filter->enable);
 +    filter->enable = NULL;
 +    av_freep(&filter->var_values);
+     av_freep(&filter->internal);
      av_free(filter);
  }
  
 -/* process a list of value1:value2:..., each value corresponding
 - * to subsequent AVOption, in the order they are declared */
 -static int process_unnamed_options(AVFilterContext *ctx, AVDictionary **options,
 -                                   const char *args)
 +static int process_options(AVFilterContext *ctx, AVDictionary **options,
 +                           const char *args)
  {
      const AVOption *o = NULL;
 -    const char *p = args;
 -    char *val;
 +    int ret, count = 0;
 +    char *av_uninit(parsed_key), *av_uninit(value);
 +    const char *key;
 +    int offset= -1;
 +
 +    av_opt_set_defaults(ctx);
 +
 +    if (!args)
 +        return 0;
 +
 +    while (*args) {
 +        const char *shorthand = NULL;
  
 -    while (*p) {
          o = av_opt_next(ctx->priv, o);
 -        if (!o) {
 -            av_log(ctx, AV_LOG_ERROR, "More options provided than "
 -                   "this filter supports.\n");
 -            return AVERROR(EINVAL);
 +        if (o) {
 +            if (o->type == AV_OPT_TYPE_CONST || o->offset == offset)
 +                continue;
 +            offset = o->offset;
 +            shorthand = o->name;
          }
 -        if (o->type == AV_OPT_TYPE_CONST)
 -            continue;
  
 -        val = av_get_token(&p, ":");
 -        if (!val)
 -            return AVERROR(ENOMEM);
 +        ret = av_opt_get_key_value(&args, "=", ":",
 +                                   shorthand ? AV_OPT_FLAG_IMPLICIT_KEY : 0,
 +                                   &parsed_key, &value);
 +        if (ret < 0) {
 +            if (ret == AVERROR(EINVAL))
 +                av_log(ctx, AV_LOG_ERROR, "No option name near '%s'\n", args);
 +            else
 +                av_log(ctx, AV_LOG_ERROR, "Unable to parse '%s': %s\n", args,
 +                       av_err2str(ret));
 +            return ret;
 +        }
 +        if (*args)
 +            args++;
 +        if (parsed_key) {
 +            key = parsed_key;
 +            while ((o = av_opt_next(ctx->priv, o))); /* discard all remaining shorthand */
 +        } else {
 +            key = shorthand;
 +        }
  
 -        av_dict_set(options, o->name, val, 0);
 +        av_log(ctx, AV_LOG_DEBUG, "Setting '%s' to value '%s'\n", key, value);
 +
 +        if (av_opt_find(ctx, key, NULL, 0, 0)) {
 +            ret = av_opt_set(ctx, key, value, 0);
 +            if (ret < 0)
 +                return ret;
 +        } else {
 +        av_dict_set(options, key, value, 0);
 +        if ((ret = av_opt_set(ctx->priv, key, value, 0)) < 0) {
 +            if (!av_opt_find(ctx->priv, key, NULL, 0, AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ)) {
 +            if (ret == AVERROR_OPTION_NOT_FOUND)
 +                av_log(ctx, AV_LOG_ERROR, "Option '%s' not found\n", key);
 +            av_free(value);
 +            av_free(parsed_key);
 +            return ret;
 +            }
 +        }
 +        }
  
 -        av_freep(&val);
 -        if (*p)
 -            p++;
 +        av_free(value);
 +        av_free(parsed_key);
 +        count++;
      }
  
 -    return 0;
 +    if (ctx->enable_str) {
 +        ret = set_enable_expr(ctx, ctx->enable_str);
 +        if (ret < 0)
 +            return ret;
 +    }
 +    return count;
  }
  
  #if FF_API_AVFILTER_INIT_FILTER
@@@ -772,6 -556,21 +796,21 @@@ int avfilter_init_dict(AVFilterContext 
  {
      int ret = 0;
  
+     ret = av_opt_set_dict(ctx, options);
+     if (ret < 0) {
+         av_log(ctx, AV_LOG_ERROR, "Error applying generic filter options.\n");
+         return ret;
+     }
+     if (ctx->filter->flags & AVFILTER_FLAG_SLICE_THREADS &&
+         ctx->thread_type & ctx->graph->thread_type & AVFILTER_THREAD_SLICE &&
+         ctx->graph->internal->thread_execute) {
+         ctx->thread_type       = AVFILTER_THREAD_SLICE;
+         ctx->internal->execute = ctx->graph->internal->thread_execute;
+     } else {
+         ctx->thread_type = 0;
+     }
      if (ctx->filter->priv_class) {
          ret = av_opt_set_dict(ctx->priv, options);
          if (ret < 0) {
          }
      }
  
 -    if (ctx->filter->init)
 +    if (ctx->filter->init_opaque)
 +        ret = ctx->filter->init_opaque(ctx, NULL);
 +    else if (ctx->filter->init)
          ret = ctx->filter->init(ctx);
      else if (ctx->filter->init_dict)
          ret = ctx->filter->init_dict(ctx, options);
@@@ -804,20 -601,51 +843,20 @@@ int avfilter_init_str(AVFilterContext *
          }
  
  #if FF_API_OLD_FILTER_OPTS
 -        if (!strcmp(filter->filter->name, "scale") &&
 -            strchr(args, ':') && strchr(args, ':') < strchr(args, '=')) {
 -            /* old w:h:flags=<flags> syntax */
 -            char *copy = av_strdup(args);
 -            char *p;
 -
 -            av_log(filter, AV_LOG_WARNING, "The <w>:<h>:flags=<flags> option "
 -                   "syntax is deprecated. Use either <w>:<h>:<flags> or "
 -                   "w=<w>:h=<h>:flags=<flags>.\n");
 -
 -            if (!copy) {
 -                ret = AVERROR(ENOMEM);
 -                goto fail;
 -            }
 -
 -            p = strrchr(copy, ':');
 -            if (p) {
 -                *p++ = 0;
 -                ret = av_dict_parse_string(&options, p, "=", ":", 0);
 -            }
 -            if (ret >= 0)
 -                ret = process_unnamed_options(filter, &options, copy);
 -            av_freep(&copy);
 -
 -            if (ret < 0)
 -                goto fail;
 -        } else
 -#endif
 -
 -        if (strchr(args, '=')) {
 -            /* assume a list of key1=value1:key2=value2:... */
 -            ret = av_dict_parse_string(&options, args, "=", ":", 0);
 -            if (ret < 0)
 -                goto fail;
 -#if FF_API_OLD_FILTER_OPTS
 -        } else if (!strcmp(filter->filter->name, "format")     ||
 +            if (   !strcmp(filter->filter->name, "format")     ||
                     !strcmp(filter->filter->name, "noformat")   ||
                     !strcmp(filter->filter->name, "frei0r")     ||
                     !strcmp(filter->filter->name, "frei0r_src") ||
 -                   !strcmp(filter->filter->name, "ocv")) {
 +                   !strcmp(filter->filter->name, "ocv")        ||
 +                   !strcmp(filter->filter->name, "pan")        ||
 +                   !strcmp(filter->filter->name, "pp")         ||
 +                   !strcmp(filter->filter->name, "aevalsrc")) {
              /* a hack for compatibility with the old syntax
               * replace colons with |s */
              char *copy = av_strdup(args);
              char *p    = copy;
              int nb_leading = 0; // number of leading colons to skip
 +            int deprecated = 0;
  
              if (!copy) {
                  ret = AVERROR(ENOMEM);
                  p++;
              }
  
 -            if (strchr(p, ':')) {
 -                av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
 -                       "'|' to separate the list items.\n");
 -            }
 -
 +            deprecated = strchr(p, ':') != NULL;
 +
 +            if (!strcmp(filter->filter->name, "aevalsrc")) {
 +                deprecated = 0;
 +                while ((p = strchr(p, ':')) && p[1] != ':') {
 +                    const char *epos = strchr(p + 1, '=');
 +                    const char *spos = strchr(p + 1, ':');
 +                    const int next_token_is_opt = epos && (!spos || epos < spos);
 +                    if (next_token_is_opt) {
 +                        p++;
 +                        break;
 +                    }
 +                    /* next token does not contain a '=', assume a channel expression */
 +                    deprecated = 1;
 +                    *p++ = '|';
 +                }
 +                if (p && *p == ':') { // double sep '::' found
 +                    deprecated = 1;
 +                    memmove(p, p + 1, strlen(p));
 +                }
 +            } else
              while ((p = strchr(p, ':')))
                  *p++ = '|';
  
 -            ret = process_unnamed_options(filter, &options, copy);
 +            if (deprecated)
 +                av_log(filter, AV_LOG_WARNING, "This syntax is deprecated. Use "
 +                       "'|' to separate the list items.\n");
 +
 +            av_log(filter, AV_LOG_DEBUG, "compat: called with args=[%s]\n", copy);
 +            ret = process_options(filter, &options, copy);
              av_freep(&copy);
  
              if (ret < 0)
                  goto fail;
  #endif
          } else {
 -            ret = process_unnamed_options(filter, &options, args);
 +#if CONFIG_MP_FILTER
 +            if (!strcmp(filter->filter->name, "mp")) {
 +                char *escaped;
 +
 +                if (!strncmp(args, "filter=", 7))
 +                    args += 7;
 +                ret = av_escape(&escaped, args, ":=", AV_ESCAPE_MODE_BACKSLASH, 0);
 +                if (ret < 0) {
 +                    av_log(filter, AV_LOG_ERROR, "Unable to escape MPlayer filters arg '%s'\n", args);
 +                    goto fail;
 +                }
 +                ret = process_options(filter, &options, escaped);
 +                av_free(escaped);
 +            } else
 +#endif
 +            ret = process_options(filter, &options, args);
              if (ret < 0)
                  goto fail;
          }
@@@ -927,20 -719,14 +966,20 @@@ static int default_filter_frame(AVFilte
      return ff_filter_frame(link->dst->outputs[0], frame);
  }
  
 -int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
 +static int ff_filter_frame_framed(AVFilterLink *link, AVFrame *frame)
  {
      int (*filter_frame)(AVFilterLink *, AVFrame *);
 +    AVFilterContext *dstctx = link->dst;
      AVFilterPad *dst = link->dstpad;
      AVFrame *out;
 +    int ret;
 +    AVFilterCommand *cmd= link->dst->command_queue;
 +    int64_t pts;
  
 -    FF_DPRINTF_START(NULL, filter_frame);
 -    ff_dlog_link(NULL, link, 1);
 +    if (link->closed) {
 +        av_frame_free(&frame);
 +        return AVERROR_EOF;
 +    }
  
      if (!(filter_frame = dst->filter_frame))
          filter_frame = default_filter_frame;
      if (dst->needs_writable && !av_frame_is_writable(frame)) {
          av_log(link->dst, AV_LOG_DEBUG, "Copying data in avfilter.\n");
  
 +        /* Maybe use ff_copy_buffer_ref instead? */
          switch (link->type) {
          case AVMEDIA_TYPE_VIDEO:
              out = ff_get_video_buffer(link, link->w, link->h);
  
          switch (link->type) {
          case AVMEDIA_TYPE_VIDEO:
 -            av_image_copy(out->data, out->linesize, frame->data, frame->linesize,
 +            av_image_copy(out->data, out->linesize, (const uint8_t **)frame->data, frame->linesize,
                            frame->format, frame->width, frame->height);
              break;
          case AVMEDIA_TYPE_AUDIO:
      } else
          out = frame;
  
 -    return filter_frame(link, out);
 +    while(cmd && cmd->time <= out->pts * av_q2d(link->time_base)){
 +        av_log(link->dst, AV_LOG_DEBUG,
 +               "Processing command time:%f command:%s arg:%s\n",
 +               cmd->time, cmd->command, cmd->arg);
 +        avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
 +        ff_command_queue_pop(link->dst);
 +        cmd= link->dst->command_queue;
 +    }
 +
 +    pts = out->pts;
 +    if (dstctx->enable_str) {
 +        int64_t pos = av_frame_get_pkt_pos(out);
 +        dstctx->var_values[VAR_N] = link->frame_count;
 +        dstctx->var_values[VAR_T] = pts == AV_NOPTS_VALUE ? NAN : pts * av_q2d(link->time_base);
 +        dstctx->var_values[VAR_POS] = pos == -1 ? NAN : pos;
 +
 +        dstctx->is_disabled = !av_expr_eval(dstctx->enable, dstctx->var_values, NULL);
 +        if (dstctx->is_disabled &&
 +            (dstctx->filter->flags & AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC))
 +            filter_frame = default_filter_frame;
 +    }
 +    ret = filter_frame(link, out);
 +    link->frame_count++;
 +    link->frame_requested = 0;
 +    ff_update_link_current_pts(link, pts);
 +    return ret;
 +}
 +
 +static int ff_filter_frame_needs_framing(AVFilterLink *link, AVFrame *frame)
 +{
 +    int insamples = frame->nb_samples, inpos = 0, nb_samples;
 +    AVFrame *pbuf = link->partial_buf;
 +    int nb_channels = av_frame_get_channels(frame);
 +    int ret = 0;
 +
 +    link->flags |= FF_LINK_FLAG_REQUEST_LOOP;
 +    /* Handle framing (min_samples, max_samples) */
 +    while (insamples) {
 +        if (!pbuf) {
 +            AVRational samples_tb = { 1, link->sample_rate };
 +            pbuf = ff_get_audio_buffer(link, link->partial_buf_size);
 +            if (!pbuf) {
 +                av_log(link->dst, AV_LOG_WARNING,
 +                       "Samples dropped due to memory allocation failure.\n");
 +                return 0;
 +            }
 +            av_frame_copy_props(pbuf, frame);
 +            pbuf->pts = frame->pts +
 +                        av_rescale_q(inpos, samples_tb, link->time_base);
 +            pbuf->nb_samples = 0;
 +        }
 +        nb_samples = FFMIN(insamples,
 +                           link->partial_buf_size - pbuf->nb_samples);
 +        av_samples_copy(pbuf->extended_data, frame->extended_data,
 +                        pbuf->nb_samples, inpos,
 +                        nb_samples, nb_channels, link->format);
 +        inpos                   += nb_samples;
 +        insamples               -= nb_samples;
 +        pbuf->nb_samples += nb_samples;
 +        if (pbuf->nb_samples >= link->min_samples) {
 +            ret = ff_filter_frame_framed(link, pbuf);
 +            pbuf = NULL;
 +        }
 +    }
 +    av_frame_free(&frame);
 +    link->partial_buf = pbuf;
 +    return ret;
 +}
 +
 +int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
 +{
 +    FF_TPRINTF_START(NULL, filter_frame); ff_tlog_link(NULL, link, 1); ff_tlog(NULL, " "); ff_tlog_ref(NULL, frame, 1);
 +
 +    /* Consistency checks */
 +    if (link->type == AVMEDIA_TYPE_VIDEO) {
 +        if (strcmp(link->dst->filter->name, "scale")) {
 +            av_assert1(frame->format                 == link->format);
 +            av_assert1(frame->width               == link->w);
 +            av_assert1(frame->height               == link->h);
 +        }
 +    } else {
 +        av_assert1(frame->format                == link->format);
 +        av_assert1(av_frame_get_channels(frame) == link->channels);
 +        av_assert1(frame->channel_layout        == link->channel_layout);
 +        av_assert1(frame->sample_rate           == link->sample_rate);
 +    }
 +
 +    /* Go directly to actual filtering if possible */
 +    if (link->type == AVMEDIA_TYPE_AUDIO &&
 +        link->min_samples &&
 +        (link->partial_buf ||
 +         frame->nb_samples < link->min_samples ||
 +         frame->nb_samples > link->max_samples)) {
 +        return ff_filter_frame_needs_framing(link, frame);
 +    } else {
 +        return ff_filter_frame_framed(link, frame);
 +    }
  }
  
  const AVClass *avfilter_get_class(void)
diff --combined libavfilter/avfilter.h
@@@ -2,20 -2,20 +2,20 @@@
   * filter layer
   * Copyright (c) 2007 Bobby Bingham
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   * @{
   */
  
 +#include <stddef.h>
 +
  #include "libavutil/avutil.h"
 +#include "libavutil/dict.h"
  #include "libavutil/frame.h"
  #include "libavutil/log.h"
  #include "libavutil/samplefmt.h"
  #include "libavutil/pixfmt.h"
  #include "libavutil/rational.h"
 -#include "libavcodec/avcodec.h"
 -
 -#include <stddef.h>
  
  #include "libavfilter/version.h"
  
@@@ -60,6 -60,7 +60,6 @@@ const char *avfilter_configuration(void
   */
  const char *avfilter_license(void);
  
 -
  typedef struct AVFilterContext AVFilterContext;
  typedef struct AVFilterLink    AVFilterLink;
  typedef struct AVFilterPad     AVFilterPad;
@@@ -112,9 -113,6 +112,9 @@@ typedef struct AVFilterBuffer 
  #define AV_PERM_REUSE    0x08   ///< can output the buffer multiple times, with the same contents each time
  #define AV_PERM_REUSE2   0x10   ///< can output the buffer multiple times, modified each time
  #define AV_PERM_NEG_LINESIZES 0x20  ///< the buffer requested can have negative linesizes
 +#define AV_PERM_ALIGN    0x40   ///< the buffer must be aligned
 +
 +#define AVFILTER_ALIGN 16 //not part of ABI
  
  /**
   * Audio specific properties in a reference to an AVFilterBuffer. Since
   */
  typedef struct AVFilterBufferRefAudioProps {
      uint64_t channel_layout;    ///< channel layout of audio buffer
 -    int nb_samples;             ///< number of audio samples
 +    int nb_samples;             ///< number of audio samples per channel
      int sample_rate;            ///< audio buffer sample rate
 -    int planar;                 ///< audio buffer - planar or packed
 +    int channels;               ///< number of channels (do not access directly)
  } AVFilterBufferRefAudioProps;
  
  /**
  typedef struct AVFilterBufferRefVideoProps {
      int w;                      ///< image width
      int h;                      ///< image height
 -    AVRational pixel_aspect;    ///< pixel aspect ratio
 +    AVRational sample_aspect_ratio; ///< sample aspect ratio
      int interlaced;             ///< is frame interlaced
      int top_field_first;        ///< field order
      enum AVPictureType pict_type; ///< picture type of the frame
      int key_frame;              ///< 1 -> keyframe, 0-> not
 +    int qp_table_linesize;                ///< qp_table stride
 +    int qp_table_size;            ///< qp_table size
 +    int8_t *qp_table;             ///< array of Quantization Parameters
  } AVFilterBufferRefVideoProps;
  
  /**
@@@ -190,8 -185,6 +190,8 @@@ typedef struct AVFilterBufferRef 
      int perms;                  ///< permissions, see the AV_PERM_* flags
  
      enum AVMediaType type;      ///< media type of buffer data
 +
 +    AVDictionary *metadata;     ///< dictionary containing metadata key=value tags
  } AVFilterBufferRef;
  
  /**
@@@ -235,19 -228,11 +235,19 @@@ attribute_deprecate
  void avfilter_unref_bufferp(AVFilterBufferRef **ref);
  #endif
  
 +/**
 + * Get the number of channels of a buffer reference.
 + */
 +attribute_deprecated
 +int avfilter_ref_get_channels(AVFilterBufferRef *ref);
 +
  #if FF_API_AVFILTERPAD_PUBLIC
  /**
   * A filter pad used for either input or output.
   *
 - * @warning this struct will be removed from public API.
 + * See doc/filter_design.txt for details on how to implement the methods.
 + *
 + * @warning this struct might be removed from public API.
   * users should call avfilter_pad_get_name() and avfilter_pad_get_type()
   * to access the name and type fields; there should be no need to access
   * any other fields from outside of libavfilter.
@@@ -266,29 -251,22 +266,29 @@@ struct AVFilterPad 
      enum AVMediaType type;
  
      /**
 +     * Input pads:
       * Minimum required permissions on incoming buffers. Any buffer with
       * insufficient permissions will be automatically copied by the filter
       * system to a new buffer which provides the needed access permissions.
       *
 -     * Input pads only.
 +     * Output pads:
 +     * Guaranteed permissions on outgoing buffers. Any buffer pushed on the
 +     * link must have at least these permissions; this fact is checked by
 +     * asserts. It can be used to optimize buffer allocation.
       */
      attribute_deprecated int min_perms;
  
      /**
 +     * Input pads:
       * Permissions which are not accepted on incoming buffers. Any buffer
       * which has any of these permissions set will be automatically copied
       * by the filter system to a new buffer which does not have those
       * permissions. This can be used to easily disallow buffers with
       * AV_PERM_REUSE.
       *
 -     * Input pads only.
 +     * Output pads:
 +     * Permissions which are automatically removed on outgoing buffers. It
 +     * can be used to optimize buffer allocation.
       */
      attribute_deprecated int rej_perms;
  
  
      /**
       * Callback function to get a video buffer. If NULL, the filter system will
 -     * use avfilter_default_get_video_buffer().
 +     * use ff_default_get_video_buffer().
       *
       * Input video pads only.
       */
  
      /**
       * Callback function to get an audio buffer. If NULL, the filter system will
 -     * use avfilter_default_get_audio_buffer().
 +     * use ff_default_get_audio_buffer().
       *
       * Input audio pads only.
       */
       * Input pads only.
       *
       * @return >= 0 on success, a negative AVERROR on error. This function
 -     * must ensure that samplesref is properly unreferenced on error if it
 +     * must ensure that frame is properly unreferenced on error if it
       * hasn't been passed on to another filter.
       */
      int (*filter_frame)(AVFilterLink *link, AVFrame *frame);
       * Frame request callback. A call to this should result in at least one
       * frame being output over the given link. This should return zero on
       * success, and another value on error.
 +     * See ff_request_frame() for the error codes with a specific
 +     * meaning.
       *
       * Output pads only.
       */
      /**
       * Link configuration callback.
       *
 -     * For output pads, this should set the link properties such as
 -     * width/height. This should NOT set the format property - that is
 -     * negotiated between filters by the filter system using the
 +     * For output pads, this should set the following link properties:
 +     * video: width, height, sample_aspect_ratio, time_base
 +     * audio: sample_rate.
 +     *
 +     * This should NOT set properties such as format, channel_layout, etc which
 +     * are negotiated between filters by the filter system using the
       * query_formats() callback before this function is called.
       *
       * For input pads, this should check the properties of the link, and update
       * the filter's internal state as necessary.
       *
 -     * For both input and output filters, this should return zero on success,
 +     * For both input and output pads, this should return zero on success,
       * and another value on error.
       */
      int (*config_props)(AVFilterLink *link);
@@@ -429,27 -402,10 +429,32 @@@ enum AVMediaType avfilter_pad_get_type(
   */
  #define AVFILTER_FLAG_DYNAMIC_OUTPUTS       (1 << 1)
  /**
+  * The filter supports multithreading by splitting frames into multiple parts
+  * and processing them concurrently.
+  */
+ #define AVFILTER_FLAG_SLICE_THREADS         (1 << 2)
++/**
 + * Some filters support a generic "enable" expression option that can be used
 + * to enable or disable a filter in the timeline. Filters supporting this
 + * option have this flag set. When the enable expression is false, the default
 + * no-op filter_frame() function is called in place of the filter_frame()
 + * callback defined on each input pad, thus the frame is passed unchanged to
 + * the next filters.
 + */
 +#define AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC  (1 << 16)
 +/**
 + * Same as AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC, except that the filter will
 + * have its filter_frame() callback(s) called as usual even when the enable
 + * expression is false. The filter will disable filtering within the
 + * filter_frame() callback(s) itself, for example executing code depending on
 + * the AVFilterContext->is_disabled value.
 + */
 +#define AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL (1 << 17)
 +/**
 + * Handy mask to test whether the filter supports or no the timeline feature
 + * (internally or generically).
 + */
 +#define AVFILTER_FLAG_SUPPORT_TIMELINE (AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SUPPORT_TIMELINE_INTERNAL)
  
  /**
   * Filter definition. This defines the pads a filter contains, and all the
@@@ -507,9 -463,9 +512,9 @@@ typedef struct AVFilter 
      void (*uninit)(AVFilterContext *ctx);
  
      /**
 -     * Queries formats supported by the filter and its pads, and sets the
 -     * in_formats for links connected to its output pads, and out_formats
 -     * for links connected to its input pads.
 +     * Queries formats/layouts supported by the filter and its pads, and sets
 +     * the in_formats/in_chlayouts for links connected to its output pads,
 +     * and out_formats/out_chlayouts for links connected to its input pads.
       *
       * @return zero on success, a negative value corresponding to an
       * AVERROR code otherwise
      int priv_size;      ///< size of private data to allocate for the filter
  
      struct AVFilter *next;
 +
 +    /**
 +     * Make the filter instance process a command.
 +     *
 +     * @param cmd    the command to process, for handling simplicity all commands must be alphanumeric only
 +     * @param arg    the argument for the command
 +     * @param res    a buffer with size res_size where the filter(s) can return a response. This must not change when the command is not supported.
 +     * @param flags  if AVFILTER_CMD_FLAG_FAST is set and the command would be
 +     *               time consuming then a filter should treat it like an unsupported command
 +     *
 +     * @returns >=0 on success otherwise an error code.
 +     *          AVERROR(ENOSYS) on unsupported commands
 +     */
 +    int (*process_command)(AVFilterContext *, const char *cmd, const char *arg, char *res, int res_len, int flags);
 +
 +    /**
 +     * Filter initialization function, alternative to the init()
 +     * callback. Args contains the user-supplied parameters, opaque is
 +     * used for providing binary data.
 +     */
 +    int (*init_opaque)(AVFilterContext *ctx, void *opaque);
  } AVFilter;
  
+ /**
+  * Process multiple parts of the frame concurrently.
+  */
+ #define AVFILTER_THREAD_SLICE (1 << 0)
+ typedef struct AVFilterInternal AVFilterInternal;
  /** An instance of a filter */
  struct AVFilterContext {
 -    const AVClass *av_class;              ///< needed for av_log()
 +    const AVClass *av_class;        ///< needed for av_log() and filters common options
  
      const AVFilter *filter;         ///< the AVFilter of which this is an instance
  
  
      struct AVFilterGraph *graph;    ///< filtergraph this filter belongs to
  
+     /**
+      * Type of multithreading being allowed/used. A combination of
+      * AVFILTER_THREAD_* flags.
+      *
+      * May be set by the caller before initializing the filter to forbid some
+      * or all kinds of multithreading for this filter. The default is allowing
+      * everything.
+      *
+      * When the filter is initialized, this field is combined using bit AND with
+      * AVFilterGraph.thread_type to get the final mask used for determining
+      * allowed threading types. I.e. a threading type needs to be set in both
+      * to be allowed.
+      *
+      * After the filter is initialzed, libavfilter sets this field to the
+      * threading type that is actually used (0 for no multithreading).
+      */
+     int thread_type;
+     /**
+      * An opaque struct for libavfilter internal use.
+      */
+     AVFilterInternal *internal;
++
 +    struct AVFilterCommand *command_queue;
 +
 +    char *enable_str;               ///< enable expression string
 +    void *enable;                   ///< parsed expression (AVExpr*)
 +    double *var_values;             ///< variable values for the enable expression
 +    int is_disabled;                ///< the enabled state from the last expression evaluation
  };
  
  /**
@@@ -596,7 -554,7 +631,7 @@@ struct AVFilterLink 
      int w;                      ///< agreed upon image width
      int h;                      ///< agreed upon image height
      AVRational sample_aspect_ratio; ///< agreed upon sample aspect ratio
 -    /* These two parameters apply only to audio */
 +    /* These parameters apply only to audio */
      uint64_t channel_layout;    ///< channel layout of current buffer (see libavutil/channel_layout.h)
      int sample_rate;            ///< samples per second
  
       *****************************************************************
       */
      /**
 -     * Lists of formats supported by the input and output filters respectively.
 -     * These lists are used for negotiating the format to actually be used,
 -     * which will be loaded into the format member, above, when chosen.
 +     * Lists of formats and channel layouts supported by the input and output
 +     * filters respectively. These lists are used for negotiating the format
 +     * to actually be used, which will be loaded into the format and
 +     * channel_layout members, above, when chosen.
 +     *
       */
      AVFilterFormats *in_formats;
      AVFilterFormats *out_formats;
          AVLINK_STARTINIT,       ///< started, but incomplete
          AVLINK_INIT             ///< complete
      } init_state;
 +
 +    struct AVFilterPool *pool;
 +
 +    /**
 +     * Graph the filter belongs to.
 +     */
 +    struct AVFilterGraph *graph;
 +
 +    /**
 +     * Current timestamp of the link, as defined by the most recent
 +     * frame(s), in AV_TIME_BASE units.
 +     */
 +    int64_t current_pts;
 +
 +    /**
 +     * Index in the age array.
 +     */
 +    int age_index;
 +
 +    /**
 +     * Frame rate of the stream on the link, or 1/0 if unknown;
 +     * if left to 0/0, will be automatically be copied from the first input
 +     * of the source filter if it exists.
 +     *
 +     * Sources should set it to the best estimation of the real frame rate.
 +     * Filters should update it if necessary depending on their function.
 +     * Sinks can use it to set a default output frame rate.
 +     * It is similar to the r_frame_rate field in AVStream.
 +     */
 +    AVRational frame_rate;
 +
 +    /**
 +     * Buffer partially filled with samples to achieve a fixed/minimum size.
 +     */
 +    AVFrame *partial_buf;
 +
 +    /**
 +     * Size of the partial buffer to allocate.
 +     * Must be between min_samples and max_samples.
 +     */
 +    int partial_buf_size;
 +
 +    /**
 +     * Minimum number of samples to filter at once. If filter_frame() is
 +     * called with fewer samples, it will accumulate them in partial_buf.
 +     * This field and the related ones must not be changed after filtering
 +     * has started.
 +     * If 0, all related fields are ignored.
 +     */
 +    int min_samples;
 +
 +    /**
 +     * Maximum number of samples to filter at once. If filter_frame() is
 +     * called with more samples, it will split them.
 +     */
 +    int max_samples;
 +
 +    /**
 +     * The buffer reference currently being received across the link by the
 +     * destination filter. This is used internally by the filter system to
 +     * allow automatic copying of buffers which do not have sufficient
 +     * permissions for the destination. This should not be accessed directly
 +     * by the filters.
 +     */
 +    AVFilterBufferRef *cur_buf_copy;
 +
 +    /**
 +     * True if the link is closed.
 +     * If set, all attemps of start_frame, filter_frame or request_frame
 +     * will fail with AVERROR_EOF, and if necessary the reference will be
 +     * destroyed.
 +     * If request_frame returns AVERROR_EOF, this flag is set on the
 +     * corresponding link.
 +     * It can be set also be set by either the source or the destination
 +     * filter.
 +     */
 +    int closed;
 +
 +    /**
 +     * Number of channels.
 +     */
 +    int channels;
 +
 +    /**
 +     * True if a frame is being requested on the link.
 +     * Used internally by the framework.
 +     */
 +    unsigned frame_requested;
 +
 +    /**
 +     * Link processing flags.
 +     */
 +    unsigned flags;
 +
 +    /**
 +     * Number of past frames sent through the link.
 +     */
 +    int64_t frame_count;
  };
  
  /**
@@@ -765,21 -623,6 +800,21 @@@ int avfilter_link(AVFilterContext *src
                    AVFilterContext *dst, unsigned dstpad);
  
  /**
 + * Free the link in *link, and set its pointer to NULL.
 + */
 +void avfilter_link_free(AVFilterLink **link);
 +
 +/**
 + * Get the number of channels of a link.
 + */
 +int avfilter_link_get_channels(AVFilterLink *link);
 +
 +/**
 + * Set the closed field of a link.
 + */
 +void avfilter_link_set_closed(AVFilterLink *link, int closed);
 +
 +/**
   * Negotiate the media format, dimensions, etc of all inputs to a filter.
   *
   * @param filter the filter to negotiate the properties for its inputs
@@@ -801,16 -644,13 +836,16 @@@ int avfilter_config_links(AVFilterConte
   */
  attribute_deprecated
  AVFilterBufferRef *
 -avfilter_get_video_buffer_ref_from_arrays(uint8_t *data[4], int linesize[4], int perms,
 +avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms,
                                            int w, int h, enum AVPixelFormat format);
  
  /**
   * Create an audio buffer reference wrapped around an already
   * allocated samples buffer.
   *
 + * See avfilter_get_audio_buffer_ref_from_arrays_channels() for a version
 + * that can handle unknown channel layouts.
 + *
   * @param data           pointers to the samples plane buffers
   * @param linesize       linesize for the samples plane buffers
   * @param perms          the required access permissions
@@@ -825,40 -665,8 +860,40 @@@ AVFilterBufferRef *avfilter_get_audio_b
                                                               int nb_samples,
                                                               enum AVSampleFormat sample_fmt,
                                                               uint64_t channel_layout);
 +/**
 + * Create an audio buffer reference wrapped around an already
 + * allocated samples buffer.
 + *
 + * @param data           pointers to the samples plane buffers
 + * @param linesize       linesize for the samples plane buffers
 + * @param perms          the required access permissions
 + * @param nb_samples     number of samples per channel
 + * @param sample_fmt     the format of each sample in the buffer to allocate
 + * @param channels       the number of channels of the buffer
 + * @param channel_layout the channel layout of the buffer,
 + *                       must be either 0 or consistent with channels
 + */
 +attribute_deprecated
 +AVFilterBufferRef *avfilter_get_audio_buffer_ref_from_arrays_channels(uint8_t **data,
 +                                                                      int linesize,
 +                                                                      int perms,
 +                                                                      int nb_samples,
 +                                                                      enum AVSampleFormat sample_fmt,
 +                                                                      int channels,
 +                                                                      uint64_t channel_layout);
 +
  #endif
  
 +
 +#define AVFILTER_CMD_FLAG_ONE   1 ///< Stop once a filter understood the command (for target=all for example), fast filters are favored automatically
 +#define AVFILTER_CMD_FLAG_FAST  2 ///< Only execute command when its fast (like a video out that supports contrast adjustment in hw)
 +
 +/**
 + * Make the filter instance process a command.
 + * It is recommended to use avfilter_graph_send_command().
 + */
 +int avfilter_process_command(AVFilterContext *filter, const char *cmd, const char *arg, char *res, int res_len, int flags);
 +
  /** Initialize the filter system. Register all builtin filters. */
  void avfilter_register_all(void);
  
@@@ -875,7 -683,7 +910,7 @@@ void avfilter_uninit(void)
   * is not registered.
   *
   * @param filter the filter to register
 - * @return 0 if the registration was succesfull, a negative value
 + * @return 0 if the registration was successful, a negative value
   * otherwise
   */
  int avfilter_register(AVFilter *filter);
@@@ -1020,11 -828,13 +1055,13 @@@ int avfilter_copy_buf_props(AVFrame *ds
   */
  const AVClass *avfilter_get_class(void);
  
+ typedef struct AVFilterGraphInternal AVFilterGraphInternal;
  typedef struct AVFilterGraph {
      const AVClass *av_class;
  #if FF_API_FOO_COUNT
      attribute_deprecated
 -    unsigned filter_count;
 +    unsigned filter_count_unused;
  #endif
      AVFilterContext **filters;
  #if !FF_API_FOO_COUNT
  #if FF_API_FOO_COUNT
      unsigned nb_filters;
  #endif
+     /**
+      * Type of multithreading allowed for filters in this graph. A combination
+      * of AVFILTER_THREAD_* flags.
+      *
+      * May be set by the caller at any point, the setting will apply to all
+      * filters initialized after that. The default is allowing everything.
+      *
+      * When a filter in this graph is initialized, this field is combined using
+      * bit AND with AVFilterContext.thread_type to get the final mask used for
+      * determining allowed threading types. I.e. a threading type needs to be
+      * set in both to be allowed.
+      */
+     int thread_type;
+     /**
+      * Maximum number of threads used by filters in this graph. May be set by
+      * the caller before adding any filters to the filtergraph. Zero (the
+      * default) means that the number of threads is determined automatically.
+      */
+     int nb_threads;
+     /**
+      * Opaque object for libavfilter internal use.
+      */
+     AVFilterGraphInternal *internal;
++
 +    char *aresample_swr_opts; ///< swr options to use for the auto-inserted aresample filters, Access ONLY through AVOptions
 +
 +    /**
 +     * Private fields
 +     *
 +     * The following fields are for internal use only.
 +     * Their type, offset, number and semantic can change without notice.
 +     */
 +
 +    AVFilterLink **sink_links;
 +    int sink_links_count;
 +
 +    unsigned disable_auto_convert;
  } AVFilterGraph;
  
  /**
@@@ -1114,21 -937,6 +1178,21 @@@ int avfilter_graph_create_filter(AVFilt
                                   AVFilterGraph *graph_ctx);
  
  /**
 + * Enable or disable automatic format conversion inside the graph.
 + *
 + * Note that format conversion can still happen inside explicitly inserted
 + * scale and aresample filters.
 + *
 + * @param flags  any of the AVFILTER_AUTO_CONVERT_* constants
 + */
 +void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags);
 +
 +enum {
 +    AVFILTER_AUTO_CONVERT_ALL  =  0, /**< all automatic conversions enabled */
 +    AVFILTER_AUTO_CONVERT_NONE = -1, /**< all automatic conversions disabled */
 +};
 +
 +/**
   * Check validity and configure all the links and formats in the graph.
   *
   * @param graphctx the filter graph
@@@ -1184,16 -992,12 +1248,16 @@@ void avfilter_inout_free(AVFilterInOut 
   *
   * @param graph   the filter graph where to link the parsed graph context
   * @param filters string to be parsed
 - * @param inputs  linked list to the inputs of the graph
 - * @param outputs linked list to the outputs of the graph
 - * @return zero on success, a negative AVERROR code on error
 + * @param inputs  pointer to a linked list to the inputs of the graph, may be NULL.
 + *                If non-NULL, *inputs is updated to contain the list of open inputs
 + *                after the parsing, should be freed with avfilter_inout_free().
 + * @param outputs pointer to a linked list to the outputs of the graph, may be NULL.
 + *                If non-NULL, *outputs is updated to contain the list of open outputs
 + *                after the parsing, should be freed with avfilter_inout_free().
 + * @return non negative on success, a negative AVERROR code on error
   */
  int avfilter_graph_parse(AVFilterGraph *graph, const char *filters,
 -                         AVFilterInOut *inputs, AVFilterInOut *outputs,
 +                         AVFilterInOut **inputs, AVFilterInOut **outputs,
                           void *log_ctx);
  
  /**
@@@ -1231,71 -1035,6 +1295,71 @@@ int avfilter_graph_parse2(AVFilterGrap
                            AVFilterInOut **outputs);
  
  /**
 + * Send a command to one or more filter instances.
 + *
 + * @param graph  the filter graph
 + * @param target the filter(s) to which the command should be sent
 + *               "all" sends to all filters
 + *               otherwise it can be a filter or filter instance name
 + *               which will send the command to all matching filters.
 + * @param cmd    the command to send, for handling simplicity all commands must be alphanumeric only
 + * @param arg    the argument for the command
 + * @param res    a buffer with size res_size where the filter(s) can return a response.
 + *
 + * @returns >=0 on success otherwise an error code.
 + *              AVERROR(ENOSYS) on unsupported commands
 + */
 +int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags);
 +
 +/**
 + * Queue a command for one or more filter instances.
 + *
 + * @param graph  the filter graph
 + * @param target the filter(s) to which the command should be sent
 + *               "all" sends to all filters
 + *               otherwise it can be a filter or filter instance name
 + *               which will send the command to all matching filters.
 + * @param cmd    the command to sent, for handling simplicity all commands must be alphanummeric only
 + * @param arg    the argument for the command
 + * @param ts     time at which the command should be sent to the filter
 + *
 + * @note As this executes commands after this function returns, no return code
 + *       from the filter is provided, also AVFILTER_CMD_FLAG_ONE is not supported.
 + */
 +int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts);
 +
 +
 +/**
 + * Dump a graph into a human-readable string representation.
 + *
 + * @param graph    the graph to dump
 + * @param options  formatting options; currently ignored
 + * @return  a string, or NULL in case of memory allocation failure;
 + *          the string must be freed using av_free
 + */
 +char *avfilter_graph_dump(AVFilterGraph *graph, const char *options);
 +
 +/**
 + * Request a frame on the oldest sink link.
 + *
 + * If the request returns AVERROR_EOF, try the next.
 + *
 + * Note that this function is not meant to be the sole scheduling mechanism
 + * of a filtergraph, only a convenience function to help drain a filtergraph
 + * in a balanced way under normal circumstances.
 + *
 + * Also note that AVERROR_EOF does not mean that frames did not arrive on
 + * some of the sinks during the process.
 + * When there are multiple sink links, in case the requested link
 + * returns an EOF, this may cause a filter to flush pending frames
 + * which are sent to another sink link, although unrequested.
 + *
 + * @return  the return value of ff_request_frame(),
 + *          or AVERROR_EOF if all links returned AVERROR_EOF
 + */
 +int avfilter_graph_request_oldest(AVFilterGraph *graph);
 +
 +/**
   * @}
   */
  
@@@ -3,59 -3,85 +3,91 @@@
   * Copyright (c) 2008 Vitor Sessak
   * Copyright (c) 2007 Bobby Bingham
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
+ #include "config.h"
  #include <string.h>
  
  #include "libavutil/avassert.h"
  #include "libavutil/avstring.h"
 +#include "libavutil/bprint.h"
  #include "libavutil/channel_layout.h"
 -#include "libavutil/common.h"
 -#include "libavutil/log.h"
  #include "libavutil/opt.h"
 +#include "libavutil/pixdesc.h"
 +#include "libavcodec/avcodec.h" // avcodec_find_best_pix_fmt_of_2()
  #include "avfilter.h"
  #include "formats.h"
  #include "internal.h"
- #define OFFSET(x) offsetof(AVFilterGraph,x)
- static const AVOption options[]={
- {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 },
- {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,  AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, 0 },
- {0}
+ #include "thread.h"
+ #define OFFSET(x) offsetof(AVFilterGraph, x)
 -#define FLAGS AV_OPT_FLAG_VIDEO_PARAM
++#define FLAGS AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_FILTERING_PARAM
+ static const AVOption filtergraph_options[] = {
+     { "thread_type", "Allowed thread types", OFFSET(thread_type), AV_OPT_TYPE_FLAGS,
+         { .i64 = AVFILTER_THREAD_SLICE }, 0, INT_MAX, FLAGS, "thread_type" },
+         { "slice", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AVFILTER_THREAD_SLICE }, .flags = FLAGS, .unit = "thread_type" },
+     { "threads",     "Maximum number of threads", OFFSET(nb_threads),
+         AV_OPT_TYPE_INT,   { .i64 = 0 }, 0, INT_MAX, FLAGS },
++    {"scale_sws_opts"       , "default scale filter options"        , OFFSET(scale_sws_opts)        ,
++        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
++    {"aresample_swr_opts"   , "default aresample filter options"    , OFFSET(aresample_swr_opts)    ,
++        AV_OPT_TYPE_STRING, {.str = NULL}, 0, 0, FLAGS },
+     { NULL },
  };
  
  static const AVClass filtergraph_class = {
      .class_name = "AVFilterGraph",
      .item_name  = av_default_item_name,
-     .option     = options,
      .version    = LIBAVUTIL_VERSION_INT,
+     .option     = filtergraph_options,
 +    .category   = AV_CLASS_CATEGORY_FILTER,
  };
  
+ #if !HAVE_THREADS
+ void ff_graph_thread_free(AVFilterGraph *graph)
+ {
+ }
+ int ff_graph_thread_init(AVFilterGraph *graph)
+ {
+     graph->thread_type = 0;
+     graph->nb_threads  = 1;
+     return 0;
+ }
+ #endif
  AVFilterGraph *avfilter_graph_alloc(void)
  {
      AVFilterGraph *ret = av_mallocz(sizeof(*ret));
      if (!ret)
          return NULL;
+     ret->internal = av_mallocz(sizeof(*ret->internal));
+     if (!ret->internal) {
+         av_freep(&ret);
+         return NULL;
+     }
      ret->av_class = &filtergraph_class;
+     av_opt_set_defaults(ret);
      return ret;
  }
  
@@@ -80,11 -106,12 +112,15 @@@ void avfilter_graph_free(AVFilterGraph 
      while ((*graph)->nb_filters)
          avfilter_free((*graph)->filters[0]);
  
+     ff_graph_thread_free(*graph);
 +    av_freep(&(*graph)->sink_links);
++
      av_freep(&(*graph)->scale_sws_opts);
 +    av_freep(&(*graph)->aresample_swr_opts);
      av_freep(&(*graph)->resample_lavr_opts);
      av_freep(&(*graph)->filters);
+     av_freep(&(*graph)->internal);
      av_freep(graph);
  }
  
@@@ -100,7 -127,7 +136,7 @@@ int avfilter_graph_add_filter(AVFilterG
      graph->filters[graph->nb_filters++] = filter;
  
  #if FF_API_FOO_COUNT
 -    graph->filter_count = graph->nb_filters;
 +    graph->filter_count_unused = graph->nb_filters;
  #endif
  
      filter->graph = graph;
@@@ -132,17 -159,20 +168,25 @@@ fail
      return ret;
  }
  
 +void avfilter_graph_set_auto_convert(AVFilterGraph *graph, unsigned flags)
 +{
 +    graph->disable_auto_convert = flags;
 +}
 +
  AVFilterContext *avfilter_graph_alloc_filter(AVFilterGraph *graph,
                                               const AVFilter *filter,
                                               const char *name)
  {
      AVFilterContext **filters, *s;
  
+     if (graph->thread_type && !graph->internal->thread) {
+         int ret = ff_graph_thread_init(graph);
+         if (ret < 0) {
+             av_log(graph, AV_LOG_ERROR, "Error initializing threading.\n");
+             return NULL;
+         }
+     }
      s = ff_filter_alloc(filter, name);
      if (!s)
          return NULL;
      graph->filters[graph->nb_filters++] = s;
  
  #if FF_API_FOO_COUNT
 -    graph->filter_count = graph->nb_filters;
 +    graph->filter_count_unused = graph->nb_filters;
  #endif
  
      s->graph = graph;
@@@ -179,25 -209,22 +223,25 @@@ static int graph_check_validity(AVFilte
      int i, j;
  
      for (i = 0; i < graph->nb_filters; i++) {
 +        const AVFilterPad *pad;
          filt = graph->filters[i];
  
          for (j = 0; j < filt->nb_inputs; j++) {
              if (!filt->inputs[j] || !filt->inputs[j]->src) {
 +                pad = &filt->input_pads[j];
                  av_log(log_ctx, AV_LOG_ERROR,
 -                       "Input pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any source\n",
 -                       filt->input_pads[j].name, filt->name, filt->filter->name);
 +                       "Input pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any source\n",
 +                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
                  return AVERROR(EINVAL);
              }
          }
  
          for (j = 0; j < filt->nb_outputs; j++) {
              if (!filt->outputs[j] || !filt->outputs[j]->dst) {
 +                pad = &filt->output_pads[j];
                  av_log(log_ctx, AV_LOG_ERROR,
 -                       "Output pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any destination\n",
 -                       filt->output_pads[j].name, filt->name, filt->filter->name);
 +                       "Output pad \"%s\" with type %s of the filter instance \"%s\" of %s not connected to any destination\n",
 +                       pad->name, av_get_media_type_string(pad->type), filt->name, filt->filter->name);
                  return AVERROR(EINVAL);
              }
          }
@@@ -239,114 -266,17 +283,114 @@@ AVFilterContext *avfilter_graph_get_fil
      return NULL;
  }
  
 +static void sanitize_channel_layouts(void *log, AVFilterChannelLayouts *l)
 +{
 +    if (!l)
 +        return;
 +    if (l->nb_channel_layouts) {
 +        if (l->all_layouts || l->all_counts)
 +            av_log(log, AV_LOG_WARNING, "All layouts set on non-empty list\n");
 +        l->all_layouts = l->all_counts = 0;
 +    } else {
 +        if (l->all_counts && !l->all_layouts)
 +            av_log(log, AV_LOG_WARNING, "All counts without all layouts\n");
 +        l->all_layouts = 1;
 +    }
 +}
 +
 +static int filter_query_formats(AVFilterContext *ctx)
 +{
 +    int ret, i;
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *chlayouts;
 +    AVFilterFormats *samplerates;
 +    enum AVMediaType type = ctx->inputs  && ctx->inputs [0] ? ctx->inputs [0]->type :
 +                            ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
 +                            AVMEDIA_TYPE_VIDEO;
 +
 +    if ((ret = ctx->filter->query_formats(ctx)) < 0) {
 +        if (ret != AVERROR(EAGAIN))
 +            av_log(ctx, AV_LOG_ERROR, "Query format failed for '%s': %s\n",
 +                   ctx->name, av_err2str(ret));
 +        return ret;
 +    }
 +
 +    for (i = 0; i < ctx->nb_inputs; i++)
 +        sanitize_channel_layouts(ctx, ctx->inputs[i]->out_channel_layouts);
 +    for (i = 0; i < ctx->nb_outputs; i++)
 +        sanitize_channel_layouts(ctx, ctx->outputs[i]->in_channel_layouts);
 +
 +    formats = ff_all_formats(type);
 +    if (!formats)
 +        return AVERROR(ENOMEM);
 +    ff_set_common_formats(ctx, formats);
 +    if (type == AVMEDIA_TYPE_AUDIO) {
 +        samplerates = ff_all_samplerates();
 +        if (!samplerates)
 +            return AVERROR(ENOMEM);
 +        ff_set_common_samplerates(ctx, samplerates);
 +        chlayouts = ff_all_channel_layouts();
 +        if (!chlayouts)
 +            return AVERROR(ENOMEM);
 +        ff_set_common_channel_layouts(ctx, chlayouts);
 +    }
 +    return 0;
 +}
 +
 +static int formats_declared(AVFilterContext *f)
 +{
 +    int i;
 +
 +    for (i = 0; i < f->nb_inputs; i++) {
 +        if (!f->inputs[i]->out_formats)
 +            return 0;
 +        if (f->inputs[i]->type == AVMEDIA_TYPE_AUDIO &&
 +            !(f->inputs[i]->out_samplerates &&
 +              f->inputs[i]->out_channel_layouts))
 +            return 0;
 +    }
 +    for (i = 0; i < f->nb_outputs; i++) {
 +        if (!f->outputs[i]->in_formats)
 +            return 0;
 +        if (f->outputs[i]->type == AVMEDIA_TYPE_AUDIO &&
 +            !(f->outputs[i]->in_samplerates &&
 +              f->outputs[i]->in_channel_layouts))
 +            return 0;
 +    }
 +    return 1;
 +}
 +
 +/**
 + * Perform one round of query_formats() and merging formats lists on the
 + * filter graph.
 + * @return  >=0 if all links formats lists could be queried and merged;
 + *          AVERROR(EAGAIN) some progress was made in the queries or merging
 + *          and a later call may succeed;
 + *          AVERROR(EIO) (may be changed) plus a log message if no progress
 + *          was made and the negotiation is stuck;
 + *          a negative error code if some other error happened
 + */
  static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
  {
      int i, j, ret;
      int scaler_count = 0, resampler_count = 0;
 +    int count_queried = 0;        /* successful calls to query_formats() */
 +    int count_merged = 0;         /* successful merge of formats lists */
 +    int count_already_merged = 0; /* lists already merged */
 +    int count_delayed = 0;        /* lists that need to be merged later */
  
 -    /* ask all the sub-filters for their supported media formats */
      for (i = 0; i < graph->nb_filters; i++) {
 -        if (graph->filters[i]->filter->query_formats)
 -            graph->filters[i]->filter->query_formats(graph->filters[i]);
 +        AVFilterContext *f = graph->filters[i];
 +        if (formats_declared(f))
 +            continue;
 +        if (f->filter->query_formats)
 +            ret = filter_query_formats(f);
          else
 -            ff_default_query_formats(graph->filters[i]);
 +            ret = ff_default_query_formats(f);
 +        if (ret < 0 && ret != AVERROR(EAGAIN))
 +            return ret;
 +        /* note: EAGAIN could indicate a partial success, not counted yet */
 +        count_queried += ret >= 0;
      }
  
      /* go through and merge as many format lists as possible */
              if (!link)
                  continue;
  
 -            if (link->in_formats != link->out_formats &&
 -                !ff_merge_formats(link->in_formats,
 -                                        link->out_formats))
 -                convert_needed = 1;
 -            if (link->type == AVMEDIA_TYPE_AUDIO) {
 -                if (link->in_channel_layouts != link->out_channel_layouts &&
 -                    !ff_merge_channel_layouts(link->in_channel_layouts,
 -                                              link->out_channel_layouts))
 -                    convert_needed = 1;
 -                if (link->in_samplerates != link->out_samplerates &&
 -                    !ff_merge_samplerates(link->in_samplerates,
 -                                          link->out_samplerates))
 +#define MERGE_DISPATCH(field, statement)                                     \
 +            if (!(link->in_ ## field && link->out_ ## field)) {              \
 +                count_delayed++;                                             \
 +            } else if (link->in_ ## field == link->out_ ## field) {          \
 +                count_already_merged++;                                      \
 +            } else {                                                         \
 +                count_merged++;                                              \
 +                statement                                                    \
 +            }
 +            MERGE_DISPATCH(formats,
 +                if (!ff_merge_formats(link->in_formats, link->out_formats,
 +                                      link->type))
                      convert_needed = 1;
 +            )
 +            if (link->type == AVMEDIA_TYPE_AUDIO) {
 +                MERGE_DISPATCH(channel_layouts,
 +                    if (!ff_merge_channel_layouts(link->in_channel_layouts,
 +                                                  link->out_channel_layouts))
 +                        convert_needed = 1;
 +                )
 +                MERGE_DISPATCH(samplerates,
 +                    if (!ff_merge_samplerates(link->in_samplerates,
 +                                              link->out_samplerates))
 +                        convert_needed = 1;
 +                )
              }
 +#undef MERGE_DISPATCH
  
              if (convert_needed) {
                  AVFilterContext *convert;
                          return ret;
                      break;
                  case AVMEDIA_TYPE_AUDIO:
 -                    if (!(filter = avfilter_get_by_name("resample"))) {
 -                        av_log(log_ctx, AV_LOG_ERROR, "'resample' filter "
 +                    if (!(filter = avfilter_get_by_name("aresample"))) {
 +                        av_log(log_ctx, AV_LOG_ERROR, "'aresample' filter "
                                 "not present, cannot convert audio formats.\n");
                          return AVERROR(EINVAL);
                      }
                      snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",
                               resampler_count++);
                      scale_args[0] = '\0';
 -                    if (graph->resample_lavr_opts)
 +                    if (graph->aresample_swr_opts)
                          snprintf(scale_args, sizeof(scale_args), "%s",
 -                                 graph->resample_lavr_opts);
 +                                 graph->aresample_swr_opts);
                      if ((ret = avfilter_graph_create_filter(&convert, filter,
 -                                                            inst_name, scale_args,
 +                                                            inst_name, graph->aresample_swr_opts,
                                                              NULL, graph)) < 0)
                          return ret;
                      break;
                  if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
                      return ret;
  
 -                convert->filter->query_formats(convert);
 +                filter_query_formats(convert);
                  inlink  = convert->inputs[0];
                  outlink = convert->outputs[0];
 -                if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats) ||
 -                    !ff_merge_formats(outlink->in_formats, outlink->out_formats))
 +                if (!ff_merge_formats( inlink->in_formats,  inlink->out_formats,  inlink->type) ||
 +                    !ff_merge_formats(outlink->in_formats, outlink->out_formats, outlink->type))
                      ret |= AVERROR(ENOSYS);
                  if (inlink->type == AVMEDIA_TYPE_AUDIO &&
                      (!ff_merge_samplerates(inlink->in_samplerates,
          }
      }
  
 +    av_log(graph, AV_LOG_DEBUG, "query_formats: "
 +           "%d queried, %d merged, %d already done, %d delayed\n",
 +           count_queried, count_merged, count_already_merged, count_delayed);
 +    if (count_delayed) {
 +        AVBPrint bp;
 +
 +        /* if count_queried > 0, one filter at least did set its formats,
 +           that will give additional information to its neighbour;
 +           if count_merged > 0, one pair of formats lists at least was merged,
 +           that will give additional information to all connected filters;
 +           in both cases, progress was made and a new round must be done */
 +        if (count_queried || count_merged)
 +            return AVERROR(EAGAIN);
 +        av_bprint_init(&bp, 0, AV_BPRINT_SIZE_AUTOMATIC);
 +        for (i = 0; i < graph->nb_filters; i++)
 +            if (!formats_declared(graph->filters[i]))
 +                av_bprintf(&bp, "%s%s", bp.len ? ", " : "",
 +                          graph->filters[i]->name);
 +        av_log(graph, AV_LOG_ERROR,
 +               "The following filters could not choose their formats: %s\n"
 +               "Consider inserting the (a)format filter near their input or "
 +               "output.\n", bp.str);
 +        return AVERROR(EIO);
 +    }
      return 0;
  }
  
 -static int pick_format(AVFilterLink *link)
 +static int pick_format(AVFilterLink *link, AVFilterLink *ref)
  {
      if (!link || !link->in_formats)
          return 0;
  
 +    if (link->type == AVMEDIA_TYPE_VIDEO) {
 +        if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
 +            int has_alpha= av_pix_fmt_desc_get(ref->format)->nb_components % 2 == 0;
 +            enum AVPixelFormat best= AV_PIX_FMT_NONE;
 +            int i;
 +            for (i=0; i<link->in_formats->nb_formats; i++) {
 +                enum AVPixelFormat p = link->in_formats->formats[i];
 +                best= avcodec_find_best_pix_fmt_of_2(best, p, ref->format, has_alpha, NULL);
 +            }
 +            av_log(link->src,AV_LOG_DEBUG, "picking %s out of %d ref:%s alpha:%d\n",
 +                   av_get_pix_fmt_name(best), link->in_formats->nb_formats,
 +                   av_get_pix_fmt_name(ref->format), has_alpha);
 +            link->in_formats->formats[0] = best;
 +        }
 +    }
 +
      link->in_formats->nb_formats = 1;
      link->format = link->in_formats->formats[0];
  
          link->in_samplerates->nb_formats = 1;
          link->sample_rate = link->in_samplerates->formats[0];
  
 -        if (!link->in_channel_layouts->nb_channel_layouts) {
 +        if (link->in_channel_layouts->all_layouts) {
              av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
 -                   "the link between filters %s and %s.\n", link->src->name,
 +                   " the link between filters %s and %s.\n", link->src->name,
                     link->dst->name);
              return AVERROR(EINVAL);
          }
          link->in_channel_layouts->nb_channel_layouts = 1;
          link->channel_layout = link->in_channel_layouts->channel_layouts[0];
 +        if ((link->channels = FF_LAYOUT2COUNT(link->channel_layout)))
 +            link->channel_layout = 0;
 +        else
 +            link->channels = av_get_channel_layout_nb_channels(link->channel_layout);
      }
  
      ff_formats_unref(&link->in_formats);
@@@ -594,42 -467,8 +638,42 @@@ static int reduce_formats_on_filter(AVF
                     nb_formats, ff_add_format);
      REDUCE_FORMATS(int,      AVFilterFormats,        samplerates,     formats,
                     nb_formats, ff_add_format);
 -    REDUCE_FORMATS(uint64_t, AVFilterChannelLayouts, channel_layouts,
 -                   channel_layouts, nb_channel_layouts, ff_add_channel_layout);
 +
 +    /* reduce channel layouts */
 +    for (i = 0; i < filter->nb_inputs; i++) {
 +        AVFilterLink *inlink = filter->inputs[i];
 +        uint64_t fmt;
 +
 +        if (!inlink->out_channel_layouts ||
 +            inlink->out_channel_layouts->nb_channel_layouts != 1)
 +            continue;
 +        fmt = inlink->out_channel_layouts->channel_layouts[0];
 +
 +        for (j = 0; j < filter->nb_outputs; j++) {
 +            AVFilterLink *outlink = filter->outputs[j];
 +            AVFilterChannelLayouts *fmts;
 +
 +            fmts = outlink->in_channel_layouts;
 +            if (inlink->type != outlink->type || fmts->nb_channel_layouts == 1)
 +                continue;
 +
 +            if (fmts->all_layouts) {
 +                /* Turn the infinite list into a singleton */
 +                fmts->all_layouts = fmts->all_counts  = 0;
 +                ff_add_channel_layout(&outlink->in_channel_layouts, fmt);
 +                break;
 +            }
 +
 +            for (k = 0; k < outlink->in_channel_layouts->nb_channel_layouts; k++) {
 +                if (fmts->channel_layouts[k] == fmt) {
 +                    fmts->channel_layouts[0]  = fmt;
 +                    fmts->nb_channel_layouts = 1;
 +                    ret = 1;
 +                    break;
 +                }
 +            }
 +        }
 +    }
  
      return ret;
  }
@@@ -757,23 -596,7 +801,23 @@@ static void swap_channel_layouts_on_fil
              int out_channels      = av_get_channel_layout_nb_channels(out_chlayout);
              int count_diff        = out_channels - in_channels;
              int matched_channels, extra_channels;
 -            int score = 0;
 +            int score = 100000;
 +
 +            if (FF_LAYOUT2COUNT(in_chlayout) || FF_LAYOUT2COUNT(out_chlayout)) {
 +                /* Compute score in case the input or output layout encodes
 +                   a channel count; in this case the score is not altered by
 +                   the computation afterwards, as in_chlayout and
 +                   out_chlayout have both been set to 0 */
 +                if (FF_LAYOUT2COUNT(in_chlayout))
 +                    in_channels = FF_LAYOUT2COUNT(in_chlayout);
 +                if (FF_LAYOUT2COUNT(out_chlayout))
 +                    out_channels = FF_LAYOUT2COUNT(out_chlayout);
 +                score -= 10000 + FFABS(out_channels - in_channels) +
 +                         (in_channels > out_channels ? 10000 : 0);
 +                in_chlayout = out_chlayout = 0;
 +                /* Let the remaining computation run, even if the score
 +                   value is not altered */
 +            }
  
              /* channel substitution */
              for (k = 0; k < FF_ARRAY_ELEMS(ch_subst); k++) {
@@@ -896,50 -719,15 +940,50 @@@ static void swap_sample_fmts(AVFilterGr
  static int pick_formats(AVFilterGraph *graph)
  {
      int i, j, ret;
 +    int change;
 +
 +    do{
 +        change = 0;
 +        for (i = 0; i < graph->nb_filters; i++) {
 +            AVFilterContext *filter = graph->filters[i];
 +            if (filter->nb_inputs){
 +                for (j = 0; j < filter->nb_inputs; j++){
 +                    if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->nb_formats == 1) {
 +                        if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
 +                            return ret;
 +                        change = 1;
 +                    }
 +                }
 +            }
 +            if (filter->nb_outputs){
 +                for (j = 0; j < filter->nb_outputs; j++){
 +                    if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->nb_formats == 1) {
 +                        if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
 +                            return ret;
 +                        change = 1;
 +                    }
 +                }
 +            }
 +            if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
 +                for (j = 0; j < filter->nb_outputs; j++) {
 +                    if(filter->outputs[j]->format<0) {
 +                        if ((ret = pick_format(filter->outputs[j], filter->inputs[0])) < 0)
 +                            return ret;
 +                        change = 1;
 +                    }
 +                }
 +            }
 +        }
 +    }while(change);
  
      for (i = 0; i < graph->nb_filters; i++) {
          AVFilterContext *filter = graph->filters[i];
  
          for (j = 0; j < filter->nb_inputs; j++)
 -            if ((ret = pick_format(filter->inputs[j])) < 0)
 +            if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
                  return ret;
          for (j = 0; j < filter->nb_outputs; j++)
 -            if ((ret = pick_format(filter->outputs[j])) < 0)
 +            if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
                  return ret;
      }
      return 0;
@@@ -953,9 -741,7 +997,9 @@@ static int graph_config_formats(AVFilte
      int ret;
  
      /* find supported formats from sub-filters, and merge along links */
 -    if ((ret = query_formats(graph, log_ctx)) < 0)
 +    while ((ret = query_formats(graph, log_ctx)) == AVERROR(EAGAIN))
 +        av_log(graph, AV_LOG_DEBUG, "query_formats not finished\n");
 +    if (ret < 0)
          return ret;
  
      /* Once everything is merged, it's possible that we'll still have
      return 0;
  }
  
 +static int ff_avfilter_graph_config_pointers(AVFilterGraph *graph,
 +                                             AVClass *log_ctx)
 +{
 +    unsigned i, j;
 +    int sink_links_count = 0, n = 0;
 +    AVFilterContext *f;
 +    AVFilterLink **sinks;
 +
 +    for (i = 0; i < graph->nb_filters; i++) {
 +        f = graph->filters[i];
 +        for (j = 0; j < f->nb_inputs; j++) {
 +            f->inputs[j]->graph     = graph;
 +            f->inputs[j]->age_index = -1;
 +        }
 +        for (j = 0; j < f->nb_outputs; j++) {
 +            f->outputs[j]->graph    = graph;
 +            f->outputs[j]->age_index= -1;
 +        }
 +        if (!f->nb_outputs) {
 +            if (f->nb_inputs > INT_MAX - sink_links_count)
 +                return AVERROR(EINVAL);
 +            sink_links_count += f->nb_inputs;
 +        }
 +    }
 +    sinks = av_calloc(sink_links_count, sizeof(*sinks));
 +    if (!sinks)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i < graph->nb_filters; i++) {
 +        f = graph->filters[i];
 +        if (!f->nb_outputs) {
 +            for (j = 0; j < f->nb_inputs; j++) {
 +                sinks[n] = f->inputs[j];
 +                f->inputs[j]->age_index = n++;
 +            }
 +        }
 +    }
 +    av_assert0(n == sink_links_count);
 +    graph->sink_links       = sinks;
 +    graph->sink_links_count = sink_links_count;
 +    return 0;
 +}
 +
  static int graph_insert_fifos(AVFilterGraph *graph, AVClass *log_ctx)
  {
      AVFilterContext *f;
@@@ -1067,131 -811,6 +1111,131 @@@ int avfilter_graph_config(AVFilterGrap
          return ret;
      if ((ret = graph_config_links(graphctx, log_ctx)))
          return ret;
 +    if ((ret = ff_avfilter_graph_config_pointers(graphctx, log_ctx)))
 +        return ret;
  
      return 0;
  }
 +
 +int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
 +{
 +    int i, r = AVERROR(ENOSYS);
 +
 +    if (!graph)
 +        return r;
 +
 +    if ((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
 +        r = avfilter_graph_send_command(graph, target, cmd, arg, res, res_len, flags | AVFILTER_CMD_FLAG_FAST);
 +        if (r != AVERROR(ENOSYS))
 +            return r;
 +    }
 +
 +    if (res_len && res)
 +        res[0] = 0;
 +
 +    for (i = 0; i < graph->nb_filters; i++) {
 +        AVFilterContext *filter = graph->filters[i];
 +        if (!strcmp(target, "all") || (filter->name && !strcmp(target, filter->name)) || !strcmp(target, filter->filter->name)) {
 +            r = avfilter_process_command(filter, cmd, arg, res, res_len, flags);
 +            if (r != AVERROR(ENOSYS)) {
 +                if ((flags & AVFILTER_CMD_FLAG_ONE) || r < 0)
 +                    return r;
 +            }
 +        }
 +    }
 +
 +    return r;
 +}
 +
 +int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *command, const char *arg, int flags, double ts)
 +{
 +    int i;
 +
 +    if(!graph)
 +        return 0;
 +
 +    for (i = 0; i < graph->nb_filters; i++) {
 +        AVFilterContext *filter = graph->filters[i];
 +        if(filter && (!strcmp(target, "all") || !strcmp(target, filter->name) || !strcmp(target, filter->filter->name))){
 +            AVFilterCommand **queue = &filter->command_queue, *next;
 +            while (*queue && (*queue)->time <= ts)
 +                queue = &(*queue)->next;
 +            next = *queue;
 +            *queue = av_mallocz(sizeof(AVFilterCommand));
 +            (*queue)->command = av_strdup(command);
 +            (*queue)->arg     = av_strdup(arg);
 +            (*queue)->time    = ts;
 +            (*queue)->flags   = flags;
 +            (*queue)->next    = next;
 +            if(flags & AVFILTER_CMD_FLAG_ONE)
 +                return 0;
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static void heap_bubble_up(AVFilterGraph *graph,
 +                           AVFilterLink *link, int index)
 +{
 +    AVFilterLink **links = graph->sink_links;
 +
 +    while (index) {
 +        int parent = (index - 1) >> 1;
 +        if (links[parent]->current_pts >= link->current_pts)
 +            break;
 +        links[index] = links[parent];
 +        links[index]->age_index = index;
 +        index = parent;
 +    }
 +    links[index] = link;
 +    link->age_index = index;
 +}
 +
 +static void heap_bubble_down(AVFilterGraph *graph,
 +                             AVFilterLink *link, int index)
 +{
 +    AVFilterLink **links = graph->sink_links;
 +
 +    while (1) {
 +        int child = 2 * index + 1;
 +        if (child >= graph->sink_links_count)
 +            break;
 +        if (child + 1 < graph->sink_links_count &&
 +            links[child + 1]->current_pts < links[child]->current_pts)
 +            child++;
 +        if (link->current_pts < links[child]->current_pts)
 +            break;
 +        links[index] = links[child];
 +        links[index]->age_index = index;
 +        index = child;
 +    }
 +    links[index] = link;
 +    link->age_index = index;
 +}
 +
 +void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link)
 +{
 +    heap_bubble_up  (graph, link, link->age_index);
 +    heap_bubble_down(graph, link, link->age_index);
 +}
 +
 +
 +int avfilter_graph_request_oldest(AVFilterGraph *graph)
 +{
 +    while (graph->sink_links_count) {
 +        AVFilterLink *oldest = graph->sink_links[0];
 +        int r = ff_request_frame(oldest);
 +        if (r != AVERROR_EOF)
 +            return r;
 +        av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n",
 +               oldest->dst ? oldest->dst->name : "unknown",
 +               oldest->dstpad ? oldest->dstpad->name : "unknown");
 +        /* EOF: remove the link from the heap */
 +        if (oldest->age_index < --graph->sink_links_count)
 +            heap_bubble_down(graph, graph->sink_links[graph->sink_links_count],
 +                             oldest->age_index);
 +        oldest->age_index = -1;
 +    }
 +    return AVERROR_EOF;
 +}
diff --combined libavfilter/internal.h
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
   */
  
  #include "avfilter.h"
 +#include "avfiltergraph.h"
 +#include "formats.h"
+ #include "thread.h"
 +#include "video.h"
 +
 +#define POOL_SIZE 32
 +typedef struct AVFilterPool {
 +    AVFilterBufferRef *pic[POOL_SIZE];
 +    int count;
 +    int refcount;
 +    int draining;
 +} AVFilterPool;
 +
 +typedef struct AVFilterCommand {
 +    double time;                ///< time expressed in seconds
 +    char *command;              ///< command
 +    char *arg;                  ///< optional argument for the command
 +    int flags;
 +    struct AVFilterCommand *next;
 +} AVFilterCommand;
 +
 +/**
 + * Update the position of a link in the age heap.
 + */
 +void ff_avfilter_graph_update_heap(AVFilterGraph *graph, AVFilterLink *link);
  
  #if !FF_API_AVFILTERPAD_PUBLIC
  /**
@@@ -69,7 -46,7 +70,7 @@@ struct AVFilterPad 
  
      /**
       * Callback function to get a video buffer. If NULL, the filter system will
 -     * use avfilter_default_get_video_buffer().
 +     * use ff_default_get_video_buffer().
       *
       * Input video pads only.
       */
@@@ -77,7 -54,7 +78,7 @@@
  
      /**
       * Callback function to get an audio buffer. If NULL, the filter system will
 -     * use avfilter_default_get_audio_buffer().
 +     * use ff_default_get_audio_buffer().
       *
       * Input audio pads only.
       */
  };
  #endif
  
+ struct AVFilterGraphInternal {
+     void *thread;
+     int (*thread_execute)(AVFilterContext *ctx, action_func *func, void *arg,
+                           int *ret, int nb_jobs);
+ };
+ struct AVFilterInternal {
+     int (*execute)(AVFilterContext *ctx, action_func *func, void *arg,
+                    int *ret, int nb_jobs);
+ };
  /** default handler for freeing audio/video buffer when there are no references left */
  void ff_avfilter_default_free_buffer(AVFilterBuffer *buf);
  
  /** Tell is a format is contained in the provided list terminated by -1. */
  int ff_fmt_is_in(int fmt, const int *fmts);
  
 -#define FF_DPRINTF_START(ctx, func) av_dlog(NULL, "%-16s: ", #func)
 +/**
 + * Return a copy of a list of integers terminated by -1, or NULL in
 + * case of copy failure.
 + */
 +int *ff_copy_int_list(const int * const list);
 +
 +/**
 + * Return a copy of a list of 64-bit integers, or NULL in case of
 + * copy failure.
 + */
 +int64_t *ff_copy_int64_list(const int64_t * const list);
 +
 +/* Functions to parse audio format arguments */
 +
 +/**
 + * Parse a pixel format.
 + *
 + * @param ret pixel format pointer to where the value should be written
 + * @param arg string to parse
 + * @param log_ctx log context
 + * @return 0 in case of success, a negative AVERROR code on error
 + */
 +int ff_parse_pixel_format(enum AVPixelFormat *ret, const char *arg, void *log_ctx);
 +
 +/**
 + * Parse a sample rate.
 + *
 + * @param ret unsigned integer pointer to where the value should be written
 + * @param arg string to parse
 + * @param log_ctx log context
 + * @return 0 in case of success, a negative AVERROR code on error
 + */
 +int ff_parse_sample_rate(int *ret, const char *arg, void *log_ctx);
 +
 +/**
 + * Parse a time base.
 + *
 + * @param ret unsigned AVRational pointer to where the value should be written
 + * @param arg string to parse
 + * @param log_ctx log context
 + * @return 0 in case of success, a negative AVERROR code on error
 + */
 +int ff_parse_time_base(AVRational *ret, const char *arg, void *log_ctx);
 +
 +/**
 + * Parse a sample format name or a corresponding integer representation.
 + *
 + * @param ret integer pointer to where the value should be written
 + * @param arg string to parse
 + * @param log_ctx log context
 + * @return 0 in case of success, a negative AVERROR code on error
 + */
 +int ff_parse_sample_format(int *ret, const char *arg, void *log_ctx);
 +
 +/**
 + * Parse a channel layout or a corresponding integer representation.
 + *
 + * @param ret 64bit integer pointer to where the value should be written.
 + * @param arg string to parse
 + * @param log_ctx log context
 + * @return 0 in case of success, a negative AVERROR code on error
 + */
 +int ff_parse_channel_layout(int64_t *ret, const char *arg, void *log_ctx);
 +
 +void ff_update_link_current_pts(AVFilterLink *link, int64_t pts);
 +
 +void ff_command_queue_pop(AVFilterContext *filter);
 +
 +/* misc trace functions */
  
 -void ff_dlog_link(void *ctx, AVFilterLink *link, int end);
 +/* #define FF_AVFILTER_TRACE */
 +
 +#ifdef FF_AVFILTER_TRACE
 +#    define ff_tlog(pctx, ...) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__)
 +#else
 +#    define ff_tlog(pctx, ...) do { if (0) av_log(pctx, AV_LOG_DEBUG, __VA_ARGS__); } while (0)
 +#endif
 +
 +#define FF_TPRINTF_START(ctx, func) ff_tlog(NULL, "%-16s: ", #func)
 +
 +char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms);
 +
 +void ff_tlog_ref(void *ctx, AVFrame *ref, int end);
 +
 +void ff_tlog_link(void *ctx, AVFilterLink *link, int end);
  
  /**
   * Insert a new pad.
@@@ -289,29 -195,6 +301,29 @@@ int ff_poll_frame(AVFilterLink *link)
   */
  int ff_request_frame(AVFilterLink *link);
  
 +#define AVFILTER_DEFINE_CLASS(fname)            \
 +    static const AVClass fname##_class = {      \
 +        .class_name = #fname,                   \
 +        .item_name  = av_default_item_name,     \
 +        .option     = fname##_options,          \
 +        .version    = LIBAVUTIL_VERSION_INT,    \
 +        .category   = AV_CLASS_CATEGORY_FILTER, \
 +    }
 +
 +AVFilterBufferRef *ff_copy_buffer_ref(AVFilterLink *outlink,
 +                                      AVFilterBufferRef *ref);
 +
 +/**
 + * Find the index of a link.
 + *
 + * I.e. find i such that link == ctx->(in|out)puts[i]
 + */
 +#define FF_INLINK_IDX(link)  ((int)((link)->dstpad - (link)->dst->input_pads))
 +#define FF_OUTLINK_IDX(link) ((int)((link)->srcpad - (link)->src->output_pads))
 +
 +int ff_buffersink_read_compat(AVFilterContext *ctx, AVFilterBufferRef **buf);
 +int ff_buffersink_read_samples_compat(AVFilterContext *ctx, AVFilterBufferRef **pbuf,
 +                                      int nb_samples);
  /**
   * Send a frame of data to the next filter.
   *
  int ff_filter_frame(AVFilterLink *link, AVFrame *frame);
  
  /**
 + * Flags for AVFilterLink.flags.
 + */
 +enum {
 +
 +    /**
 +     * Frame requests may need to loop in order to be fulfilled.
 +     * A filter must set this flags on an output link if it may return 0 in
 +     * request_frame() without filtering a frame.
 +     */
 +    FF_LINK_FLAG_REQUEST_LOOP = 1,
 +
 +};
 +
 +/**
   * Allocate a new filter context and return it.
   *
   * @param filter what filter to create an instance of
diff --combined libavfilter/pthread.c
index 0000000,374c1c3..6ceb8e6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,229 +1,229 @@@
 - * This file is part of Libav.
+ /*
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ /**
+  * @file
+  * Libavfilter multithreading support
+  */
+ #include "config.h"
+ #include "libavutil/common.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/mem.h"
+ #include "avfilter.h"
+ #include "internal.h"
+ #include "thread.h"
+ #if HAVE_PTHREADS
+ #include <pthread.h>
+ #elif HAVE_W32THREADS
+ #include "compat/w32pthreads.h"
+ #endif
+ typedef struct ThreadContext {
+     AVFilterGraph *graph;
+     int nb_threads;
+     pthread_t *workers;
+     action_func *func;
+     /* per-execute perameters */
+     AVFilterContext *ctx;
+     void *arg;
+     int   *rets;
+     int nb_rets;
+     int nb_jobs;
+     pthread_cond_t last_job_cond;
+     pthread_cond_t current_job_cond;
+     pthread_mutex_t current_job_lock;
+     int current_job;
+     int done;
+ } ThreadContext;
+ static void* attribute_align_arg worker(void *v)
+ {
+     ThreadContext *c = v;
+     int our_job      = c->nb_jobs;
+     int nb_threads   = c->nb_threads;
+     int self_id;
+     pthread_mutex_lock(&c->current_job_lock);
+     self_id = c->current_job++;
+     for (;;) {
+         while (our_job >= c->nb_jobs) {
+             if (c->current_job == nb_threads + c->nb_jobs)
+                 pthread_cond_signal(&c->last_job_cond);
+             pthread_cond_wait(&c->current_job_cond, &c->current_job_lock);
+             our_job = self_id;
+             if (c->done) {
+                 pthread_mutex_unlock(&c->current_job_lock);
+                 return NULL;
+             }
+         }
+         pthread_mutex_unlock(&c->current_job_lock);
+         c->rets[our_job % c->nb_rets] = c->func(c->ctx, c->arg, our_job, c->nb_jobs);
+         pthread_mutex_lock(&c->current_job_lock);
+         our_job = c->current_job++;
+     }
+ }
+ static void slice_thread_uninit(ThreadContext *c)
+ {
+     int i;
+     pthread_mutex_lock(&c->current_job_lock);
+     c->done = 1;
+     pthread_cond_broadcast(&c->current_job_cond);
+     pthread_mutex_unlock(&c->current_job_lock);
+     for (i = 0; i < c->nb_threads; i++)
+          pthread_join(c->workers[i], NULL);
+     pthread_mutex_destroy(&c->current_job_lock);
+     pthread_cond_destroy(&c->current_job_cond);
+     pthread_cond_destroy(&c->last_job_cond);
+     av_freep(&c->workers);
+ }
+ static void slice_thread_park_workers(ThreadContext *c)
+ {
+     pthread_cond_wait(&c->last_job_cond, &c->current_job_lock);
+     pthread_mutex_unlock(&c->current_job_lock);
+ }
+ static int thread_execute(AVFilterContext *ctx, action_func *func,
+                           void *arg, int *ret, int nb_jobs)
+ {
+     ThreadContext *c = ctx->graph->internal->thread;
+     int dummy_ret;
+     if (nb_jobs <= 0)
+         return 0;
+     pthread_mutex_lock(&c->current_job_lock);
+     c->current_job = c->nb_threads;
+     c->nb_jobs     = nb_jobs;
+     c->ctx         = ctx;
+     c->arg         = arg;
+     c->func        = func;
+     if (ret) {
+         c->rets    = ret;
+         c->nb_rets = nb_jobs;
+     } else {
+         c->rets    = &dummy_ret;
+         c->nb_rets = 1;
+     }
+     pthread_cond_broadcast(&c->current_job_cond);
+     slice_thread_park_workers(c);
+     return 0;
+ }
+ static int thread_init(ThreadContext *c, int nb_threads)
+ {
+     int i, ret;
+     if (!nb_threads) {
+         int nb_cpus = av_cpu_count();
+         av_log(c->graph, AV_LOG_DEBUG, "Detected %d logical cores.\n", nb_cpus);
+         // use number of cores + 1 as thread count if there is more than one
+         if (nb_cpus > 1)
+             nb_threads = nb_cpus + 1;
+         else
+             nb_threads = 1;
+     }
+     if (nb_threads <= 1)
+         return 1;
+     c->nb_threads = nb_threads;
+     c->workers = av_mallocz(sizeof(*c->workers) * nb_threads);
+     if (!c->workers)
+         return AVERROR(ENOMEM);
+     c->current_job = 0;
+     c->nb_jobs     = 0;
+     c->done        = 0;
+     pthread_cond_init(&c->current_job_cond, NULL);
+     pthread_cond_init(&c->last_job_cond,    NULL);
+     pthread_mutex_init(&c->current_job_lock, NULL);
+     pthread_mutex_lock(&c->current_job_lock);
+     for (i = 0; i < nb_threads; i++) {
+         ret = pthread_create(&c->workers[i], NULL, worker, c);
+         if (ret) {
+            pthread_mutex_unlock(&c->current_job_lock);
+            c->nb_threads = i;
+            slice_thread_uninit(c);
+            return AVERROR(ret);
+         }
+     }
+     slice_thread_park_workers(c);
+     return c->nb_threads;
+ }
+ int ff_graph_thread_init(AVFilterGraph *graph)
+ {
+     int ret;
+ #if HAVE_W32THREADS
+     w32thread_init();
+ #endif
+     if (graph->nb_threads == 1) {
+         graph->thread_type = 0;
+         return 0;
+     }
+     graph->internal->thread = av_mallocz(sizeof(ThreadContext));
+     if (!graph->internal->thread)
+         return AVERROR(ENOMEM);
+     ret = thread_init(graph->internal->thread, graph->nb_threads);
+     if (ret <= 1) {
+         av_freep(&graph->internal->thread);
+         graph->thread_type = 0;
+         graph->nb_threads  = 1;
+         return (ret < 0) ? ret : 0;
+     }
+     graph->nb_threads = ret;
+     graph->internal->thread_execute = thread_execute;
+     return 0;
+ }
+ void ff_graph_thread_free(AVFilterGraph *graph)
+ {
+     if (graph->internal->thread)
+         slice_thread_uninit(graph->internal->thread);
+     av_freep(&graph->internal->thread);
+ }
diff --combined libavfilter/thread.h
index 0000000,49134d9..0dc3aaa
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,31 +1,31 @@@
 - * This file is part of Libav.
+ /*
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * FFmpeg is free software; you can redistribute it and/or
+  * modify it under the terms of the GNU Lesser General Public
+  * License as published by the Free Software Foundation; either
+  * version 2.1 of the License, or (at your option) any later version.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * FFmpeg is distributed in the hope that it will be useful,
+  * but WITHOUT ANY WARRANTY; without even the implied warranty of
+  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  * Lesser General Public License for more details.
+  *
+  * You should have received a copy of the GNU Lesser General Public
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #ifndef AVFILTER_THREAD_H
+ #define AVFILTER_THREAD_H
+ #include "avfilter.h"
+ typedef int (action_func)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);
+ int ff_graph_thread_init(AVFilterGraph *graph);
+ void ff_graph_thread_free(AVFilterGraph *graph);
+ #endif /* AVFILTER_THREAD_H */
diff --combined libavfilter/version.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
   * Version macros.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -30,8 -30,8 +30,8 @@@
  #include "libavutil/avutil.h"
  
  #define LIBAVFILTER_VERSION_MAJOR  3
- #define LIBAVFILTER_VERSION_MINOR  69
- #define LIBAVFILTER_VERSION_MICRO 101
 -#define LIBAVFILTER_VERSION_MINOR  10
 -#define LIBAVFILTER_VERSION_MICRO  0
++#define LIBAVFILTER_VERSION_MINOR  70
++#define LIBAVFILTER_VERSION_MICRO 100
  
  #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
                                                 LIBAVFILTER_VERSION_MINOR, \
@@@ -41,8 -41,6 +41,8 @@@
                                             LIBAVFILTER_VERSION_MICRO)
  #define LIBAVFILTER_BUILD       LIBAVFILTER_VERSION_INT
  
 +#define LIBAVFILTER_IDENT       "Lavfi" AV_STRINGIFY(LIBAVFILTER_VERSION)
 +
  /**
   * FF_API_* defines may be placed below to indicate public API that will be
   * dropped at a future version bump. The defines themselves are not part of
  #ifndef FF_API_FOO_COUNT
  #define FF_API_FOO_COUNT                    (LIBAVFILTER_VERSION_MAJOR < 4)
  #endif
 +#ifndef FF_API_FILL_FRAME
 +#define FF_API_FILL_FRAME                   (LIBAVFILTER_VERSION_MAJOR < 4)
 +#endif
 +#ifndef FF_API_BUFFERSRC_BUFFER
 +#define FF_API_BUFFERSRC_BUFFER             (LIBAVFILTER_VERSION_MAJOR < 4)
 +#endif
  #ifndef FF_API_AVFILTERBUFFER
  #define FF_API_AVFILTERBUFFER               (LIBAVFILTER_VERSION_MAJOR < 4)
  #endif
  #ifndef FF_API_OLD_FILTER_OPTS
  #define FF_API_OLD_FILTER_OPTS              (LIBAVFILTER_VERSION_MAJOR < 4)
  #endif
 +#ifndef FF_API_ACONVERT_FILTER
 +#define FF_API_ACONVERT_FILTER              (LIBAVFILTER_VERSION_MAJOR < 4)
 +#endif
  #ifndef FF_API_AVFILTER_OPEN
  #define FF_API_AVFILTER_OPEN                (LIBAVFILTER_VERSION_MAJOR < 4)
  #endif