Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 13 Jun 2012 19:04:06 +0000 (21:04 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 13 Jun 2012 20:43:57 +0000 (22:43 +0200)
* qatar/master:
  rtmp: Add a new option 'rtmp_buffer', for setting the client buffer time
  rtmp: Set the client buffer time to 3s instead of 0.26s
  rtmp: Handle server bandwidth packets
  rtmp: Display a verbose message when an unknown packet type is received
  lavfi/audio: use av_samples_copy() instead of custom code.
  configure: add all filters hardcoded into avconv to avconv_deps
  avfiltergraph: remove a redundant call to avfilter_get_by_name().
  lavfi: allow building without swscale.
  build: Do not delete tests/vsynth2 directory, which is no longer created.
  lavfi: replace AVFilterContext.input/output_count with nb_inputs/outputs
  lavfi: make AVFilterPad opaque after two major bumps.
  lavfi: add avfilter_pad_get_type() and avfilter_pad_get_name().
  lavfi: make avfilter_get_video_buffer() private on next bump.
  jack: update to new latency range API as the old one has been deprecated
  rtmp: Tokenize the AMF connection parameters manually instead of using strtok_r
  ppc: Rename H.264 optimization template file for consistency.
  lavfi: add channelsplit audio filter.
  golomb: check remaining bits during unary decoding in get_ur_golomb_jpegls()
  sws: fix planar RGB input conversions for 9/10/16 bpp.

Conflicts:
Changelog
configure
doc/APIchanges
ffmpeg.c
libavcodec/golomb.h
libavcodec/v210dec.h
libavfilter/Makefile
libavfilter/allfilters.c
libavfilter/asrc_anullsrc.c
libavfilter/audio.c
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/buffersrc.c
libavfilter/formats.c
libavfilter/version.h
libavfilter/vf_frei0r.c
libavfilter/vf_pad.c
libavfilter/vf_scale.c
libavfilter/video.h
libavfilter/vsrc_color.c
libavformat/rtmpproto.c
libswscale/input.c
tests/Makefile

Merged-by: Michael Niedermayer <michaelni@gmx.at>
66 files changed:
1  2 
.gitignore
Changelog
configure
doc/APIchanges
doc/filters.texi
doc/protocols.texi
ffmpeg.c
libavcodec/ppc/h264_altivec.c
libavcodec/ppc/h264_altivec_template.c
libavcodec/ppc/vc1dsp_altivec.c
libavcodec/v210dec.h
libavdevice/jack_audio.c
libavfilter/Makefile
libavfilter/af_amerge.c
libavfilter/af_anull.c
libavfilter/allfilters.c
libavfilter/asink_anullsink.c
libavfilter/asrc_anullsrc.c
libavfilter/audio.c
libavfilter/audio.h
libavfilter/avfilter.c
libavfilter/avfilter.h
libavfilter/avfiltergraph.c
libavfilter/buffersrc.c
libavfilter/formats.c
libavfilter/formats.h
libavfilter/graphparser.c
libavfilter/internal.h
libavfilter/split.c
libavfilter/src_movie.c
libavfilter/version.h
libavfilter/vf_aspect.c
libavfilter/vf_blackframe.c
libavfilter/vf_boxblur.c
libavfilter/vf_copy.c
libavfilter/vf_crop.c
libavfilter/vf_cropdetect.c
libavfilter/vf_delogo.c
libavfilter/vf_drawbox.c
libavfilter/vf_drawtext.c
libavfilter/vf_fade.c
libavfilter/vf_fieldorder.c
libavfilter/vf_format.c
libavfilter/vf_frei0r.c
libavfilter/vf_gradfun.c
libavfilter/vf_hflip.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_null.c
libavfilter/vf_overlay.c
libavfilter/vf_pad.c
libavfilter/vf_pixdesctest.c
libavfilter/vf_scale.c
libavfilter/vf_setpts.c
libavfilter/vf_slicify.c
libavfilter/vf_transpose.c
libavfilter/vf_unsharp.c
libavfilter/vf_vflip.c
libavfilter/vf_yadif.c
libavfilter/video.c
libavfilter/video.h
libavfilter/vsink_nullsink.c
libavfilter/vsrc_color.c
libavfilter/vsrc_testsrc.c
libavformat/rtmpproto.c
libswscale/input.c
tests/Makefile

diff --cc .gitignore
@@@ -50,10 -37,8 +50,9 @@@ tests/rotozoo
  tests/tiny_psnr
  tests/videogen
  tests/vsynth1
- tests/vsynth2
  tools/aviocat
  tools/cws2fws
 +tools/ffeval
  tools/graph2dot
  tools/ismindex
  tools/lavfi-showfiltfmts
diff --cc Changelog
+++ b/Changelog
  Entries are sorted chronologically from oldest to youngest within each release,
  releases are sorted from youngest to oldest.
  
 -version <next>:
 +version next:
 +- INI and flat output in ffprobe
 +- Scene detection in libavfilter
 +- Indeo Audio decoder
++- channelsplit audio filter
  
 -- XWD encoder and decoder
 -- Support for fragmentation in the mov/mp4 muxer
 -- ISMV (Smooth Streaming) muxer
 +
 +version 0.11:
 +
 +- 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
 -- remove libpostproc
  - ID3v2 attached pictures reading and writing
  - WMA Lossless decoder
 -- XBM encoder
 +- bluray protocol
 +- blackdetect filter
 +- libutvideo encoder wrapper (--enable-libutvideo)
 +- swapuv filter
 +- bbox filter
 +- XBM encoder and decoder
  - RealAudio Lossless decoder
  - ZeroCodec decoder
 -- drop support for avconv without libavfilter
 -- add libavresample audio conversion library
 -- audio filters support in libavfilter and avconv
 +- 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
 -- audio split filter
 +- vorbis parser
 +- png parser
  - audio mix filter
 -- avprobe output is now standard INI or JSON. The old format can still
 -  be used with -of old.
 -- Indeo Audio decoder
 -- channelsplit audio filter
  
  
 -version 0.8:
 +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
 -
 -
 -version 0.8_beta2:
 -
 +- 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
diff --cc configure
+++ b/configure
@@@ -1210,7 -1087,7 +1210,8 @@@ HAVE_LIST=
      inet_aton
      inline_asm
      isatty
+     jack_port_get_latency_range
 +    kbhit
      ldbrx
      libdc1394_1
      libdc1394_2
@@@ -1730,19 -1536,17 +1731,18 @@@ yadif_filter_deps="gpl
  
  # libraries
  avdevice_deps="avcodec avformat"
- avfilter_deps="swscale"
  avformat_deps="avcodec"
 +postproc_deps="gpl"
  
  # programs
 -avconv_deps="avcodec avfilter avformat avresample swscale
 -             aformat_filter asyncts_filter
 -             format_filter fps_filter scale_filter setpts_filter"
 -avplay_deps="avcodec avformat swscale sdl"
 -avplay_select="rdft"
 -avprobe_deps="avcodec avformat"
 -avserver_deps="avformat ffm_muxer fork rtp_protocol rtsp_demuxer !shared"
 -avserver_extralibs='$ldl'
 +ffmpeg_deps="avcodec avfilter avformat swscale swresample"
 +ffmpeg_select="buffersink_filter format_filter aformat_filter
 +               setpts_filter null_filter anull_filter"
 +ffplay_deps="avcodec avformat swscale swresample sdl"
 +ffplay_select="buffersink_filter rdft"
 +ffprobe_deps="avcodec avformat"
 +ffserver_deps="avformat ffm_muxer fork rtp_protocol rtsp_demuxer"
 +ffserver_extralibs='$ldl'
  
  doc_deps="texi2html"
  
@@@ -3354,7 -2984,8 +3354,8 @@@ check_header soundcard.
  
  enabled_any alsa_indev alsa_outdev && check_lib2 alsa/asoundlib.h snd_pcm_htimestamp -lasound
  
- enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack && check_func sem_timedwait
 -enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack &&
++enabled jack_indev && check_lib2 jack/jack.h jack_client_open -ljack && check_func sem_timedwait &&
+     check_func jack_port_get_latency_range -ljack
  
  enabled_any sndio_indev sndio_outdev && check_lib2 sndio.h sio_open -lsndio
  
diff --cc doc/APIchanges
@@@ -15,29 -13,15 +15,38 @@@ libavutil:     2011-04-1
  
  API changes, most recent first:
  
 +2012-04-11 - xxxxxxx - lavu 51.58.100 - error.h
 +  Add av_make_error_string() and av_err2str() utilities to
 +  libavutil/error.h.
 +
 +2012-06-05 - xxxxxxx - lavc 54.24.100
 +  Add pkt_duration field to AVFrame.
 +
 +2012-05-24 - xxxxxxx - lavu 51.54.100
 +  Move AVPALETTE_SIZE and AVPALETTE_COUNT macros from
 +  libavcodec/avcodec.h to libavutil/pixfmt.h.
 +
 +2012-05-07 - xxxxxxx - lavf 54.5.100
 +  Add av_guess_sample_aspect_ratio() function.
 +
 +2012-04-20 - xxxxxxx - lavfi 2.70.100
 +  Add avfilter_unref_bufferp() to avfilter.h.
 +
 +2012-04-12 - xxxxxxx - 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.
 +
+ 2012-xx-xx - xxxxxxx - lavfi 2.23.0 - avfilter.h
+   Add AVFilterContext.nb_inputs/outputs. Deprecate
+   AVFilterContext.input/output_count.
+ 2012-xx-xx - xxxxxxx - lavfi 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-xx-xx - xxxxxxx - lavu 51.32.0 - audioconvert.h
    Add av_get_channel_layout_channel_index(), av_get_channel_name()
    and av_channel_layout_extract_channel().
@@@ -576,9 -207,36 +576,34 @@@ Maximum compensation in samples per sec
  
  @end table
  
 -avconv -i in.mp3 -filter_complex channelsplit out.mkv
+ @section channelsplit
+ Split each channel in input audio stream into a separate output stream.
+ This filter accepts the following named parameters:
+ @table @option
+ @item channel_layout
+ Channel layout of the input stream. Default is "stereo".
+ @end table
+ For example, assuming a stereo input MP3 file
+ @example
 -avconv -i in.wav -filter_complex
++ffmpeg -i in.mp3 -filter_complex channelsplit out.mkv
+ @end example
+ will create an output Matroska file with two audio streams, one containing only
+ the left channel and the other the right channel.
+ To split a 5.1 WAV file into per-channel files
+ @example
++ffmpeg -i in.wav -filter_complex
+ 'channelsplit=channel_layout=5.1[FL][FR][FC][LFE][SL][SR]'
+ -map '[FL]' front_left.wav -map '[FR]' front_right.wav -map '[FC]'
+ front_center.wav -map '[LFE]' lfe.wav -map '[SL]' side_left.wav -map '[SR]'
+ side_right.wav
+ @end example
  @section resample
  Convert the audio sample format, sample rate and channel layout. This filter is
 -not meant to be used directly, it is inserted automatically by libavfilter
 -whenever conversion is needed. Use the @var{aformat} filter to force a specific
 -conversion.
 +not meant to be used directly.
  
  @c man end AUDIO FILTERS
  
Simple merge
diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -707,8 -547,8 +707,8 @@@ static FilterGraph *init_simple_filterg
  
  static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
  {
 -    InputStream *ist;
 +    InputStream *ist = NULL;
-     enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
+     enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);
      int i;
  
      // TODO: support other filter types
@@@ -4899,9 -4112,10 +4899,10 @@@ static void init_output_filter(OutputFi
  {
      OutputStream *ost;
  
-     switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
+     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
+                                   ofilter->out_tmp->pad_idx)) {
 -    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
 -    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
 +    case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
 +    case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
      default:
          av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
                 "currently.\n");
Simple merge
Simple merge
index 1f06f9e,0000000..e1e3d32
mode 100644,000000..100644
--- /dev/null
@@@ -1,35 -1,0 +1,36 @@@
 +/*
 + * This file is part of Libav.
 + *
 + * Libav 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,
 + * 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
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#ifndef AVCODEC_V210DEC_H
 +#define AVCODEC_V210DEC_H
 +
 +#include "libavutil/log.h"
 +#include "libavutil/opt.h"
 +
++
 +typedef struct {
 +    AVClass *av_class;
 +    int custom_stride;
 +    int aligned_input;
 +    int stride_warning_shown;
 +    void (*unpack_frame)(const uint32_t *src, uint16_t *y, uint16_t *u, uint16_t *v, int width);
 +} V210DecContext;
 +
 +void v210_x86_init(V210DecContext *s);
 +
 +#endif /* AVCODEC_V210DEC_H */
Simple merge
@@@ -1,21 -1,11 +1,22 @@@
 +include $(SUBDIR)../config.mak
 +
  NAME = avfilter
- FFLIBS = avutil swscale
+ FFLIBS = avutil
  FFLIBS-$(CONFIG_ASYNCTS_FILTER) += avresample
 -FFLIBS-$(CONFIG_MOVIE_FILTER) += avformat avcodec
  FFLIBS-$(CONFIG_RESAMPLE_FILTER) += avresample
+ FFLIBS-$(CONFIG_SCALE_FILTER)   += swscale
  
 -HEADERS = avfilter.h                                                    \
 +FFLIBS-$(CONFIG_ACONVERT_FILTER)             += swresample
 +FFLIBS-$(CONFIG_AMOVIE_FILTER)               += avformat avcodec
 +FFLIBS-$(CONFIG_ARESAMPLE_FILTER)            += swresample
 +FFLIBS-$(CONFIG_MOVIE_FILTER)                += avformat avcodec
 +FFLIBS-$(CONFIG_PAN_FILTER)                  += swresample
 +FFLIBS-$(CONFIG_REMOVELOGO_FILTER)           += avformat avcodec
 +FFLIBS-$(CONFIG_MP_FILTER)                   += avcodec postproc
 +
 +HEADERS = asrc_abuffer.h                                                \
 +          avcodec.h                                                     \
 +          avfilter.h                                                    \
            avfiltergraph.h                                               \
            buffersink.h                                                  \
            buffersrc.h                                                   \
@@@ -39,40 -25,20 +40,41 @@@ OBJS = allfilters.
         vf_scale.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_AFORMAT_FILTER)                += af_aformat.o
 +OBJS-$(CONFIG_AMERGE_FILTER)                 += af_amerge.o
  OBJS-$(CONFIG_AMIX_FILTER)                   += af_amix.o
  OBJS-$(CONFIG_ANULL_FILTER)                  += af_anull.o
 +OBJS-$(CONFIG_ARESAMPLE_FILTER)              += af_aresample.o
 +OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o
  OBJS-$(CONFIG_ASPLIT_FILTER)                 += split.o
 +OBJS-$(CONFIG_ASTREAMSYNC_FILTER)            += af_astreamsync.o
  OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o
+ OBJS-$(CONFIG_CHANNELSPLIT_FILTER)           += af_channelsplit.o
 +OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o
 +OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o
  OBJS-$(CONFIG_RESAMPLE_FILTER)               += af_resample.o
 +OBJS-$(CONFIG_SILENCEDETECT_FILTER)          += af_silencedetect.o
 +OBJS-$(CONFIG_VOLUME_FILTER)                 += af_volume.o
  
 +OBJS-$(CONFIG_AEVALSRC_FILTER)               += asrc_aevalsrc.o
 +OBJS-$(CONFIG_AMOVIE_FILTER)                 += src_movie.o
  OBJS-$(CONFIG_ANULLSRC_FILTER)               += asrc_anullsrc.o
  
 +OBJS-$(CONFIG_ABUFFERSINK_FILTER)            += sink_buffer.o
  OBJS-$(CONFIG_ANULLSINK_FILTER)              += asink_anullsink.o
  
 +OBJS-$(CONFIG_ASS_FILTER)                    += vf_ass.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_BOXBLUR_FILTER)                += vf_boxblur.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
@@@ -101,10 -64,9 +103,11 @@@ OBJS-$(CONFIG_OCV_FILTER
  OBJS-$(CONFIG_OVERLAY_FILTER)                += vf_overlay.o
  OBJS-$(CONFIG_PAD_FILTER)                    += vf_pad.o
  OBJS-$(CONFIG_PIXDESCTEST_FILTER)            += vf_pixdesctest.o
 +OBJS-$(CONFIG_REMOVELOGO_FILTER)             += bbox.o lswsutils.o lavfutils.o vf_removelogo.o
+ OBJS-$(CONFIG_SCALE_FILTER)                  += vf_scale.o
  OBJS-$(CONFIG_SELECT_FILTER)                 += vf_select.o
  OBJS-$(CONFIG_SETDAR_FILTER)                 += vf_aspect.o
 +OBJS-$(CONFIG_SETFIELD_FILTER)               += vf_setfield.o
  OBJS-$(CONFIG_SETPTS_FILTER)                 += vf_setpts.o
  OBJS-$(CONFIG_SETSAR_FILTER)                 += vf_aspect.o
  OBJS-$(CONFIG_SETTB_FILTER)                  += vf_settb.o
index 3183fdc,0000000..95dd1ae
mode 100644,000000..100644
--- /dev/null
@@@ -1,339 -1,0 +1,339 @@@
-     formats = avfilter_make_format_list(ff_packed_sample_fmts);
 +/*
 + * Copyright (c) 2011 Nicolas George <nicolas.george@normalesup.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 + * GNU 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
 + * Audio merging filter
 + */
 +
 +#include "libavutil/bprint.h"
 +#include "libavutil/opt.h"
 +#include "libswresample/swresample.h" // only for SWR_CH_MAX
 +#include "avfilter.h"
 +#include "audio.h"
 +#include "bufferqueue.h"
 +#include "internal.h"
 +
 +typedef struct {
 +    const AVClass *class;
 +    int nb_inputs;
 +    int route[SWR_CH_MAX]; /**< channels routing, see copy_samples */
 +    int bps;
 +    struct amerge_input {
 +        struct FFBufQueue queue;
 +        int nb_ch;         /**< number of channels for the input */
 +        int nb_samples;
 +        int pos;
 +    } *in;
 +} AMergeContext;
 +
 +#define OFFSET(x) offsetof(AMergeContext, x)
 +
 +static const AVOption amerge_options[] = {
 +    { "inputs", "specify the number of inputs", OFFSET(nb_inputs),
 +      AV_OPT_TYPE_INT, { .dbl = 2 }, 2, SWR_CH_MAX },
 +};
 +
 +static const AVClass amerge_class = {
 +    .class_name = "AMergeContext",
 +    .item_name  = av_default_item_name,
 +    .option     = amerge_options,
 +};
 +
 +static av_cold void uninit(AVFilterContext *ctx)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int i;
 +
 +    for (i = 0; i < am->nb_inputs; i++)
 +        ff_bufqueue_discard_all(&am->in[i].queue);
 +    av_freep(&am->in);
 +}
 +
 +static int query_formats(AVFilterContext *ctx)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int64_t inlayout[SWR_CH_MAX], outlayout = 0;
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *layouts;
 +    int i, overlap = 0, nb_ch = 0;
 +
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        if (!ctx->inputs[i]->in_channel_layouts ||
 +            !ctx->inputs[i]->in_channel_layouts->nb_channel_layouts) {
 +            av_log(ctx, AV_LOG_ERROR,
 +                   "No channel layout for input %d\n", i + 1);
 +            return AVERROR(EINVAL);
 +        }
 +        inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];
 +        if (ctx->inputs[i]->in_channel_layouts->nb_channel_layouts > 1) {
 +            char buf[256];
 +            av_get_channel_layout_string(buf, sizeof(buf), 0, inlayout[i]);
 +            av_log(ctx, AV_LOG_INFO, "Using \"%s\" for input %d\n", buf, i + 1);
 +        }
 +        am->in[i].nb_ch = av_get_channel_layout_nb_channels(inlayout[i]);
 +        if (outlayout & inlayout[i])
 +            overlap++;
 +        outlayout |= inlayout[i];
 +        nb_ch += am->in[i].nb_ch;
 +    }
 +    if (nb_ch > SWR_CH_MAX) {
 +        av_log(ctx, AV_LOG_ERROR, "Too many channels (max %d)\n", SWR_CH_MAX);
 +        return AVERROR(EINVAL);
 +    }
 +    if (overlap) {
 +        av_log(ctx, AV_LOG_WARNING,
 +               "Inputs overlap: output layout will be meaningless\n");
 +        for (i = 0; i < nb_ch; i++)
 +            am->route[i] = i;
 +        outlayout = av_get_default_channel_layout(nb_ch);
 +        if (!outlayout)
 +            outlayout = ((int64_t)1 << nb_ch) - 1;
 +    } else {
 +        int *route[SWR_CH_MAX];
 +        int c, out_ch_number = 0;
 +
 +        route[0] = am->route;
 +        for (i = 1; i < am->nb_inputs; i++)
 +            route[i] = route[i - 1] + am->in[i - 1].nb_ch;
 +        for (c = 0; c < 64; c++)
 +            for (i = 0; i < am->nb_inputs; i++)
 +                if ((inlayout[i] >> c) & 1)
 +                    *(route[i]++) = out_ch_number++;
 +    }
++    formats = avfilter_make_format_list(ff_packed_sample_fmts_array);
 +    avfilter_set_common_sample_formats(ctx, formats);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        layouts = NULL;
 +        ff_add_channel_layout(&layouts, inlayout[i]);
 +        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
 +    }
 +    layouts = NULL;
 +    ff_add_channel_layout(&layouts, outlayout);
 +    ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
 +    ff_set_common_samplerates(ctx, ff_all_samplerates());
 +    return 0;
 +}
 +
 +static int config_output(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AMergeContext *am = ctx->priv;
 +    AVBPrint bp;
 +    int i;
 +
 +    for (i = 1; i < am->nb_inputs; i++) {
 +        if (ctx->inputs[i]->sample_rate != ctx->inputs[0]->sample_rate) {
 +            av_log(ctx, AV_LOG_ERROR,
 +                   "Inputs must have the same sample rate "
 +                   "(%"PRIi64" for in%d vs %"PRIi64")\n",
 +                   ctx->inputs[i]->sample_rate, i, ctx->inputs[0]->sample_rate);
 +            return AVERROR(EINVAL);
 +        }
 +    }
 +    am->bps = av_get_bytes_per_sample(ctx->outputs[0]->format);
 +    outlink->sample_rate = ctx->inputs[0]->sample_rate;
 +    outlink->time_base   = ctx->inputs[0]->time_base;
 +
 +    av_bprint_init(&bp, 0, 1);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        av_bprintf(&bp, "%sin%d:", i ? " + " : "", i);
 +        av_bprint_channel_layout(&bp, -1, ctx->inputs[i]->channel_layout);
 +    }
 +    av_bprintf(&bp, " -> out:");
 +    av_bprint_channel_layout(&bp, -1, ctx->outputs[0]->channel_layout);
 +    av_log(ctx, AV_LOG_INFO, "%s\n", bp.str);
 +
 +    return 0;
 +}
 +
 +static int request_frame(AVFilterLink *outlink)
 +{
 +    AVFilterContext *ctx = outlink->src;
 +    AMergeContext *am = ctx->priv;
 +    int i, ret;
 +
 +    for (i = 0; i < am->nb_inputs; i++)
 +        if (!am->in[i].nb_samples)
 +            if ((ret = avfilter_request_frame(ctx->inputs[i])) < 0)
 +                return ret;
 +    return 0;
 +}
 +
 +/**
 + * Copy samples from several input streams to one output stream.
 + * @param nb_inputs number of inputs
 + * @param in        inputs; used only for the nb_ch field;
 + * @param route     routing values;
 + *                  input channel i goes to output channel route[i];
 + *                  i <  in[0].nb_ch are the channels from the first output;
 + *                  i >= in[0].nb_ch are the channels from the second output
 + * @param ins       pointer to the samples of each inputs, in packed format;
 + *                  will be left at the end of the copied samples
 + * @param outs      pointer to the samples of the output, in packet format;
 + *                  must point to a buffer big enough;
 + *                  will be left at the end of the copied samples
 + * @param ns        number of samples to copy
 + * @param bps       bytes per sample
 + */
 +static inline void copy_samples(int nb_inputs, struct amerge_input in[],
 +                                int *route, uint8_t *ins[],
 +                                uint8_t **outs, int ns, int bps)
 +{
 +    int *route_cur;
 +    int i, c, nb_ch = 0;
 +
 +    for (i = 0; i < nb_inputs; i++)
 +        nb_ch += in[i].nb_ch;
 +    while (ns--) {
 +        route_cur = route;
 +        for (i = 0; i < nb_inputs; i++) {
 +            for (c = 0; c < in[i].nb_ch; c++) {
 +                memcpy((*outs) + bps * *(route_cur++), ins[i], bps);
 +                ins[i] += bps;
 +            }
 +        }
 +        *outs += nb_ch * bps;
 +    }
 +}
 +
 +static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *insamples)
 +{
 +    AVFilterContext *ctx = inlink->dst;
 +    AMergeContext *am = ctx->priv;
 +    AVFilterLink *const outlink = ctx->outputs[0];
 +    int input_number;
 +    int nb_samples, ns, i;
 +    AVFilterBufferRef *outbuf, *inbuf[SWR_CH_MAX];
 +    uint8_t *ins[SWR_CH_MAX], *outs;
 +
 +    for (input_number = 0; input_number < am->nb_inputs; input_number++)
 +        if (inlink == ctx->inputs[input_number])
 +            break;
 +    av_assert1(input_number < am->nb_inputs);
 +    ff_bufqueue_add(ctx, &am->in[input_number].queue, insamples);
 +    am->in[input_number].nb_samples += insamples->audio->nb_samples;
 +    nb_samples = am->in[0].nb_samples;
 +    for (i = 1; i < am->nb_inputs; i++)
 +        nb_samples = FFMIN(nb_samples, am->in[i].nb_samples);
 +    if (!nb_samples)
 +        return;
 +
 +    outbuf = ff_get_audio_buffer(ctx->outputs[0], AV_PERM_WRITE, nb_samples);
 +    outs = outbuf->data[0];
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);
 +        ins[i] = inbuf[i]->data[0] +
 +                 am->in[i].pos * am->in[i].nb_ch * am->bps;
 +    }
 +    outbuf->pts = inbuf[0]->pts == AV_NOPTS_VALUE ? AV_NOPTS_VALUE :
 +                  inbuf[0]->pts +
 +                  av_rescale_q(am->in[0].pos,
 +                               (AVRational){ 1, ctx->inputs[0]->sample_rate },
 +                               ctx->outputs[0]->time_base);
 +
 +    avfilter_copy_buffer_ref_props(outbuf, inbuf[0]);
 +    outbuf->audio->nb_samples     = nb_samples;
 +    outbuf->audio->channel_layout = outlink->channel_layout;
 +
 +    while (nb_samples) {
 +        ns = nb_samples;
 +        for (i = 0; i < am->nb_inputs; i++)
 +            ns = FFMIN(ns, inbuf[i]->audio->nb_samples - am->in[i].pos);
 +        /* Unroll the most common sample formats: speed +~350% for the loop,
 +           +~13% overall (including two common decoders) */
 +        switch (am->bps) {
 +            case 1:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 1);
 +                break;
 +            case 2:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 2);
 +                break;
 +            case 4:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, 4);
 +                break;
 +            default:
 +                copy_samples(am->nb_inputs, am->in, am->route, ins, &outs, ns, am->bps);
 +                break;
 +        }
 +
 +        nb_samples -= ns;
 +        for (i = 0; i < am->nb_inputs; i++) {
 +            am->in[i].nb_samples -= ns;
 +            am->in[i].pos += ns;
 +            if (am->in[i].pos == inbuf[i]->audio->nb_samples) {
 +                am->in[i].pos = 0;
 +                avfilter_unref_buffer(inbuf[i]);
 +                ff_bufqueue_get(&am->in[i].queue);
 +                inbuf[i] = ff_bufqueue_peek(&am->in[i].queue, 0);
 +                ins[i] = inbuf[i] ? inbuf[i]->data[0] : NULL;
 +            }
 +        }
 +    }
 +    ff_filter_samples(ctx->outputs[0], outbuf);
 +}
 +
 +static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
 +{
 +    AMergeContext *am = ctx->priv;
 +    int ret, i;
 +    char name[16];
 +
 +    am->class = &amerge_class;
 +    av_opt_set_defaults(am);
 +    ret = av_set_options_string(am, args, "=", ":");
 +    if (ret < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Error parsing options: '%s'\n", args);
 +        return ret;
 +    }
 +    am->in = av_calloc(am->nb_inputs, sizeof(*am->in));
 +    if (!am->in)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i < am->nb_inputs; i++) {
 +        AVFilterPad pad = {
 +            .name             = name,
 +            .type             = AVMEDIA_TYPE_AUDIO,
 +            .filter_samples   = filter_samples,
 +            .min_perms        = AV_PERM_READ | AV_PERM_PRESERVE,
 +        };
 +        snprintf(name, sizeof(name), "in%d", i);
 +        avfilter_insert_inpad(ctx, i, &pad);
 +    }
 +    return 0;
 +}
 +
 +AVFilter avfilter_af_amerge = {
 +    .name          = "amerge",
 +    .description   = NULL_IF_CONFIG_SMALL("Merge two audio streams into "
 +                                          "a single multi-channel stream."),
 +    .priv_size     = sizeof(AMergeContext),
 +    .init          = init,
 +    .uninit        = uninit,
 +    .query_formats = query_formats,
 +
 +    .inputs    = (const AVFilterPad[]) { { .name = NULL } },
 +    .outputs   = (const AVFilterPad[]) {
 +        { .name             = "default",
 +          .type             = AVMEDIA_TYPE_AUDIO,
 +          .config_props     = config_output,
 +          .request_frame    = request_frame, },
 +        { .name = NULL }
 +    },
 +};
Simple merge
@@@ -34,35 -34,20 +34,36 @@@ void avfilter_register_all(void
          return;
      initialized = 1;
  
 +    REGISTER_FILTER (ACONVERT,    aconvert,    af);
      REGISTER_FILTER (AFORMAT,     aformat,     af);
 +    REGISTER_FILTER (AMERGE,      amerge,      af);
      REGISTER_FILTER (AMIX,        amix,        af);
      REGISTER_FILTER (ANULL,       anull,       af);
 +    REGISTER_FILTER (ARESAMPLE,   aresample,   af);
 +    REGISTER_FILTER (ASHOWINFO,   ashowinfo,   af);
      REGISTER_FILTER (ASPLIT,      asplit,      af);
 +    REGISTER_FILTER (ASTREAMSYNC, astreamsync, af);
      REGISTER_FILTER (ASYNCTS,     asyncts,     af);
+     REGISTER_FILTER (CHANNELSPLIT,channelsplit,af);
 +    REGISTER_FILTER (EARWAX,      earwax,      af);
 +    REGISTER_FILTER (PAN,         pan,         af);
 +    REGISTER_FILTER (SILENCEDETECT, silencedetect, af);
 +    REGISTER_FILTER (VOLUME,      volume,      af);
      REGISTER_FILTER (RESAMPLE,    resample,    af);
  
 +    REGISTER_FILTER (AEVALSRC,    aevalsrc,    asrc);
 +    REGISTER_FILTER (AMOVIE,      amovie,      asrc);
      REGISTER_FILTER (ANULLSRC,    anullsrc,    asrc);
  
 +    REGISTER_FILTER (ABUFFERSINK, abuffersink, asink);
      REGISTER_FILTER (ANULLSINK,   anullsink,   asink);
  
 +    REGISTER_FILTER (ASS,         ass,         vf);
 +    REGISTER_FILTER (BBOX,        bbox,        vf);
 +    REGISTER_FILTER (BLACKDETECT, blackdetect, vf);
      REGISTER_FILTER (BLACKFRAME,  blackframe,  vf);
      REGISTER_FILTER (BOXBLUR,     boxblur,     vf);
 +    REGISTER_FILTER (COLORMATRIX, colormatrix, vf);
      REGISTER_FILTER (COPY,        copy,        vf);
      REGISTER_FILTER (CROP,        crop,        vf);
      REGISTER_FILTER (CROPDETECT,  cropdetect,  vf);
      REGISTER_FILTER (OVERLAY,     overlay,     vf);
      REGISTER_FILTER (PAD,         pad,         vf);
      REGISTER_FILTER (PIXDESCTEST, pixdesctest, vf);
 +    REGISTER_FILTER (REMOVELOGO,  removelogo,  vf);
+     REGISTER_FILTER (SCALE,       scale,       vf);
      REGISTER_FILTER (SELECT,      select,      vf);
      REGISTER_FILTER (SETDAR,      setdar,      vf);
 +    REGISTER_FILTER (SETFIELD,    setfield,    vf);
      REGISTER_FILTER (SETPTS,      setpts,      vf);
      REGISTER_FILTER (SETSAR,      setsar,      vf);
      REGISTER_FILTER (SETTB,       settb,       vf);
Simple merge
   * null audio source
   */
  
 -#include "avfilter.h"
+ #include "internal.h"
  #include "libavutil/audioconvert.h"
 +#include "libavutil/opt.h"
 +
 +#include "audio.h"
 +#include "avfilter.h"
 +#include "internal.h"
  
  typedef struct {
 +    const AVClass *class;
 +    char   *channel_layout_str;
      uint64_t channel_layout;
 -    int64_t sample_rate;
 +    char   *sample_rate_str;
 +    int     sample_rate;
 +    int nb_samples;             ///< number of samples per requested frame
 +    int64_t pts;
  } ANullContext;
  
 +#define OFFSET(x) offsetof(ANullContext, x)
 +
 +static const AVOption anullsrc_options[]= {
 +    { "channel_layout", "set channel_layout", OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, {.str = "stereo"}, 0, 0 },
 +    { "cl",             "set channel_layout", OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, {.str = "stereo"}, 0, 0 },
 +    { "sample_rate",    "set sample rate",    OFFSET(sample_rate_str)   , AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0 },
 +    { "r",              "set sample rate",    OFFSET(sample_rate_str)   , AV_OPT_TYPE_STRING, {.str = "44100"}, 0, 0 },
 +    { "nb_samples",     "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.dbl = 1024}, 0, INT_MAX },
 +    { "n",              "set the number of samples per requested frame", OFFSET(nb_samples), AV_OPT_TYPE_INT, {.dbl = 1024}, 0, INT_MAX },
 +    { NULL },
 +};
 +
 +static const AVClass anullsrc_class = {
 +    "ANullSrcContext",
 +    av_default_item_name,
 +    anullsrc_options
 +};
 +
  static int init(AVFilterContext *ctx, const char *args, void *opaque)
  {
 -    ANullContext *priv = ctx->priv;
 -    char channel_layout_str[128] = "";
 +    ANullContext *null = ctx->priv;
 +    int ret;
  
 -    priv->sample_rate = 44100;
 -    priv->channel_layout = AV_CH_LAYOUT_STEREO;
 +    null->class = &anullsrc_class;
 +    av_opt_set_defaults(null);
  
 -    if (args)
 -        sscanf(args, "%"PRId64":%s", &priv->sample_rate, channel_layout_str);
 -
 -    if (priv->sample_rate < 0) {
 -        av_log(ctx, AV_LOG_ERROR, "Invalid negative sample rate: %"PRId64"\n", priv->sample_rate);
 -        return AVERROR(EINVAL);
 +    if ((ret = (av_set_options_string(null, args, "=", ":"))) < 0) {
 +        av_log(ctx, AV_LOG_ERROR, "Error parsing options string: '%s'\n", args);
 +        return ret;
      }
  
 -    if (*channel_layout_str)
 -        if (!(priv->channel_layout = av_get_channel_layout(channel_layout_str))
 -            && sscanf(channel_layout_str, "%"PRId64, &priv->channel_layout) != 1) {
 -            av_log(ctx, AV_LOG_ERROR, "Invalid value '%s' for channel layout\n",
 -                   channel_layout_str);
 -            return AVERROR(EINVAL);
 -        }
 +    if ((ret = ff_parse_sample_rate(&null->sample_rate,
 +                                     null->sample_rate_str, ctx)) < 0)
 +        return ret;
 +
 +    if ((ret = ff_parse_channel_layout(&null->channel_layout,
 +                                        null->channel_layout_str, ctx)) < 0)
 +        return ret;
  
      return 0;
  }
@@@ -190,10 -185,6 +190,7 @@@ void ff_filter_samples(AVFilterLink *li
      /* prepare to copy the samples if the buffer has insufficient permissions */
      if ((dst->min_perms & samplesref->perms) != dst->min_perms ||
          dst->rej_perms & samplesref->perms) {
-         int  i, size, planar = av_sample_fmt_is_planar(samplesref->format);
-         int planes = !planar ? 1:
-                      av_get_channel_layout_nb_channels(samplesref->audio->channel_layout);
++        int size;
          av_log(link->dst, AV_LOG_DEBUG,
                 "Copying audio data in avfilter (have perms %x, need %x, reject %x)\n",
                 samplesref->perms, link->dstpad->min_perms, link->dstpad->rej_perms);
  
  #include "avfilter.h"
  
- static const enum AVSampleFormat ff_packed_sample_fmts[] = {
++static const enum AVSampleFormat ff_packed_sample_fmts_array[] = {
 +    AV_SAMPLE_FMT_U8,
 +    AV_SAMPLE_FMT_S16,
 +    AV_SAMPLE_FMT_S32,
 +    AV_SAMPLE_FMT_FLT,
 +    AV_SAMPLE_FMT_DBL,
 +    AV_SAMPLE_FMT_NONE
 +};
 +
- static const enum AVSampleFormat ff_planar_sample_fmts[] = {
++static const enum AVSampleFormat ff_planar_sample_fmts_array[] = {
 +    AV_SAMPLE_FMT_U8P,
 +    AV_SAMPLE_FMT_S16P,
 +    AV_SAMPLE_FMT_S32P,
 +    AV_SAMPLE_FMT_FLTP,
 +    AV_SAMPLE_FMT_DBLP,
 +    AV_SAMPLE_FMT_NONE
 +};
 +
  /** default handler for get_audio_buffer() for audio inputs */
  AVFilterBufferRef *ff_default_get_audio_buffer(AVFilterLink *link, int perms,
                                                       int nb_samples);
@@@ -200,10 -138,8 +200,10 @@@ int avfilter_config_links(AVFilterConte
      unsigned i;
      int ret;
  
-     for (i = 0; i < filter->input_count; i ++) {
+     for (i = 0; i < filter->nb_inputs; i ++) {
          AVFilterLink *link = filter->inputs[i];
-         AVFilterLink *inlink = link->src->input_count ?
++        AVFilterLink *inlink = link->src->nb_inputs ?
 +            link->src->inputs[0] : NULL;
  
          if (!link) continue;
  
@@@ -509,9 -399,9 +513,9 @@@ void avfilter_free(AVFilterContext *fil
              ff_channel_layouts_unref(&link->in_channel_layouts);
              ff_channel_layouts_unref(&link->out_channel_layouts);
          }
 -        av_freep(&link);
 +        avfilter_link_free(&link);
      }
-     for (i = 0; i < filter->output_count; i++) {
+     for (i = 0; i < filter->nb_outputs; i++) {
          if ((link = filter->outputs[i])) {
              if (link->dst)
                  link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
@@@ -546,7 -433,21 +550,17 @@@ int avfilter_init_filter(AVFilterContex
      return ret;
  }
  
+ const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx)
+ {
+     return pads[pad_idx].name;
+ }
+ enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx)
+ {
+     return pads[pad_idx].type;
+ }
  #if FF_API_DEFAULT_CONFIG_OUTPUT_LINK
 -int avfilter_default_config_output_link(AVFilterLink *link)
 -{
 -    return 0;
 -}
  void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
                           AVFilterPad **pads, AVFilterLink ***links,
                           AVFilterPad *newpad)
@@@ -372,7 -239,10 +373,12 @@@ void avfilter_set_common_packing_format
  /**
   * 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.
   */
  struct AVFilterPad {
      /**
@@@ -618,15 -502,9 +651,18 @@@ struct AVFilterContext 
  
      void *priv;                     ///< private data for use by the filter
  
+     unsigned nb_inputs;             ///< number of input pads
+     unsigned nb_outputs;            ///< number of output pads
++
 +    struct AVFilterCommand *command_queue;
 +};
 +
 +#if FF_API_PACKING
 +enum AVFilterPacking {
 +    AVFILTER_PACKED = 0,
 +    AVFILTER_PLANAR,
  };
 +#endif
  
  /**
   * A link between two filters. This contains pointers to the source and
@@@ -259,65 -167,22 +259,65 @@@ static int insert_conv_filter(AVFilterG
  static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
  {
      int i, j, ret;
 +    char filt_args[128];
 +    AVFilterFormats *formats;
 +    AVFilterChannelLayouts *chlayouts;
 +    AVFilterFormats *samplerates;
      int scaler_count = 0, resampler_count = 0;
  
 +    for (j = 0; j < 2; j++) {
      /* ask all the sub-filters for their supported media formats */
      for (i = 0; i < graph->filter_count; i++) {
-         if (!graph->filters[i]->input_count == j)
 +        /* Call query_formats on sources first.
 +           This is a temporary workaround for amerge,
 +           until format renegociation is implemented. */
++        if (!graph->filters[i]->nb_inputs == j)
 +            continue;
          if (graph->filters[i]->filter->query_formats)
 -            graph->filters[i]->filter->query_formats(graph->filters[i]);
 +            ret = filter_query_formats(graph->filters[i]);
          else
 -            ff_default_query_formats(graph->filters[i]);
 +            ret = ff_default_query_formats(graph->filters[i]);
 +        if (ret < 0)
 +            return ret;
 +    }
      }
  
      /* go through and merge as many format lists as possible */
      for (i = 0; i < graph->filter_count; i++) {
          AVFilterContext *filter = graph->filters[i];
  
-         for (j = 0; j < filter->input_count; j++) {
+         for (j = 0; j < filter->nb_inputs; j++) {
              AVFilterLink *link = filter->inputs[j];
 +#if 0
 +            if (!link) continue;
 +
 +            if (!link->in_formats || !link->out_formats)
 +                return AVERROR(EINVAL);
 +
 +            if (link->type == AVMEDIA_TYPE_VIDEO &&
 +                !avfilter_merge_formats(link->in_formats, link->out_formats)) {
 +
 +                /* couldn't merge format lists, auto-insert scale filter */
 +                snprintf(filt_args, sizeof(filt_args), "0:0:%s",
 +                         graph->scale_sws_opts);
 +                if (ret = insert_conv_filter(graph, link, "scale", filt_args))
 +                    return ret;
 +            }
 +            else if (link->type == AVMEDIA_TYPE_AUDIO) {
 +                if (!link->in_channel_layouts || !link->out_channel_layouts)
 +                    return AVERROR(EINVAL);
 +
 +                /* Merge all three list before checking: that way, in all
 +                 * three categories, aconvert will use a common format
 +                 * whenever possible. */
 +                formats   = avfilter_merge_formats(link->in_formats,   link->out_formats);
 +                chlayouts   = ff_merge_channel_layouts(link->in_channel_layouts  , link->out_channel_layouts);
 +                samplerates = ff_merge_samplerates    (link->in_samplerates, link->out_samplerates);
 +
 +                if (!formats || !chlayouts || !samplerates)
 +                    if (ret = insert_conv_filter(graph, link, "aresample", NULL))
 +                       return ret;
 +#else
              int convert_needed = 0;
  
              if (!link)
@@@ -694,47 -549,15 +698,47 @@@ static void swap_sample_fmts(AVFilterGr
  static int pick_formats(AVFilterGraph *graph)
  {
      int i, j, ret;
-             if (filter->input_count){
-                 for (j = 0; j < filter->input_count; j++){
 +    int change;
 +
 +    do{
 +        change = 0;
 +        for (i = 0; i < graph->filter_count; i++) {
 +            AVFilterContext *filter = graph->filters[i];
-             if (filter->output_count){
-                 for (j = 0; j < filter->output_count; j++){
++            if (filter->nb_inputs){
++                for (j = 0; j < filter->nb_inputs; j++){
 +                    if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_count == 1) {
 +                        pick_format(filter->inputs[j], NULL);
 +                        change = 1;
 +                    }
 +                }
 +            }
-             if (filter->input_count && filter->output_count && filter->inputs[0]->format>=0) {
-                 for (j = 0; j < filter->output_count; j++) {
++            if (filter->nb_outputs){
++                for (j = 0; j < filter->nb_outputs; j++){
 +                    if(filter->outputs[j]->in_formats && filter->outputs[j]->in_formats->format_count == 1) {
 +                        pick_format(filter->outputs[j], NULL);
 +                        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) {
 +                        pick_format(filter->outputs[j], filter->inputs[0]);
 +                        change = 1;
 +                    }
 +                }
 +            }
 +        }
 +    }while(change);
  
      for (i = 0; i < graph->filter_count; i++) {
          AVFilterContext *filter = graph->filters[i];
  
-         for (j = 0; j < filter->input_count; j++)
+         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->output_count; j++)
+         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;
@@@ -768,48 -591,6 +772,48 @@@ static int graph_config_formats(AVFilte
      return 0;
  }
  
-         for (j = 0; j < f->input_count; j++) {
 +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->filter_count; i++) {
 +        f = graph->filters[i];
-         for (j = 0; j < f->output_count; j++) {
++        for (j = 0; j < f->nb_inputs; j++) {
 +            f->inputs[j]->graph     = graph;
 +            f->inputs[j]->age_index = -1;
 +        }
-         if (!f->output_count) {
-             if (f->input_count > INT_MAX - sink_links_count)
++        for (j = 0; j < f->nb_outputs; j++) {
 +            f->outputs[j]->graph    = graph;
 +            f->outputs[j]->age_index= -1;
 +        }
-             sink_links_count += f->input_count;
++        if (!f->nb_outputs) {
++            if (f->nb_inputs > INT_MAX - sink_links_count)
 +                return AVERROR(EINVAL);
-         if (!f->output_count) {
-             for (j = 0; j < f->input_count; j++) {
++            sink_links_count += f->nb_inputs;
 +        }
 +    }
 +    sinks = av_calloc(sink_links_count, sizeof(*sinks));
 +    if (!sinks)
 +        return AVERROR(ENOMEM);
 +    for (i = 0; i < graph->filter_count; 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;
 +}
 +
  int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
  {
      int ret;
@@@ -74,46 -70,8 +74,46 @@@ typedef struct 
          return AVERROR(EINVAL);\
      }
  
-         buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
 +static AVFilterBufferRef *copy_buffer_ref(AVFilterContext *ctx,
 +                                          AVFilterBufferRef *ref)
 +{
 +    AVFilterLink *outlink = ctx->outputs[0];
 +    AVFilterBufferRef *buf;
 +    int channels;
 +
 +    switch (outlink->type) {
 +
 +    case AVMEDIA_TYPE_VIDEO:
++        buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
 +                                        ref->video->w, ref->video->h);
 +        if(!buf)
 +            return NULL;
 +        av_image_copy(buf->data, buf->linesize,
 +                      (void*)ref->data, ref->linesize,
 +                      ref->format, ref->video->w, ref->video->h);
 +        break;
 +
 +    case AVMEDIA_TYPE_AUDIO:
 +        buf = ff_get_audio_buffer(outlink, AV_PERM_WRITE,
 +                                        ref->audio->nb_samples);
 +        if(!buf)
 +            return NULL;
 +        channels = av_get_channel_layout_nb_channels(ref->audio->channel_layout);
 +        av_samples_copy(buf->extended_data, ref->buf->extended_data,
 +                        0, 0, ref->audio->nb_samples,
 +                        channels,
 +                        ref->format);
 +        break;
 +
 +    default:
 +        return NULL;
 +    }
 +    avfilter_copy_buffer_ref_props(buf, ref);
 +    return buf;
 +}
 +
  #if FF_API_VSRC_BUFFER_ADD_FRAME
 -int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame,
 +static int av_vsrc_buffer_add_frame_alt(AVFilterContext *buffer_filter, AVFrame *frame,
                               int64_t pts, AVRational pixel_aspect)
  {
      int64_t orig_pts = frame->pts;
@@@ -280,29 -220,18 +280,41 @@@ AVFilterFormats *avfilter_make_all_form
      return ret;
  }
  
 +const int64_t avfilter_all_channel_layouts[] = {
 +#include "all_channel_layouts.inc"
 +    -1
 +};
 +
 +// AVFilterFormats *avfilter_make_all_channel_layouts(void)
 +// {
 +//     return avfilter_make_format64_list(avfilter_all_channel_layouts);
 +// }
 +
 +#if FF_API_PACKING
 +AVFilterFormats *avfilter_make_all_packing_formats(void)
 +{
 +    static const int packing[] = {
 +        AVFILTER_PACKED,
 +        AVFILTER_PLANAR,
 +        -1,
 +    };
 +
 +    return avfilter_make_format_list(packing);
 +}
 +#endif
 +
+ AVFilterFormats *ff_planar_sample_fmts(void)
+ {
+     AVFilterFormats *ret = NULL;
+     int fmt;
+     for (fmt = 0; fmt < AV_SAMPLE_FMT_NB; fmt++)
+         if (av_sample_fmt_is_planar(fmt))
+             ff_add_format(&ret, fmt);
+     return ret;
+ }
  AVFilterFormats *ff_all_samplerates(void)
  {
      AVFilterFormats *ret = av_mallocz(sizeof(*ret));
@@@ -401,14 -330,14 +413,14 @@@ void ff_formats_changeref(AVFilterForma
  {                                                                   \
      int count = 0, i;                                               \
                                                                      \
-     for (i = 0; i < ctx->input_count; i++) {                        \
+     for (i = 0; i < ctx->nb_inputs; i++) {                          \
 -        if (ctx->inputs[i]) {                                       \
 +        if (ctx->inputs[i] && !ctx->inputs[i]->out_fmts) {          \
              ref(fmts, &ctx->inputs[i]->out_fmts);                   \
              count++;                                                \
          }                                                           \
      }                                                               \
-     for (i = 0; i < ctx->output_count; i++) {                       \
+     for (i = 0; i < ctx->nb_outputs; i++) {                         \
 -        if (ctx->outputs[i]) {                                      \
 +        if (ctx->outputs[i] && !ctx->outputs[i]->in_fmts) {         \
              ref(fmts, &ctx->outputs[i]->in_fmts);                   \
              count++;                                                \
          }                                                           \
Simple merge
Simple merge
   */
  
  #include "avfilter.h"
 +#include "avfiltergraph.h"
 +#include "formats.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
+ /**
+  * A filter pad used for either input or output.
+  */
+ struct AVFilterPad {
+     /**
+      * Pad name. The name is unique among inputs and among outputs, but an
+      * input may have the same name as an output. This may be NULL if this
+      * pad has no need to ever be referenced by name.
+      */
+     const char *name;
+     /**
+      * AVFilterPad type.
+      */
+     enum AVMediaType type;
+     /**
+      * 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.
+      */
+     int min_perms;
+     /**
+      * 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.
+      */
+     int rej_perms;
+     /**
+      * Callback called before passing the first slice of a new frame. If
+      * NULL, the filter layer will default to storing a reference to the
+      * picture inside the link structure.
+      *
+      * Input video pads only.
+      */
+     void (*start_frame)(AVFilterLink *link, AVFilterBufferRef *picref);
+     /**
+      * Callback function to get a video buffer. If NULL, the filter system will
+      * use avfilter_default_get_video_buffer().
+      *
+      * Input video pads only.
+      */
+     AVFilterBufferRef *(*get_video_buffer)(AVFilterLink *link, int perms, int w, int h);
+     /**
+      * Callback function to get an audio buffer. If NULL, the filter system will
+      * use avfilter_default_get_audio_buffer().
+      *
+      * Input audio pads only.
+      */
+     AVFilterBufferRef *(*get_audio_buffer)(AVFilterLink *link, int perms,
+                                            int nb_samples);
+     /**
+      * Callback called after the slices of a frame are completely sent. If
+      * NULL, the filter layer will default to releasing the reference stored
+      * in the link structure during start_frame().
+      *
+      * Input video pads only.
+      */
+     void (*end_frame)(AVFilterLink *link);
+     /**
+      * Slice drawing callback. This is where a filter receives video data
+      * and should do its processing.
+      *
+      * Input video pads only.
+      */
+     void (*draw_slice)(AVFilterLink *link, int y, int height, int slice_dir);
+     /**
+      * Samples filtering callback. This is where a filter receives audio data
+      * and should do its processing.
+      *
+      * Input audio pads only.
+      */
+     void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
+     /**
+      * Frame poll callback. This returns the number of immediately available
+      * samples. It should return a positive value if the next request_frame()
+      * is guaranteed to return one frame (with no delay).
+      *
+      * Defaults to just calling the source poll_frame() method.
+      *
+      * Output pads only.
+      */
+     int (*poll_frame)(AVFilterLink *link);
+     /**
+      * 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.
+      *
+      * Output pads only.
+      */
+     int (*request_frame)(AVFilterLink *link);
+     /**
+      * 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
+      * 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,
+      * and another value on error.
+      */
+     int (*config_props)(AVFilterLink *link);
+ };
+ #endif
  /** default handler for freeing audio/video buffer when there are no references left */
  void ff_avfilter_default_free_buffer(AVFilterBuffer *buf);
  
Simple merge
  #include "libavutil/opt.h"
  #include "libavutil/imgutils.h"
  #include "libavformat/avformat.h"
 +#include "audio.h"
 +#include "avcodec.h"
  #include "avfilter.h"
  #include "formats.h"
+ #include "internal.h"
  #include "video.h"
  
  typedef struct {
@@@ -272,10 -238,10 +273,10 @@@ static int movie_get_frame(AVFilterLin
  
              if (frame_decoded) {
                  /* FIXME: avoid the memcpy */
-                 movie->picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE | AV_PERM_PRESERVE |
-                                                           AV_PERM_REUSE2, outlink->w, outlink->h);
+                 movie->picref = ff_get_video_buffer(outlink, AV_PERM_WRITE | AV_PERM_PRESERVE |
+                                                     AV_PERM_REUSE2, outlink->w, outlink->h);
                  av_image_copy(movie->picref->data, movie->picref->linesize,
 -                              movie->frame->data,  movie->frame->linesize,
 +                              (void*)movie->frame->data,  movie->frame->linesize,
                                movie->picref->format, outlink->w, outlink->h);
                  avfilter_copy_frame_props(movie->picref, movie->frame);
  
@@@ -29,8 -29,8 +29,8 @@@
  #include "libavutil/avutil.h"
  
  #define LIBAVFILTER_VERSION_MAJOR  2
- #define LIBAVFILTER_VERSION_MINOR 78
- #define LIBAVFILTER_VERSION_MICRO 101
 -#define LIBAVFILTER_VERSION_MINOR  23
 -#define LIBAVFILTER_VERSION_MICRO  0
++#define LIBAVFILTER_VERSION_MINOR 79
++#define LIBAVFILTER_VERSION_MICRO 100
  
  #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
                                                 LIBAVFILTER_VERSION_MINOR, \
@@@ -24,8 -24,8 +24,9 @@@
   */
  
  #include "libavutil/mathematics.h"
 +#include "libavutil/parseutils.h"
  #include "avfilter.h"
+ #include "internal.h"
  #include "video.h"
  
  typedef struct {
@@@ -28,8 -28,8 +28,9 @@@
   */
  
  #include "avfilter.h"
 +#include "internal.h"
  #include "formats.h"
+ #include "internal.h"
  #include "video.h"
  
  typedef struct {
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
   * based heavily on vf_negate.c by Bobby Bingham
   */
  
 +#include "libavutil/avstring.h"
 +#include "libavutil/eval.h"
 +#include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
  #include "avfilter.h"
 +#include "drawutils.h"
 +#include "internal.h"
  #include "formats.h"
+ #include "internal.h"
  #include "video.h"
  
 +#define R 0
 +#define G 1
 +#define B 2
 +#define A 3
 +
 +#define Y 0
 +#define U 1
 +#define V 2
 +
  typedef struct {
 +    const AVClass *class;
      int factor, fade_per_frame;
 -    unsigned int frame_index, start_frame, stop_frame;
 +    unsigned int frame_index, start_frame, stop_frame, nb_frames;
      int hsub, vsub, bpp;
 +    unsigned int black_level, black_level_scaled;
 +    uint8_t is_packed_rgb;
 +    uint8_t rgba_map[4];
 +    int alpha;
 +
 +    char *type;
  } FadeContext;
  
 +#define OFFSET(x) offsetof(FadeContext, x)
 +
 +static const AVOption fade_options[] = {
 +    { "type",        "set the fade direction",                     OFFSET(type),        AV_OPT_TYPE_STRING, {.str = "in" }, CHAR_MIN, CHAR_MAX },
 +    { "t",           "set the fade direction",                     OFFSET(type),        AV_OPT_TYPE_STRING, {.str = "in" }, CHAR_MIN, CHAR_MAX },
 +    { "start_frame", "set expression of frame to start fading",    OFFSET(start_frame), AV_OPT_TYPE_INT, {.dbl = 0    }, 0, INT_MAX },
 +    { "s",           "set expression of frame to start fading",    OFFSET(start_frame), AV_OPT_TYPE_INT, {.dbl = 0    }, 0, INT_MAX },
 +    { "nb_frames",   "set expression for fade duration in frames", OFFSET(nb_frames),   AV_OPT_TYPE_INT, {.dbl = 25   }, 0, INT_MAX },
 +    { "n",           "set expression for fade duration in frames", OFFSET(nb_frames),   AV_OPT_TYPE_INT, {.dbl = 25   }, 0, INT_MAX },
 +    { "alpha",       "fade alpha if it is available on the input", OFFSET(alpha),       AV_OPT_TYPE_INT, {.dbl = 0    }, 0,       1 },
 +    {NULL},
 +};
 +
 +static const AVClass fade_class = {
 +    "FadeContext",
 +    av_default_item_name,
 +    fade_options
 +};
 +
  static av_cold int init(AVFilterContext *ctx, const char *args, void *opaque)
  {
      FadeContext *fade = ctx->priv;
Simple merge
@@@ -25,8 -25,8 +25,9 @@@
  
  #include "libavutil/pixdesc.h"
  #include "avfilter.h"
 +#include "internal.h"
  #include "formats.h"
+ #include "internal.h"
  #include "video.h"
  
  typedef struct {
@@@ -433,8 -433,8 +434,8 @@@ static int source_config_props(AVFilter
  static int source_request_frame(AVFilterLink *outlink)
  {
      Frei0rContext *frei0r = outlink->src->priv;
-     AVFilterBufferRef *picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
+     AVFilterBufferRef *picref = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
 -    picref->video->pixel_aspect = (AVRational) {1, 1};
 +    picref->video->sample_aspect_ratio = (AVRational) {1, 1};
      picref->pts = frei0r->pts++;
      picref->pos = -1;
  
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -303,12 -205,42 +303,12 @@@ static int config_output(AVFilterLink *
  
  static AVFilterBufferRef *get_video_buffer(AVFilterLink *link, int perms, int w, int h)
  {
-     return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
+     return ff_get_video_buffer(link->dst->outputs[0], perms, w, h);
  }
  
 -static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
 -{
 -    AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0);
 -    AVFilterContext *ctx = inlink->dst;
 -    OverlayContext *over = ctx->priv;
 -
 -    inlink->dst->outputs[0]->out_buf = outpicref;
 -    outpicref->pts = av_rescale_q(outpicref->pts, ctx->inputs[MAIN]->time_base,
 -                                  ctx->outputs[0]->time_base);
 -
 -    if (!over->overpicref || over->overpicref->pts < outpicref->pts) {
 -        AVFilterBufferRef *old = over->overpicref;
 -        over->overpicref = NULL;
 -        ff_request_frame(ctx->inputs[OVERLAY]);
 -        if (over->overpicref) {
 -            if (old)
 -                avfilter_unref_buffer(old);
 -        } else
 -            over->overpicref = old;
 -    }
 -
 -    ff_start_frame(inlink->dst->outputs[0], outpicref);
 -}
 -
 -static void start_frame_overlay(AVFilterLink *inlink, AVFilterBufferRef *inpicref)
 -{
 -    AVFilterContext *ctx = inlink->dst;
 -    OverlayContext *over = ctx->priv;
 -
 -    over->overpicref = inpicref;
 -    over->overpicref->pts = av_rescale_q(inpicref->pts, ctx->inputs[OVERLAY]->time_base,
 -                                         ctx->outputs[0]->time_base);
 -}
 +// divide by 255 and round to nearest
 +// apply a fast variant: (X+127)/255 = ((X+127)*257+257)>>16 = ((X+128)*257)>>16
 +#define FAST_DIV255(x) ((((x) + 128) * 257) >> 16)
  
  static void blend_slice(AVFilterContext *ctx,
                          AVFilterBufferRef *dst, AVFilterBufferRef *src,
@@@ -218,11 -256,10 +219,11 @@@ static int config_output(AVFilterLink *
  static AVFilterBufferRef *get_video_buffer(AVFilterLink *inlink, int perms, int w, int h)
  {
      PadContext *pad = inlink->dst->priv;
 +    int align = (perms&AV_PERM_ALIGN) ? AVFILTER_ALIGN : 1;
  
-     AVFilterBufferRef *picref = avfilter_get_video_buffer(inlink->dst->outputs[0], perms,
-                                                        w + (pad->w - pad->in_w) + 4*align,
-                                                        h + (pad->h - pad->in_h));
+     AVFilterBufferRef *picref = ff_get_video_buffer(inlink->dst->outputs[0], perms,
 -                                                    w + (pad->w - pad->in_w),
++                                                    w + (pad->w - pad->in_w) + 4*align,
+                                                     h + (pad->h - pad->in_h));
      int plane;
  
      picref->video->w = w;
Simple merge
@@@ -302,7 -266,7 +303,7 @@@ static void start_frame(AVFilterLink *l
      scale->hsub = av_pix_fmt_descriptors[link->format].log2_chroma_w;
      scale->vsub = av_pix_fmt_descriptors[link->format].log2_chroma_h;
  
-     outpicref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN, outlink->w, outlink->h);
 -    outpicref = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
++    outpicref = ff_get_video_buffer(outlink, AV_PERM_WRITE|AV_PERM_ALIGN, outlink->w, outlink->h);
      avfilter_copy_buffer_ref_props(outpicref, picref);
      outpicref->video->w = outlink->w;
      outpicref->video->h = outlink->h;
Simple merge
Simple merge
@@@ -117,15 -121,15 +118,15 @@@ static void start_frame(AVFilterLink *i
  {
      AVFilterLink *outlink = inlink->dst->outputs[0];
  
-     outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
-                                                  outlink->w, outlink->h);
+     outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
+                                            outlink->w, outlink->h);
      outlink->out_buf->pts = picref->pts;
  
 -    if (picref->video->pixel_aspect.num == 0) {
 -        outlink->out_buf->video->pixel_aspect = picref->video->pixel_aspect;
 +    if (picref->video->sample_aspect_ratio.num == 0) {
 +        outlink->out_buf->video->sample_aspect_ratio = picref->video->sample_aspect_ratio;
      } else {
 -        outlink->out_buf->video->pixel_aspect.num = picref->video->pixel_aspect.den;
 -        outlink->out_buf->video->pixel_aspect.den = picref->video->pixel_aspect.num;
 +        outlink->out_buf->video->sample_aspect_ratio.num = picref->video->sample_aspect_ratio.den;
 +        outlink->out_buf->video->sample_aspect_ratio.den = picref->video->sample_aspect_ratio.num;
      }
  
      ff_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
Simple merge
Simple merge
Simple merge
  #include "internal.h"
  #include "video.h"
  
 -#ifdef DEBUG
 -static char *ff_get_ref_perms_string(char *buf, size_t buf_size, int perms)
 -{
 -    snprintf(buf, buf_size, "%s%s%s%s%s%s",
 -             perms & AV_PERM_READ      ? "r" : "",
 -             perms & AV_PERM_WRITE     ? "w" : "",
 -             perms & AV_PERM_PRESERVE  ? "p" : "",
 -             perms & AV_PERM_REUSE     ? "u" : "",
 -             perms & AV_PERM_REUSE2    ? "U" : "",
 -             perms & AV_PERM_NEG_LINESIZES ? "n" : "");
 -    return buf;
 -}
 -#endif
 -
 -static void ff_dlog_ref(void *ctx, AVFilterBufferRef *ref, int end)
 -{
 -    av_unused char buf[16];
 -    av_dlog(ctx,
 -            "ref[%p buf:%p refcount:%d perms:%s data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
 -            ref, ref->buf, ref->buf->refcount, ff_get_ref_perms_string(buf, sizeof(buf), ref->perms), ref->data[0],
 -            ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
 -            ref->pts, ref->pos);
 -
 -    if (ref->video) {
 -        av_dlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
 -                ref->video->pixel_aspect.num, ref->video->pixel_aspect.den,
 -                ref->video->w, ref->video->h,
 -                !ref->video->interlaced     ? 'P' :         /* Progressive  */
 -                ref->video->top_field_first ? 'T' : 'B',    /* Top / Bottom */
 -                ref->video->key_frame,
 -                av_get_picture_type_char(ref->video->pict_type));
 -    }
 -    if (ref->audio) {
 -        av_dlog(ctx, " cl:%"PRId64"d n:%d r:%d p:%d",
 -                ref->audio->channel_layout,
 -                ref->audio->nb_samples,
 -                ref->audio->sample_rate,
 -                ref->audio->planar);
 -    }
 -
 -    av_dlog(ctx, "]%s", end ? "\n" : "");
 -}
 -
  AVFilterBufferRef *ff_null_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
  {
-     return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
+     return ff_get_video_buffer(link->dst->outputs[0], perms, w, h);
  }
  
 -/* TODO: set the buffer's priv member to a context structure for the whole
 - * filter chain.  This will allow for a buffer pool instead of the constant
 - * alloc & free cycle currently implemented. */
  AVFilterBufferRef *ff_default_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
  {
      int linesize[4];
@@@ -191,13 -201,9 +191,13 @@@ void ff_start_frame(AVFilterLink *link
                  picref->perms,
                  link->dstpad->min_perms, link->dstpad->rej_perms);
  
-         link->cur_buf = avfilter_get_video_buffer(link, dst->min_perms, link->w, link->h);
+         link->cur_buf = ff_get_video_buffer(link, dst->min_perms, link->w, link->h);
          link->src_buf = picref;
          avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);
 +
 +        /* copy palette if required */
 +        if (av_pix_fmt_descriptors[link->format].flags & PIX_FMT_PAL)
 +            memcpy(link->cur_buf->data[1], link->src_buf-> data[1], AVPALETTE_SIZE);
      }
      else
          link->cur_buf = picref;
Simple merge
Simple merge
@@@ -105,13 -141,14 +106,13 @@@ static int color_config_props(AVFilterL
  static int color_request_frame(AVFilterLink *link)
  {
      ColorContext *color = link->src->priv;
-     AVFilterBufferRef *picref = avfilter_get_video_buffer(link, AV_PERM_WRITE, color->w, color->h);
+     AVFilterBufferRef *picref = ff_get_video_buffer(link, AV_PERM_WRITE, color->w, color->h);
 -    picref->video->pixel_aspect = (AVRational) {1, 1};
 -    picref->pts                 = color->pts++;
 -    picref->pos                 = -1;
 +    picref->video->sample_aspect_ratio = (AVRational) {1, 1};
 +    picref->pts = color->pts++;
 +    picref->pos = -1;
  
      ff_start_frame(link, avfilter_ref_buffer(picref, ~0));
 -    ff_draw_rectangle(picref->data, picref->linesize,
 -                      color->line, color->line_step, color->hsub, color->vsub,
 +    ff_fill_rectangle(&color->draw, &color->color, picref->data, picref->linesize,
                        0, 0, color->w, color->h);
      ff_draw_slice(link, 0, color->h, 1);
      ff_end_frame(link);
@@@ -135,10 -131,9 +136,9 @@@ static int request_frame(AVFilterLink *
      TestSourceContext *test = outlink->src->priv;
      AVFilterBufferRef *picref;
  
 -    if (test->max_pts >= 0 && test->pts > test->max_pts)
 +    if (test->max_pts >= 0 && test->pts >= test->max_pts)
          return AVERROR_EOF;
-     picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
-                                        test->w, test->h);
+     picref = ff_get_video_buffer(outlink, AV_PERM_WRITE, test->w, test->h);
      picref->pts = test->pts++;
      picref->pos = -1;
      picref->video->key_frame = 1;
Simple merge
@@@ -677,17 -553,16 +677,16 @@@ static void planar_rgb_to_y(uint16_t *d
      }
  }
  
- static void planar_rgb16le_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)
 -static void planar_rgb_to_uv(uint8_t *dstU, uint8_t *dstV, const uint8_t *src[4], int width)
++static void planar_rgb_to_uv(uint16_t *dstU, uint16_t *dstV, const uint8_t *src[4], int width)
  {
      int i;
-     const uint16_t **src = (const uint16_t **)_src;
-     uint16_t *dst        = (uint16_t *)_dst;
      for (i = 0; i < width; i++) {
-         int g = AV_RL16(src[0] + i);
-         int b = AV_RL16(src[1] + i);
-         int r = AV_RL16(src[2] + i);
+         int g = src[0][i];
+         int b = src[1][i];
+         int r = src[2][i];
  
-         dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
 -        dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
 -        dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT;
++        dstU[i] = (RU*r + GU*g + BU*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
++        dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
      }
  }
  
diff --cc tests/Makefile
@@@ -148,7 -126,7 +148,7 @@@ fate-list
  clean:: testclean
  
  testclean:
-       $(RM) -r tests/vsynth1 tests/vsynth2 tests/data tools/lavfi-showfiltfmts$(EXESUF)
 -      $(RM) -r tests/vsynth1 tests/data
++      $(RM) -r tests/vsynth1 tests/data tools/lavfi-showfiltfmts$(EXESUF)
        $(RM) $(CLEANSUFFIXES:%=tests/%)
        $(RM) $(TESTTOOLS:%=tests/%$(HOSTEXESUF))