sigrid/ffmpeg

.gitignore+0−1

@@ -50,7 +50,6 @@ tests/rotozoom · 49 unmodified lines
50	tests/tiny_psnr	50	tests/tiny_psnr
51	tests/videogen	51	tests/videogen
52	tests/vsynth1	52	tests/vsynth1
53	tests/vsynth2
54	tools/aviocat	53	tools/aviocat
55	tools/cws2fws	54	tools/cws2fws
56	tools/ffeval	55	tools/ffeval

Changelog+1−0

@@ -5,6 +5,7 @@ version next: · 4 unmodified lines
5	- INI and flat output in ffprobe	5	- INI and flat output in ffprobe
6	- Scene detection in libavfilter	6	- Scene detection in libavfilter
7	- Indeo Audio decoder	7	- Indeo Audio decoder
		8	- channelsplit audio filter
8		9
9		10
10	version 0.11:	11	version 0.11:

configure+3−2

     inet_aton
     inline_asm
     isatty
+    jack_port_get_latency_range
     kbhit
     ldbrx
     libdc1394_1
 # libraries
 avdevice_deps="avcodec avformat"
-avfilter_deps="swscale"
 avformat_deps="avcodec"
 postproc_deps="gpl"
 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 && 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

doc/APIchanges+9−0

@@ -38,6 +38,15 @@ API changes, most recent first: · 37 unmodified lines
38	2012-03-26 - a67d9cf - lavfi 2.66.100	38	2012-03-26 - a67d9cf - lavfi 2.66.100
39	Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.	39	Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
40		40
		41	2012-xx-xx - xxxxxxx - lavfi 2.23.0 - avfilter.h
		42	Add AVFilterContext.nb_inputs/outputs. Deprecate
		43	AVFilterContext.input/output_count.
		44
		45	2012-xx-xx - xxxxxxx - lavfi 2.22.0 - avfilter.h
		46	Add avfilter_pad_get_type() and avfilter_pad_get_name(). Those
		47	should now be used instead of accessing AVFilterPad members
		48	directly.
		49
41	2012-xx-xx - xxxxxxx - lavu 51.32.0 - audioconvert.h	50	2012-xx-xx - xxxxxxx - lavu 51.32.0 - audioconvert.h
42	Add av_get_channel_layout_channel_index(), av_get_channel_name()	51	Add av_get_channel_layout_channel_index(), av_get_channel_name()
43	and av_channel_layout_extract_channel().	52	and av_channel_layout_extract_channel().

doc/filters.texi+25−0

@@ -576,6 +576,31 @@ Maximum compensation in samples per second. · 575 unmodified lines
576		576
577	@end table	577	@end table
578		578
		579	@section channelsplit
		580	Split each channel in input audio stream into a separate output stream.
		581
		582	This filter accepts the following named parameters:
		583	@table @option
		584	@item channel_layout
		585	Channel layout of the input stream. Default is "stereo".
		586	@end table
		587
		588	For example, assuming a stereo input MP3 file
		589	@example
		590	ffmpeg -i in.mp3 -filter_complex channelsplit out.mkv
		591	@end example
		592	will create an output Matroska file with two audio streams, one containing only
		593	the left channel and the other the right channel.
		594
		595	To split a 5.1 WAV file into per-channel files
		596	@example
		597	ffmpeg -i in.wav -filter_complex
		598	'channelsplit=channel_layout=5.1[FL][FR][FC][LFE][SL][SR]'
		599	-map '[FL]' front_left.wav -map '[FR]' front_right.wav -map '[FC]'
		600	front_center.wav -map '[LFE]' lfe.wav -map '[SL]' side_left.wav -map '[SR]'
		601	side_right.wav
		602	@end example
		603
579	@section resample	604	@section resample
580	Convert the audio sample format, sample rate and channel layout. This filter is	605	Convert the audio sample format, sample rate and channel layout. This filter is
581	not meant to be used directly.	606	not meant to be used directly.

doc/protocols.texi+3−0

@@ -228,6 +228,9 @@ Additionally, the following parameters can be set via command line options · 227 unmodified lines
228	Name of application to connect on the RTMP server. This option	228	Name of application to connect on the RTMP server. This option
229	overrides the parameter specified in the URI.	229	overrides the parameter specified in the URI.
230		230
		231	@item rtmp_buffer
		232	Set the client buffer time in milliseconds. The default is 3000.
		233
231	@item rtmp_conn	234	@item rtmp_conn
232	Extra arbitrary AMF connection parameters, parsed from a string,	235	Extra arbitrary AMF connection parameters, parsed from a string,
233	e.g. like @code{B:1 S:authMe O:1 NN:code:1.23 NS:flag:ok O:0}.	236	e.g. like @code{B:1 S:authMe O:1 NN:code:1.23 NS:flag:ok O:0}.

ffmpeg.c+8−6

 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
 {
     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
                                                                    \
     avio_printf(pb, "%s", ctx->filter->name);                      \
     if (nb_pads > 1)                                               \
-        avio_printf(pb, ":%s", pads[inout->pad_idx].name);         \
+        avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
     avio_w8(pb, 0);                                                \
     avio_close_dyn_buf(pb, &f->name);                              \
 }
     av_freep(&ofilter->name);
     DESCRIBE_FILTER_LINK(ofilter, out, 0);
-    switch (out->filter_ctx->output_pads[out->pad_idx].type) {
+    switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
     case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
     case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
     default: av_assert0(0);
     av_freep(&ifilter->name);
     DESCRIBE_FILTER_LINK(ifilter, in, 1);
-    switch (in->filter_ctx->input_pads[in->pad_idx].type) {
+    switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
     case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
     case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
     default: av_assert0(0);
 {
     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, -1); break;
     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
     default:
             if (!ofilter->out_tmp || ofilter->out_tmp->name)
                 continue;
-            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:    o->video_disable    = 1; break;
             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;

libavcodec/ppc/h264_altivec.c+2−2

libavcodec/ppc/h264_altivec_template.crenamed from libavcodec/ppc/h264_template_altivec.c+0−0

File renamed without changes.

libavcodec/ppc/vc1dsp_altivec.c+2−2

@@ -325,13 +325,13 @@ static void vc1_inv_trans_8x4_altivec(uint8_t dest, int stride, DCTELEM block) · 324 unmodified lines
325		325
326	#define OP_U8_ALTIVEC PUT_OP_U8_ALTIVEC	326	#define OP_U8_ALTIVEC PUT_OP_U8_ALTIVEC
327	#define PREFIX_no_rnd_vc1_chroma_mc8_altivec put_no_rnd_vc1_chroma_mc8_altivec	327	#define PREFIX_no_rnd_vc1_chroma_mc8_altivec put_no_rnd_vc1_chroma_mc8_altivec
328	#include "h264_template_altivec.c"	328	#include "h264_altivec_template.c"
329	#undef OP_U8_ALTIVEC	329	#undef OP_U8_ALTIVEC
330	#undef PREFIX_no_rnd_vc1_chroma_mc8_altivec	330	#undef PREFIX_no_rnd_vc1_chroma_mc8_altivec
331		331
332	#define OP_U8_ALTIVEC AVG_OP_U8_ALTIVEC	332	#define OP_U8_ALTIVEC AVG_OP_U8_ALTIVEC
333	#define PREFIX_no_rnd_vc1_chroma_mc8_altivec avg_no_rnd_vc1_chroma_mc8_altivec	333	#define PREFIX_no_rnd_vc1_chroma_mc8_altivec avg_no_rnd_vc1_chroma_mc8_altivec
334	#include "h264_template_altivec.c"	334	#include "h264_altivec_template.c"
335	#undef OP_U8_ALTIVEC	335	#undef OP_U8_ALTIVEC
336	#undef PREFIX_no_rnd_vc1_chroma_mc8_altivec	336	#undef PREFIX_no_rnd_vc1_chroma_mc8_altivec
337		337

libavcodec/v210dec.h+1−0

@@ -22,6 +22,7 @@ · 21 unmodified lines
22	#include "libavutil/log.h"	22	#include "libavutil/log.h"
23	#include "libavutil/opt.h"	23	#include "libavutil/opt.h"
24		24
		25
25	typedef struct {	26	typedef struct {
26	AVClass *av_class;	27	AVClass *av_class;
27	int custom_stride;	28	int custom_stride;

libavdevice/jack_audio.c+6−0

     /* Copy and interleave audio data from the JACK buffer into the packet */
     for (i = 0; i < self->nports; i++) {
+    #if HAVE_JACK_PORT_GET_LATENCY_RANGE
+        jack_latency_range_t range;
+        jack_port_get_latency_range(self->ports[i], JackCaptureLatency, &range);
+        latency += range.max;
+    #else
         latency += jack_port_get_total_latency(self->client, self->ports[i]);
+    #endif
         buffer = jack_port_get_buffer(self->ports[i], self->buffer_size);
         for (j = 0; j < self->buffer_size; j++)
             pkt_data[j * self->nports + i] = buffer[j];

libavfilter/Makefile+4−1

 include $(SUBDIR)../config.mak
 NAME = avfilter
-FFLIBS = avutil swscale
+FFLIBS = avutil
 FFLIBS-$(CONFIG_ASYNCTS_FILTER) += avresample
 FFLIBS-$(CONFIG_RESAMPLE_FILTER) += avresample
+FFLIBS-$(CONFIG_SCALE_FILTER)   += swscale
 FFLIBS-$(CONFIG_ACONVERT_FILTER)             += swresample
 FFLIBS-$(CONFIG_AMOVIE_FILTER)               += avformat avcodec
 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_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

libavfilter/af_amerge.c+1−1

@@ -118,7 +118,7 @@ static int query_formats(AVFilterContext *ctx) · 117 unmodified lines
118	if ((inlayout[i] >> c) & 1)	118	if ((inlayout[i] >> c) & 1)
119	*(route[i]++) = out_ch_number++;	119	*(route[i]++) = out_ch_number++;
120	}	120	}
121	formats = avfilter_make_format_list(ff_packed_sample_fmts);	121	formats = avfilter_make_format_list(ff_packed_sample_fmts_array);
122	avfilter_set_common_sample_formats(ctx, formats);	122	avfilter_set_common_sample_formats(ctx, formats);
123	for (i = 0; i < am->nb_inputs; i++) {	123	for (i = 0; i < am->nb_inputs; i++) {
124	layouts = NULL;	124	layouts = NULL;

libavfilter/af_amix.c+3−3

@@ -454,10 +454,10 @@ static void filter_samples(AVFilterLink inlink, AVFilterBufferRef buf) · 453 unmodified lines
454	AVFilterLink *outlink = ctx->outputs[0];	454	AVFilterLink *outlink = ctx->outputs[0];
455	int i;	455	int i;
456		456
457	for (i = 0; i < ctx->input_count; i++)	457	for (i = 0; i < ctx->nb_inputs; i++)
458	if (ctx->inputs[i] == inlink)	458	if (ctx->inputs[i] == inlink)
459	break;	459	break;
460	if (i >= ctx->input_count) {	460	if (i >= ctx->nb_inputs) {
461	av_log(ctx, AV_LOG_ERROR, "unknown input link\n");	461	av_log(ctx, AV_LOG_ERROR, "unknown input link\n");
462	return;	462	return;
463	}	463	}
@@ -518,7 +518,7 @@ static void uninit(AVFilterContext *ctx) · 54 unmodified lines
518	av_freep(&s->input_state);	518	av_freep(&s->input_state);
519	av_freep(&s->input_scale);	519	av_freep(&s->input_scale);
520		520
521	for (i = 0; i < ctx->input_count; i++)	521	for (i = 0; i < ctx->nb_inputs; i++)
522	av_freep(&ctx->input_pads[i].name);	522	av_freep(&ctx->input_pads[i].name);
523	}	523	}
524		524

libavfilter/af_anull.c+1−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24		24
25	#include "audio.h"	25	#include "audio.h"
26	#include "avfilter.h"	26	#include "avfilter.h"
		27	#include "internal.h"
27		28
28	AVFilter avfilter_af_anull = {	29	AVFilter avfilter_af_anull = {
29	.name = "anull",	30	.name = "anull",

libavfilter/af_channelsplit.c+146−0

@@ -0,0 +1,146 @@
	1	/*
	2	* This file is part of Libav.
	3	*
	4	* Libav is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Lesser General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2.1 of the License, or (at your option) any later version.
	8	*
	9	* Libav is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Lesser General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU Lesser General Public
	15	* License along with Libav; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	/**
	20	* @file
	21	* Channel split filter
	22	*
	23	* Split an audio stream into per-channel streams.
	24	*/
	25
	26	#include "libavutil/audioconvert.h"
	27	#include "libavutil/opt.h"
	28
	29	#include "audio.h"
	30	#include "avfilter.h"
	31	#include "formats.h"
	32	#include "internal.h"
	33
	34	typedef struct ChannelSplitContext {
	35	const AVClass *class;
	36
	37	uint64_t channel_layout;
	38	char *channel_layout_str;
	39	} ChannelSplitContext;
	40
	41	#define OFFSET(x) offsetof(ChannelSplitContext, x)
	42	#define A AV_OPT_FLAG_AUDIO_PARAM
	43	static const AVOption options[] = {
	44	{ "channel_layout", "Input channel layout.", OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, { .str = "stereo" }, .flags = A },
	45	{ NULL },
	46	};
	47
	48	static const AVClass channelsplit_class = {
	49	.class_name = "channelsplit filter",
	50	.item_name = av_default_item_name,
	51	.option = options,
	52	.version = LIBAVUTIL_VERSION_INT,
	53	};
	54
	55	static int init(AVFilterContext ctx, const char arg, void *opaque)
	56	{
	57	ChannelSplitContext *s = ctx->priv;
	58	int nb_channels;
	59	int ret = 0, i;
	60
	61	s->class = &channelsplit_class;
	62	av_opt_set_defaults(s);
	63	if ((ret = av_set_options_string(s, arg, "=", ":")) < 0) {
	64	av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", arg);
	65	return ret;
	66	}
	67	if (!(s->channel_layout = av_get_channel_layout(s->channel_layout_str))) {
	68	av_log(ctx, AV_LOG_ERROR, "Error parsing channel layout '%s'.\n",
	69	s->channel_layout_str);
	70	ret = AVERROR(EINVAL);
	71	goto fail;
	72	}
	73
	74	nb_channels = av_get_channel_layout_nb_channels(s->channel_layout);
	75	for (i = 0; i < nb_channels; i++) {
	76	uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, i);
	77	AVFilterPad pad = { 0 };
	78
	79	pad.type = AVMEDIA_TYPE_AUDIO;
	80	pad.name = av_get_channel_name(channel);
	81
	82	ff_insert_outpad(ctx, i, &pad);
	83	}
	84
	85	fail:
	86	av_opt_free(s);
	87	return ret;
	88	}
	89
	90	static int query_formats(AVFilterContext *ctx)
	91	{
	92	ChannelSplitContext *s = ctx->priv;
	93	AVFilterChannelLayouts *in_layouts = NULL;
	94	int i;
	95
	96	ff_set_common_formats (ctx, ff_planar_sample_fmts());
	97	ff_set_common_samplerates(ctx, ff_all_samplerates());
	98
	99	ff_add_channel_layout(&in_layouts, s->channel_layout);
	100	ff_channel_layouts_ref(in_layouts, &ctx->inputs[0]->out_channel_layouts);
	101
	102	for (i = 0; i < ctx->nb_outputs; i++) {
	103	AVFilterChannelLayouts *out_layouts = NULL;
	104	uint64_t channel = av_channel_layout_extract_channel(s->channel_layout, i);
	105
	106	ff_add_channel_layout(&out_layouts, channel);
	107	ff_channel_layouts_ref(out_layouts, &ctx->outputs[i]->in_channel_layouts);
	108	}
	109
	110	return 0;
	111	}
	112
	113	static void filter_samples(AVFilterLink inlink, AVFilterBufferRef buf)
	114	{
	115	AVFilterContext *ctx = inlink->dst;
	116	int i;
	117
	118	for (i = 0; i < ctx->nb_outputs; i++) {
	119	AVFilterBufferRef *buf_out = avfilter_ref_buffer(buf, ~AV_PERM_WRITE);
	120
	121	if (!buf_out)
	122	return;
	123
	124	buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];
	125	buf_out->audio->channel_layout =
	126	av_channel_layout_extract_channel(buf->audio->channel_layout, i);
	127
	128	ff_filter_samples(ctx->outputs[i], buf_out);
	129	}
	130	avfilter_unref_buffer(buf);
	131	}
	132
	133	AVFilter avfilter_af_channelsplit = {
	134	.name = "channelsplit",
	135	.description = NULL_IF_CONFIG_SMALL("Split audio into per-channel streams"),
	136	.priv_size = sizeof(ChannelSplitContext),
	137
	138	.init = init,
	139	.query_formats = query_formats,
	140
	141	.inputs = (const AVFilterPad[]){{ .name = "default",
	142	.type = AVMEDIA_TYPE_AUDIO,
	143	.filter_samples = filter_samples, },
	144	{ NULL }},
	145	.outputs = (const AVFilterPad[]){{ NULL }},
	146	};

libavfilter/allfilters.c+2−4

     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 (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);
         extern AVFilter avfilter_asink_abuffer;
         avfilter_register(&avfilter_asink_abuffer);
     }
-    {
-        extern AVFilter avfilter_vf_scale;
-        avfilter_register(&avfilter_vf_scale);
-    }
 }

libavfilter/asink_anullsink.c+1−0

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	*/	19	*/
20		20
21	#include "avfilter.h"	21	#include "avfilter.h"
		22	#include "internal.h"
22		23
23	static void null_filter_samples(AVFilterLink link, AVFilterBufferRef samplesref) { }	24	static void null_filter_samples(AVFilterLink link, AVFilterBufferRef samplesref) { }
24		25

libavfilter/asrc_anullsrc.c+1−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	* null audio source	24	* null audio source
25	*/	25	*/
26		26
		27	#include "internal.h"
27	#include "libavutil/audioconvert.h"	28	#include "libavutil/audioconvert.h"
28	#include "libavutil/opt.h"	29	#include "libavutil/opt.h"
29		30

libavfilter/audio.c+6−12

 {
     AVFilterLink *outlink = NULL;
-    if (inlink->dst->output_count)
+    if (inlink->dst->nb_outputs)
         outlink = inlink->dst->outputs[0];
     if (outlink) {
     /* 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 size;
-        int planes = !planar ? 1:
-                     av_get_channel_layout_nb_channels(samplesref->audio->channel_layout);
         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);
         link->cur_buf->audio->sample_rate = samplesref->audio->sample_rate;
         /* Copy actual data into new samples buffer */
-        /* src can be larger than dst if it was allocated larger than necessary.
+        av_samples_copy(link->cur_buf->extended_data, samplesref->extended_data,
-           dst can be slightly larger due to extra alignment padding. */
+                        0, 0, samplesref->audio->nb_samples,
-        size = FFMIN(samplesref->linesize[0], link->cur_buf->linesize[0]);
+                        av_get_channel_layout_nb_channels(link->channel_layout),
-        for (i = 0; samplesref->data[i] && i < 8; i++)
+                        link->format);
-            memcpy(link->cur_buf->data[i], samplesref->data[i], size);
-        for (i = 0; i < planes; i++)
-            memcpy(link->cur_buf->extended_data[i], samplesref->extended_data[i], size);
         avfilter_unref_buffer(samplesref);
     } else

libavfilter/audio.h+2−2

@@ -24,7 +24,7 @@ · 23 unmodified lines
24		24
25	#include "avfilter.h"	25	#include "avfilter.h"
26		26
27	static const enum AVSampleFormat ff_packed_sample_fmts[] = {	27	static const enum AVSampleFormat ff_packed_sample_fmts_array[] = {
28	AV_SAMPLE_FMT_U8,	28	AV_SAMPLE_FMT_U8,
29	AV_SAMPLE_FMT_S16,	29	AV_SAMPLE_FMT_S16,
30	AV_SAMPLE_FMT_S32,	30	AV_SAMPLE_FMT_S32,
@@ -33,7 +33,7 @@ static const enum AVSampleFormat ff_packed_sample_fmts[] = { · 2 unmodified lines
33	AV_SAMPLE_FMT_NONE	33	AV_SAMPLE_FMT_NONE
34	};	34	};
35		35
36	static const enum AVSampleFormat ff_planar_sample_fmts[] = {	36	static const enum AVSampleFormat ff_planar_sample_fmts_array[] = {
37	AV_SAMPLE_FMT_U8P,	37	AV_SAMPLE_FMT_U8P,
38	AV_SAMPLE_FMT_S16P,	38	AV_SAMPLE_FMT_S16P,
39	AV_SAMPLE_FMT_S32P,	39	AV_SAMPLE_FMT_S32P,

libavfilter/avfilter.c+42−22

 {
     AVFilterLink *link;
-    if (src->output_count <= srcpad || dst->input_count <= dstpad ||
+    if (src->nb_outputs <= srcpad || dst->nb_inputs <= dstpad ||
-        src->outputs[srcpad]        || dst->inputs[dstpad])
+        src->outputs[srcpad]      || dst->inputs[dstpad])
         return -1;
     if (src->output_pads[srcpad].type != dst->input_pads[dstpad].type) {
     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;
                 return ret;
             if (!(config_link = link->srcpad->config_props)) {
-                if (link->src->input_count != 1) {
+                if (link->src->nb_inputs != 1) {
                     av_log(link->src, AV_LOG_ERROR, "Source filters and filters "
                                                     "with more than one input "
                                                     "must set config_props() "
     if (link->srcpad->poll_frame)
         return link->srcpad->poll_frame(link);
-    for (i = 0; i < link->src->input_count; i++) {
+    for (i = 0; i < link->src->nb_inputs; i++) {
         int val;
         if (!link->src->inputs[i])
             return -1;
             goto err;
     }
-    ret->input_count  = pad_count(filter->inputs);
+    ret->nb_inputs = pad_count(filter->inputs);
-    if (ret->input_count) {
+    if (ret->nb_inputs ) {
-        ret->input_pads   = av_malloc(sizeof(AVFilterPad) * ret->input_count);
+        ret->input_pads   = av_malloc(sizeof(AVFilterPad) * ret->nb_inputs);
         if (!ret->input_pads)
             goto err;
-        memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->input_count);
+        memcpy(ret->input_pads, filter->inputs, sizeof(AVFilterPad) * ret->nb_inputs);
-        ret->inputs       = av_mallocz(sizeof(AVFilterLink*) * ret->input_count);
+        ret->inputs       = av_mallocz(sizeof(AVFilterLink*) * ret->nb_inputs);
         if (!ret->inputs)
             goto err;
     }
-    ret->output_count = pad_count(filter->outputs);
+    ret->nb_outputs = pad_count(filter->outputs);
-    if (ret->output_count) {
+    if (ret->nb_outputs) {
-        ret->output_pads  = av_malloc(sizeof(AVFilterPad) * ret->output_count);
+        ret->output_pads  = av_malloc(sizeof(AVFilterPad) * ret->nb_outputs);
         if (!ret->output_pads)
             goto err;
-        memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->output_count);
+        memcpy(ret->output_pads, filter->outputs, sizeof(AVFilterPad) * ret->nb_outputs);
-        ret->outputs      = av_mallocz(sizeof(AVFilterLink*) * ret->output_count);
+        ret->outputs      = av_mallocz(sizeof(AVFilterLink*) * ret->nb_outputs);
         if (!ret->outputs)
             goto err;
     }
+#if FF_API_FOO_COUNT
+    ret->output_count = ret->nb_outputs;
+    ret->input_count  = ret->nb_inputs;
+#endif
     *filter_ctx = ret;
     return 0;
 err:
     av_freep(&ret->inputs);
     av_freep(&ret->input_pads);
-    ret->input_count = 0;
+    ret->nb_inputs = 0;
     av_freep(&ret->outputs);
     av_freep(&ret->output_pads);
-    ret->output_count = 0;
+    ret->nb_outputs = 0;
     av_freep(&ret->priv);
     av_free(ret);
     return AVERROR(ENOMEM);
     if (filter->filter->uninit)
         filter->filter->uninit(filter);
-    for (i = 0; i < filter->input_count; i++) {
+    for (i = 0; i < filter->nb_inputs; i++) {
         if ((link = filter->inputs[i])) {
             if (link->src)
                 link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
         }
         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;
     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
 void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
                          AVFilterPad **pads, AVFilterLink ***links,
 void avfilter_insert_inpad(AVFilterContext *f, unsigned index,
                            AVFilterPad *p)
 {
-    ff_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad),
+    ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad),
                   &f->input_pads, &f->inputs, p);
+#if FF_API_FOO_COUNT
+    f->input_count = f->nb_inputs;
+#endif
 }
 void avfilter_insert_outpad(AVFilterContext *f, unsigned index,
                             AVFilterPad *p)
 {
-    ff_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad),
+    ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad),
                   &f->output_pads, &f->outputs, p);
+#if FF_API_FOO_COUNT
+    f->output_count = f->nb_outputs;
+#endif
 }
 int avfilter_poll_frame(AVFilterLink *link)
 {

libavfilter/avfilter.h+41−13

  */
 #endif
+#if FF_API_AVFILTERPAD_PUBLIC
 /**
  * A filter pad used for either input or output.
  *
  * 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 {
     /**
      */
     int (*config_props)(AVFilterLink *link);
 };
+#endif
+/**
+ * Get the name of an AVFilterPad.
+ *
+ * @param pads an array of AVFilterPads
+ * @param pad_idx index of the pad in the array it; is the caller's
+ *                responsibility to ensure the index is valid
+ *
+ * @return name of the pad_idx'th pad in pads
+ */
+const char *avfilter_pad_get_name(AVFilterPad *pads, int pad_idx);
+/**
+ * Get the type of an AVFilterPad.
+ *
+ * @param pads an array of AVFilterPads
+ * @param pad_idx index of the pad in the array; it is the caller's
+ *                responsibility to ensure the index is valid
+ *
+ * @return type of the pad_idx'th pad in pads
+ */
+enum AVMediaType avfilter_pad_get_type(AVFilterPad *pads, int pad_idx);
 #if FF_API_FILTERS_PUBLIC
 /** default handler for start_frame() for video inputs */
     char *name;                     ///< name of this filter instance
-    unsigned input_count;           ///< number of input pads
+#if FF_API_FOO_COUNT
+    unsigned input_count;           ///< @deprecated use nb_inputs
+#endif
     AVFilterPad   *input_pads;      ///< array of input pads
     AVFilterLink **inputs;          ///< array of pointers to input links
-    unsigned output_count;          ///< number of output pads
+#if FF_API_FOO_COUNT
+    unsigned output_count;          ///< @deprecated use nb_outputs
+#endif
     AVFilterPad   *output_pads;     ///< array of output pads
     AVFilterLink **outputs;         ///< array of pointers to output links
     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;
 };
  */
 int avfilter_config_links(AVFilterContext *filter);
-/**
+#if FF_API_FILTERS_PUBLIC
- * Request a picture buffer with a specific set of permissions.
+attribute_deprecated
- *
- * @param link  the output link to the filter from which the buffer will
- *              be requested
- * @param perms the required access permissions
- * @param w     the minimum width of the buffer to allocate
- * @param h     the minimum height of the buffer to allocate
- * @return      A reference to the buffer. This must be unreferenced with
- *              avfilter_unref_buffer when you are finished with it.
- */
 AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms,
                                           int w, int h);
+#endif
 /**
  * Create a buffer reference wrapped around an already allocated image

libavfilter/avfiltergraph.c+39−35

     for (i = 0; i < graph->filter_count; i++) {
         filt = graph->filters[i];
-        for (j = 0; j < filt->input_count; j++) {
+        for (j = 0; j < filt->nb_inputs; j++) {
             if (!filt->inputs[j] || !filt->inputs[j]->src) {
                 av_log(log_ctx, AV_LOG_ERROR,
                        "Input pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any source\n",
             }
         }
-        for (j = 0; j < filt->output_count; j++) {
+        for (j = 0; j < filt->nb_outputs; j++) {
             if (!filt->outputs[j] || !filt->outputs[j]->dst) {
                 av_log(log_ctx, AV_LOG_ERROR,
                        "Output pad \"%s\" for the filter \"%s\" of type \"%s\" not connected to any destination\n",
     for (i=0; i < graph->filter_count; i++) {
         filt = graph->filters[i];
-        if (!filt->output_count) {
+        if (!filt->nb_outputs) {
             if ((ret = avfilter_config_links(filt)))
                 return ret;
         }
         /* Call query_formats on sources first.
            This is a temporary workaround for amerge,
            until format renegociation is implemented. */
-        if (!graph->filters[i]->input_count == j)
+        if (!graph->filters[i]->nb_inputs == j)
             continue;
         if (graph->filters[i]->filter->query_formats)
             ret = filter_query_formats(graph->filters[i]);
     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;
                 /* couldn't merge format lists. auto-insert conversion filter */
                 switch (link->type) {
                 case AVMEDIA_TYPE_VIDEO:
+                    if (!(filter = avfilter_get_by_name("scale"))) {
+                        av_log(log_ctx, AV_LOG_ERROR, "'scale' filter "
+                               "not present, cannot convert pixel formats.\n");
+                        return AVERROR(EINVAL);
+                    }
                     snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",
                              scaler_count++);
                     snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts);
-                    if ((ret = avfilter_graph_create_filter(&convert,
+                    if ((ret = avfilter_graph_create_filter(&convert, filter,
-                                                            avfilter_get_by_name("scale"),
                                                             inst_name, scale_args, NULL,
                                                             graph)) < 0)
                         return ret;
                     snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",
                              resampler_count++);
-                    if ((ret = avfilter_graph_create_filter(&convert,
+                    if ((ret = avfilter_graph_create_filter(&convert, filter,
-                                                            avfilter_get_by_name("aresample"),
                                                             inst_name, NULL, NULL, graph)) < 0)
                         return ret;
                     break;
 #define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
 do {                                                                   \
-    for (i = 0; i < filter->input_count; i++) {                        \
+    for (i = 0; i < filter->nb_inputs; i++) {                          \
         AVFilterLink *link = filter->inputs[i];                        \
         fmt_type fmt;                                                  \
                                                                        \
             continue;                                                  \
         fmt = link->out_ ## list->var[0];                              \
                                                                        \
-        for (j = 0; j < filter->output_count; j++) {                   \
+        for (j = 0; j < filter->nb_outputs; j++) {                     \
             AVFilterLink *out_link = filter->outputs[j];               \
             list_type *fmts;                                           \
                                                                        \
     int sample_rate;
     int i, j;
-    for (i = 0; i < filter->input_count; i++) {
+    for (i = 0; i < filter->nb_inputs; i++) {
         link = filter->inputs[i];
         if (link->type == AVMEDIA_TYPE_AUDIO &&
             link->out_samplerates->format_count == 1)
             break;
     }
-    if (i == filter->input_count)
+    if (i == filter->nb_inputs)
         return;
     sample_rate = link->out_samplerates->formats[0];
-    for (i = 0; i < filter->output_count; i++) {
+    for (i = 0; i < filter->nb_outputs; i++) {
         AVFilterLink *outlink = filter->outputs[i];
         int best_idx, best_diff = INT_MAX;
     uint64_t chlayout;
     int i, j;
-    for (i = 0; i < filter->input_count; i++) {
+    for (i = 0; i < filter->nb_inputs; i++) {
         link = filter->inputs[i];
         if (link->type == AVMEDIA_TYPE_AUDIO &&
             link->out_channel_layouts->nb_channel_layouts == 1)
             break;
     }
-    if (i == filter->input_count)
+    if (i == filter->nb_inputs)
         return;
     chlayout = link->out_channel_layouts->channel_layouts[0];
-    for (i = 0; i < filter->output_count; i++) {
+    for (i = 0; i < filter->nb_outputs; i++) {
         AVFilterLink *outlink = filter->outputs[i];
         int best_idx, best_score = INT_MIN;
     int format, bps;
     int i, j;
-    for (i = 0; i < filter->input_count; i++) {
+    for (i = 0; i < filter->nb_inputs; i++) {
         link = filter->inputs[i];
         if (link->type == AVMEDIA_TYPE_AUDIO &&
             link->out_formats->format_count == 1)
             break;
     }
-    if (i == filter->input_count)
+    if (i == filter->nb_inputs)
         return;
     format = link->out_formats->formats[0];
     bps    = av_get_bytes_per_sample(format);
-    for (i = 0; i < filter->output_count; i++) {
+    for (i = 0; i < filter->nb_outputs; i++) {
         AVFilterLink *outlink = filter->outputs[i];
         int best_idx, best_score = INT_MIN;
         change = 0;
         for (i = 0; i < graph->filter_count; i++) {
             AVFilterContext *filter = graph->filters[i];
-            if (filter->input_count){
+            if (filter->nb_inputs){
-                for (j = 0; j < filter->input_count; j++){
+                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->output_count){
+            if (filter->nb_outputs){
-                for (j = 0; j < filter->output_count; j++){
+                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->input_count && filter->output_count && filter->inputs[0]->format>=0) {
+            if (filter->nb_inputs && filter->nb_outputs && filter->inputs[0]->format>=0) {
-                for (j = 0; j < filter->output_count; j++) {
+                for (j = 0; j < filter->nb_outputs; j++) {
                     if(filter->outputs[j]->format<0) {
                         pick_format(filter->outputs[j], filter->inputs[0]);
                         change = 1;
     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], 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], NULL)) < 0)
                 return ret;
     }
     for (i = 0; i < graph->filter_count; i++) {
         f = graph->filters[i];
-        for (j = 0; j < f->input_count; j++) {
+        for (j = 0; j < f->nb_inputs; j++) {
             f->inputs[j]->graph     = graph;
             f->inputs[j]->age_index = -1;
         }
-        for (j = 0; j < f->output_count; j++) {
+        for (j = 0; j < f->nb_outputs; j++) {
             f->outputs[j]->graph    = graph;
             f->outputs[j]->age_index= -1;
         }
-        if (!f->output_count) {
+        if (!f->nb_outputs) {
-            if (f->input_count > INT_MAX - sink_links_count)
+            if (f->nb_inputs > INT_MAX - sink_links_count)
                 return AVERROR(EINVAL);
-            sink_links_count += f->input_count;
+            sink_links_count += f->nb_inputs;
         }
     }
     sinks = av_calloc(sink_links_count, sizeof(*sinks));
         return AVERROR(ENOMEM);
     for (i = 0; i < graph->filter_count; i++) {
         f = graph->filters[i];
-        if (!f->output_count) {
+        if (!f->nb_outputs) {
-            for (j = 0; j < f->input_count; j++) {
+            for (j = 0; j < f->nb_inputs; j++) {
                 sinks[n] = f->inputs[j];
                 f->inputs[j]->age_index = n++;
             }

libavfilter/buffersrc.c+1−1

@@ -84,7 +84,7 @@ static AVFilterBufferRef copy_buffer_ref(AVFilterContext ctx, · 83 unmodified lines
84	switch (outlink->type) {	84	switch (outlink->type) {
85		85
86	case AVMEDIA_TYPE_VIDEO:	86	case AVMEDIA_TYPE_VIDEO:
87	buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,	87	buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
88	ref->video->w, ref->video->h);	88	ref->video->w, ref->video->h);
89	if(!buf)	89	if(!buf)
90	return NULL;	90	return NULL;

libavfilter/formats.c+14−2

 }
 #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));
 {                                                                   \
     int count = 0, i;                                               \
                                                                     \
-    for (i = 0; i < ctx->input_count; i++) {                        \
+    for (i = 0; i < ctx->nb_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] && !ctx->outputs[i]->in_fmts) {         \
             ref(fmts, &ctx->outputs[i]->in_fmts);                   \
             count++;                                                \

libavfilter/formats.h+5−0

  */
 AVFilterFormats *ff_all_formats(enum AVMediaType type);
+/**
+ * Construct a formats list containing all planar sample formats.
+ */
+AVFilterFormats *ff_planar_sample_fmts(void);
 /**
  * Return a format list which contains the intersection of the formats of
  * a and b. Also, all the references of a, all the references of b, and

libavfilter/graphparser.c+2−2

@@ -226,7 +226,7 @@ static int link_filter_inouts(AVFilterContext *filt_ctx, · 225 unmodified lines
226	{	226	{
227	int pad, ret;	227	int pad, ret;
228		228
229	for (pad = 0; pad < filt_ctx->input_count; pad++) {	229	for (pad = 0; pad < filt_ctx->nb_inputs; pad++) {
230	AVFilterInOut p = curr_inputs;	230	AVFilterInOut p = curr_inputs;
231		231
232	if (p) {	232	if (p) {
@@ -254,7 +254,7 @@ static int link_filter_inouts(AVFilterContext *filt_ctx, · 21 unmodified lines
254	return AVERROR(EINVAL);	254	return AVERROR(EINVAL);
255	}	255	}
256		256
257	pad = filt_ctx->output_count;	257	pad = filt_ctx->nb_outputs;
258	while (pad--) {	258	while (pad--) {
259	AVFilterInOut *currlinkn = av_mallocz(sizeof(AVFilterInOut));	259	AVFilterInOut *currlinkn = av_mallocz(sizeof(AVFilterInOut));
260	if (!currlinkn)	260	if (!currlinkn)

libavfilter/internal.h+134−2

@@ -50,6 +50,132 @@ typedef struct AVFilterCommand { · 49 unmodified lines
50	*/	50	*/
51	void ff_avfilter_graph_update_heap(AVFilterGraph graph, AVFilterLink link);	51	void ff_avfilter_graph_update_heap(AVFilterGraph graph, AVFilterLink link);
52		52
		53	#if !FF_API_AVFILTERPAD_PUBLIC
		54	/**
		55	* A filter pad used for either input or output.
		56	*/
		57	struct AVFilterPad {
		58	/**
		59	* Pad name. The name is unique among inputs and among outputs, but an
		60	* input may have the same name as an output. This may be NULL if this
		61	* pad has no need to ever be referenced by name.
		62	*/
		63	const char *name;
		64
		65	/**
		66	* AVFilterPad type.
		67	*/
		68	enum AVMediaType type;
		69
		70	/**
		71	* Minimum required permissions on incoming buffers. Any buffer with
		72	* insufficient permissions will be automatically copied by the filter
		73	* system to a new buffer which provides the needed access permissions.
		74	*
		75	* Input pads only.
		76	*/
		77	int min_perms;
		78
		79	/**
		80	* Permissions which are not accepted on incoming buffers. Any buffer
		81	* which has any of these permissions set will be automatically copied
		82	* by the filter system to a new buffer which does not have those
		83	* permissions. This can be used to easily disallow buffers with
		84	* AV_PERM_REUSE.
		85	*
		86	* Input pads only.
		87	*/
		88	int rej_perms;
		89
		90	/**
		91	* Callback called before passing the first slice of a new frame. If
		92	* NULL, the filter layer will default to storing a reference to the
		93	* picture inside the link structure.
		94	*
		95	* Input video pads only.
		96	*/
		97	void (start_frame)(AVFilterLink link, AVFilterBufferRef *picref);
		98
		99	/**
		100	* Callback function to get a video buffer. If NULL, the filter system will
		101	* use avfilter_default_get_video_buffer().
		102	*
		103	* Input video pads only.
		104	*/
		105	AVFilterBufferRef (get_video_buffer)(AVFilterLink *link, int perms, int w, int h);
		106
		107	/**
		108	* Callback function to get an audio buffer. If NULL, the filter system will
		109	* use avfilter_default_get_audio_buffer().
		110	*
		111	* Input audio pads only.
		112	*/
		113	AVFilterBufferRef (get_audio_buffer)(AVFilterLink *link, int perms,
		114	int nb_samples);
		115
		116	/**
		117	* Callback called after the slices of a frame are completely sent. If
		118	* NULL, the filter layer will default to releasing the reference stored
		119	* in the link structure during start_frame().
		120	*
		121	* Input video pads only.
		122	*/
		123	void (end_frame)(AVFilterLink link);
		124
		125	/**
		126	* Slice drawing callback. This is where a filter receives video data
		127	* and should do its processing.
		128	*
		129	* Input video pads only.
		130	*/
		131	void (draw_slice)(AVFilterLink link, int y, int height, int slice_dir);
		132
		133	/**
		134	* Samples filtering callback. This is where a filter receives audio data
		135	* and should do its processing.
		136	*
		137	* Input audio pads only.
		138	*/
		139	void (filter_samples)(AVFilterLink link, AVFilterBufferRef *samplesref);
		140
		141	/**
		142	* Frame poll callback. This returns the number of immediately available
		143	* samples. It should return a positive value if the next request_frame()
		144	* is guaranteed to return one frame (with no delay).
		145	*
		146	* Defaults to just calling the source poll_frame() method.
		147	*
		148	* Output pads only.
		149	*/
		150	int (poll_frame)(AVFilterLink link);
		151
		152	/**
		153	* Frame request callback. A call to this should result in at least one
		154	* frame being output over the given link. This should return zero on
		155	* success, and another value on error.
		156	*
		157	* Output pads only.
		158	*/
		159	int (request_frame)(AVFilterLink link);
		160
		161	/**
		162	* Link configuration callback.
		163	*
		164	* For output pads, this should set the link properties such as
		165	* width/height. This should NOT set the format property - that is
		166	* negotiated between filters by the filter system using the
		167	* query_formats() callback before this function is called.
		168	*
		169	* For input pads, this should check the properties of the link, and update
		170	* the filter's internal state as necessary.
		171	*
		172	* For both input and output filters, this should return zero on success,
		173	* and another value on error.
		174	*/
		175	int (config_props)(AVFilterLink link);
		176	};
		177	#endif
		178
53	/** default handler for freeing audio/video buffer when there are no references left */	179	/** default handler for freeing audio/video buffer when there are no references left */
54	void ff_avfilter_default_free_buffer(AVFilterBuffer *buf);	180	void ff_avfilter_default_free_buffer(AVFilterBuffer *buf);
55		181
@@ -165,16 +291,22 @@ void ff_insert_pad(unsigned idx, unsigned *count, size_t padidx_off, · 109 unmodified lines
165	static inline void ff_insert_inpad(AVFilterContext *f, unsigned index,	291	static inline void ff_insert_inpad(AVFilterContext *f, unsigned index,
166	AVFilterPad *p)	292	AVFilterPad *p)
167	{	293	{
168	ff_insert_pad(index, &f->input_count, offsetof(AVFilterLink, dstpad),	294	ff_insert_pad(index, &f->nb_inputs, offsetof(AVFilterLink, dstpad),
169	&f->input_pads, &f->inputs, p);	295	&f->input_pads, &f->inputs, p);
		296	#if FF_API_FOO_COUNT
		297	f->input_count = f->nb_inputs;
		298	#endif
170	}	299	}
171		300
172	/** Insert a new output pad for the filter. */	301	/** Insert a new output pad for the filter. */
173	static inline void ff_insert_outpad(AVFilterContext *f, unsigned index,	302	static inline void ff_insert_outpad(AVFilterContext *f, unsigned index,
174	AVFilterPad *p)	303	AVFilterPad *p)
175	{	304	{
176	ff_insert_pad(index, &f->output_count, offsetof(AVFilterLink, srcpad),	305	ff_insert_pad(index, &f->nb_outputs, offsetof(AVFilterLink, srcpad),
177	&f->output_pads, &f->outputs, p);	306	&f->output_pads, &f->outputs, p);
		307	#if FF_API_FOO_COUNT
		308	f->output_count = f->nb_outputs;
		309	#endif
178	}	310	}
179		311
180	/**	312	/**

libavfilter/split.c+5−5

@@ -59,7 +59,7 @@ static void split_uninit(AVFilterContext *ctx) · 58 unmodified lines
59	{	59	{
60	int i;	60	int i;
61		61
62	for (i = 0; i < ctx->output_count; i++)	62	for (i = 0; i < ctx->nb_outputs; i++)
63	av_freep(&ctx->output_pads[i].name);	63	av_freep(&ctx->output_pads[i].name);
64	}	64	}
65		65
@@ -68,7 +68,7 @@ static void start_frame(AVFilterLink inlink, AVFilterBufferRef picref) · 2 unmodified lines
68	AVFilterContext *ctx = inlink->dst;	68	AVFilterContext *ctx = inlink->dst;
69	int i;	69	int i;
70		70
71	for (i = 0; i < ctx->output_count; i++)	71	for (i = 0; i < ctx->nb_outputs; i++)
72	ff_start_frame(ctx->outputs[i],	72	ff_start_frame(ctx->outputs[i],
73	avfilter_ref_buffer(picref, ~AV_PERM_WRITE));	73	avfilter_ref_buffer(picref, ~AV_PERM_WRITE));
74	}	74	}
@@ -78,7 +78,7 @@ static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir) · 3 unmodified lines
78	AVFilterContext *ctx = inlink->dst;	78	AVFilterContext *ctx = inlink->dst;
79	int i;	79	int i;
80		80
81	for (i = 0; i < ctx->output_count; i++)	81	for (i = 0; i < ctx->nb_outputs; i++)
82	ff_draw_slice(ctx->outputs[i], y, h, slice_dir);	82	ff_draw_slice(ctx->outputs[i], y, h, slice_dir);
83	}	83	}
84		84
@@ -87,7 +87,7 @@ static void end_frame(AVFilterLink *inlink) · 2 unmodified lines
87	AVFilterContext *ctx = inlink->dst;	87	AVFilterContext *ctx = inlink->dst;
88	int i;	88	int i;
89		89
90	for (i = 0; i < ctx->output_count; i++)	90	for (i = 0; i < ctx->nb_outputs; i++)
91	ff_end_frame(ctx->outputs[i]);	91	ff_end_frame(ctx->outputs[i]);
92		92
93	avfilter_unref_buffer(inlink->cur_buf);	93	avfilter_unref_buffer(inlink->cur_buf);
@@ -115,7 +115,7 @@ static void filter_samples(AVFilterLink inlink, AVFilterBufferRef samplesref) · 21 unmodified lines
115	AVFilterContext *ctx = inlink->dst;	115	AVFilterContext *ctx = inlink->dst;
116	int i;	116	int i;
117		117
118	for (i = 0; i < ctx->output_count; i++)	118	for (i = 0; i < ctx->nb_outputs; i++)
119	ff_filter_samples(inlink->dst->outputs[i],	119	ff_filter_samples(inlink->dst->outputs[i],
120	avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));	120	avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));
121	}	121	}

libavfilter/src_movie.c+3−2

 #include "avcodec.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 typedef struct {
             if (frame_decoded) {
                 /* FIXME: avoid the memcpy */
-                movie->picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE | AV_PERM_PRESERVE |
+                movie->picref = ff_get_video_buffer(outlink, AV_PERM_WRITE | AV_PERM_PRESERVE |
-                                                          AV_PERM_REUSE2, outlink->w, outlink->h);
+                                                    AV_PERM_REUSE2, outlink->w, outlink->h);
                 av_image_copy(movie->picref->data, movie->picref->linesize,
                               (void*)movie->frame->data,  movie->frame->linesize,
                               movie->picref->format, outlink->w, outlink->h);

libavfilter/version.h+8−2

 #include "libavutil/avutil.h"
 #define LIBAVFILTER_VERSION_MAJOR  2
-#define LIBAVFILTER_VERSION_MINOR 78
+#define LIBAVFILTER_VERSION_MINOR 79
-#define LIBAVFILTER_VERSION_MICRO 101
+#define LIBAVFILTER_VERSION_MICRO 100
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
                                                LIBAVFILTER_VERSION_MINOR, \
 #ifndef FF_API_FILTERS_PUBLIC
 #define FF_API_FILTERS_PUBLIC               (LIBAVFILTER_VERSION_MAJOR < 3)
 #endif
+#ifndef FF_API_AVFILTERPAD_PUBLIC
+#define FF_API_AVFILTERPAD_PUBLIC           (LIBAVFILTER_VERSION_MAJOR < 4)
+#endif
+#ifndef FF_API_FOO_COUNT
+#define FF_API_FOO_COUNT                    (LIBAVFILTER_VERSION_MAJOR < 4)
+#endif
 #endif // AVFILTER_VERSION_H

libavfilter/vf_aspect.c+1−0

@@ -26,6 +26,7 @@ · 25 unmodified lines
26	#include "libavutil/mathematics.h"	26	#include "libavutil/mathematics.h"
27	#include "libavutil/parseutils.h"	27	#include "libavutil/parseutils.h"
28	#include "avfilter.h"	28	#include "avfilter.h"
		29	#include "internal.h"
29	#include "video.h"	30	#include "video.h"
30		31
31	typedef struct {	32	typedef struct {

libavfilter/vf_blackframe.c+1−0

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	#include "avfilter.h"	30	#include "avfilter.h"
31	#include "internal.h"	31	#include "internal.h"
32	#include "formats.h"	32	#include "formats.h"
		33	#include "internal.h"
33	#include "video.h"	34	#include "video.h"
34		35
35	typedef struct {	36	typedef struct {

libavfilter/vf_boxblur.c+1−0

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	#include "libavutil/pixdesc.h"	30	#include "libavutil/pixdesc.h"
31	#include "avfilter.h"	31	#include "avfilter.h"
32	#include "formats.h"	32	#include "formats.h"
		33	#include "internal.h"
33	#include "video.h"	34	#include "video.h"
34		35
35	static const char *const var_names[] = {	36	static const char *const var_names[] = {

libavfilter/vf_copy.c+1−0

@@ -22,6 +22,7 @@ · 21 unmodified lines
22	*/	22	*/
23		23
24	#include "avfilter.h"	24	#include "avfilter.h"
		25	#include "internal.h"
25	#include "video.h"	26	#include "video.h"
26		27
27	AVFilter avfilter_vf_copy = {	28	AVFilter avfilter_vf_copy = {

libavfilter/vf_crop.c+1−0

@@ -27,6 +27,7 @@ · 26 unmodified lines
27		27
28	#include "avfilter.h"	28	#include "avfilter.h"
29	#include "formats.h"	29	#include "formats.h"
		30	#include "internal.h"
30	#include "video.h"	31	#include "video.h"
31	#include "libavutil/eval.h"	32	#include "libavutil/eval.h"
32	#include "libavutil/avstring.h"	33	#include "libavutil/avstring.h"

libavfilter/vf_cropdetect.c+1−0

@@ -26,6 +26,7 @@ · 25 unmodified lines
26	#include "libavutil/imgutils.h"	26	#include "libavutil/imgutils.h"
27	#include "avfilter.h"	27	#include "avfilter.h"
28	#include "formats.h"	28	#include "formats.h"
		29	#include "internal.h"
29	#include "video.h"	30	#include "video.h"
30		31
31	typedef struct {	32	typedef struct {

libavfilter/vf_delogo.c+3−2

 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 /**
     AVFilterBufferRef *outpicref;
     if (inpicref->perms & AV_PERM_PRESERVE) {
-        outpicref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
+        outpicref = ff_get_video_buffer(outlink, AV_PERM_WRITE,
-                                              outlink->w, outlink->h);
+                                        outlink->w, outlink->h);
         avfilter_copy_buffer_ref_props(outpicref, inpicref);
         outpicref->video->w = outlink->w;
         outpicref->video->h = outlink->h;

libavfilter/vf_drawbox.c+1−0

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include "libavutil/parseutils.h"	29	#include "libavutil/parseutils.h"
30	#include "avfilter.h"	30	#include "avfilter.h"
31	#include "formats.h"	31	#include "formats.h"
		32	#include "internal.h"
32	#include "video.h"	33	#include "video.h"
33		34
34	enum { Y, U, V, A };	35	enum { Y, U, V, A };

libavfilter/vf_drawtext.c+1−0

@@ -42,6 +42,7 @@ · 41 unmodified lines
42	#include "avfilter.h"	42	#include "avfilter.h"
43	#include "drawutils.h"	43	#include "drawutils.h"
44	#include "formats.h"	44	#include "formats.h"
		45	#include "internal.h"
45	#include "video.h"	46	#include "video.h"
46		47
47	#undef time	48	#undef time

libavfilter/vf_fade.c+1−0

@@ -33,6 +33,7 @@ · 32 unmodified lines
33	#include "drawutils.h"	33	#include "drawutils.h"
34	#include "internal.h"	34	#include "internal.h"
35	#include "formats.h"	35	#include "formats.h"
		36	#include "internal.h"
36	#include "video.h"	37	#include "video.h"
37		38
38	#define R 0	39	#define R 0

libavfilter/vf_fieldorder.c+2−1

 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 typedef struct
     AVFilterContext   *ctx        = inlink->dst;
     AVFilterLink      *outlink    = ctx->outputs[0];
-    return avfilter_get_video_buffer(outlink, perms, w, h);
+    return ff_get_video_buffer(outlink, perms, w, h);
 }
 static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref)

libavfilter/vf_format.c+1−0

@@ -27,6 +27,7 @@ · 26 unmodified lines
27	#include "avfilter.h"	27	#include "avfilter.h"
28	#include "internal.h"	28	#include "internal.h"
29	#include "formats.h"	29	#include "formats.h"
		30	#include "internal.h"
30	#include "video.h"	31	#include "video.h"
31		32
32	typedef struct {	33	typedef struct {

libavfilter/vf_frei0r.c+2−1

 #include "libavutil/parseutils.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 typedef f0r_instance_t (*f0r_construct_f)(unsigned int width, unsigned int height);
 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->sample_aspect_ratio = (AVRational) {1, 1};
     picref->pts = frei0r->pts++;
     picref->pos = -1;

libavfilter/vf_gradfun.c+2−1

 #include "avfilter.h"
 #include "formats.h"
 #include "gradfun.h"
+#include "internal.h"
 #include "video.h"
 DECLARE_ALIGNED(16, static const uint16_t, dither)[8][8] = {
     AVFilterBufferRef *outpicref;
     if (inpicref->perms & AV_PERM_PRESERVE) {
-        outpicref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
+        outpicref = ff_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
         avfilter_copy_buffer_ref_props(outpicref, inpicref);
         outpicref->video->w = outlink->w;
         outpicref->video->h = outlink->h;

libavfilter/vf_hflip.c+1−0

@@ -26,6 +26,7 @@ · 25 unmodified lines
26		26
27	#include "avfilter.h"	27	#include "avfilter.h"
28	#include "formats.h"	28	#include "formats.h"
		29	#include "internal.h"
29	#include "video.h"	30	#include "video.h"
30	#include "libavutil/pixdesc.h"	31	#include "libavutil/pixdesc.h"
31	#include "libavutil/intreadwrite.h"	32	#include "libavutil/intreadwrite.h"

libavfilter/vf_hqdn3d.c+1−0

@@ -28,6 +28,7 @@ · 27 unmodified lines
28	#include "libavutil/pixdesc.h"	28	#include "libavutil/pixdesc.h"
29	#include "avfilter.h"	29	#include "avfilter.h"
30	#include "formats.h"	30	#include "formats.h"
		31	#include "internal.h"
31	#include "video.h"	32	#include "video.h"
32		33
33	typedef struct {	34	typedef struct {

libavfilter/vf_null.c+1−0

@@ -22,6 +22,7 @@ · 21 unmodified lines
22	*/	22	*/
23		23
24	#include "avfilter.h"	24	#include "avfilter.h"
		25	#include "internal.h"
25	#include "video.h"	26	#include "video.h"
26		27
27	AVFilter avfilter_vf_null = {	28	AVFilter avfilter_vf_null = {

libavfilter/vf_overlay.c+1−1

@@ -303,7 +303,7 @@ static int config_output(AVFilterLink *outlink) · 302 unmodified lines
303		303
304	static AVFilterBufferRef get_video_buffer(AVFilterLink link, int perms, int w, int h)	304	static AVFilterBufferRef get_video_buffer(AVFilterLink link, int perms, int w, int h)
305	{	305	{
306	return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);	306	return ff_get_video_buffer(link->dst->outputs[0], perms, w, h);
307	}	307	}
308		308
309	// divide by 255 and round to nearest	309	// divide by 255 and round to nearest

libavfilter/vf_pad.c+7−6

 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 #include "libavutil/avstring.h"
 #include "libavutil/eval.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,
+    AVFilterBufferRef *picref = ff_get_video_buffer(inlink->dst->outputs[0], perms,
-                                                       w + (pad->w - pad->in_w) + 4*align,
+                                                    w + (pad->w - pad->in_w) + 4*align,
-                                                       h + (pad->h - pad->in_h));
+                                                    h + (pad->h - pad->in_h));
     int plane;
     picref->video->w = w;
     if(pad->needs_copy){
         av_log(inlink->dst, AV_LOG_DEBUG, "Direct padding impossible allocating new frame\n");
         avfilter_unref_buffer(outpicref);
-        outpicref = avfilter_get_video_buffer(inlink->dst->outputs[0], AV_PERM_WRITE | AV_PERM_NEG_LINESIZES,
+        outpicref = ff_get_video_buffer(inlink->dst->outputs[0], AV_PERM_WRITE | AV_PERM_NEG_LINESIZES,
-                                                       FFMAX(inlink->w, pad->w),
+                                        FFMAX(inlink->w, pad->w),
-                                                       FFMAX(inlink->h, pad->h));
+                                        FFMAX(inlink->h, pad->h));
         avfilter_copy_buffer_ref_props(outpicref, inpicref);
     }

libavfilter/vf_pixdesctest.c+3−2

 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "internal.h"
 #include "video.h"
 typedef struct {
     AVFilterBufferRef *outpicref;
     int i;
-    outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
+    outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
-                                                outlink->w, outlink->h);
+                                           outlink->w, outlink->h);
     outpicref = outlink->out_buf;
     avfilter_copy_buffer_ref_props(outpicref, picref);

libavfilter/vf_scale.c+2−1

 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 #include "libavutil/avstring.h"
 #include "libavutil/eval.h"
     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|AV_PERM_ALIGN, outlink->w, outlink->h);
     avfilter_copy_buffer_ref_props(outpicref, picref);
     outpicref->video->w = outlink->w;
     outpicref->video->h = outlink->h;

libavfilter/vf_setpts.c+1−0

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include "libavutil/eval.h"	29	#include "libavutil/eval.h"
30	#include "libavutil/mathematics.h"	30	#include "libavutil/mathematics.h"
31	#include "avfilter.h"	31	#include "avfilter.h"
		32	#include "internal.h"
32	#include "video.h"	33	#include "video.h"
33		34
34	static const char *const var_names[] = {	35	static const char *const var_names[] = {

libavfilter/vf_slicify.c+1−0

@@ -24,6 +24,7 @@ · 23 unmodified lines
24	*/	24	*/
25		25
26	#include "avfilter.h"	26	#include "avfilter.h"
		27	#include "internal.h"
27	#include "video.h"	28	#include "video.h"
28	#include "libavutil/pixdesc.h"	29	#include "libavutil/pixdesc.h"
29		30

libavfilter/vf_transpose.c+3−2

 #include "libavutil/imgutils.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 typedef struct {
 {
     AVFilterLink *outlink = inlink->dst->outputs[0];
-    outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
+    outlink->out_buf = ff_get_video_buffer(outlink, AV_PERM_WRITE,
-                                                 outlink->w, outlink->h);
+                                           outlink->w, outlink->h);
     outlink->out_buf->pts = picref->pts;
     if (picref->video->sample_aspect_ratio.num == 0) {

libavfilter/vf_unsharp.c+1−0

@@ -38,6 +38,7 @@ · 37 unmodified lines
38		38
39	#include "avfilter.h"	39	#include "avfilter.h"
40	#include "formats.h"	40	#include "formats.h"
		41	#include "internal.h"
41	#include "video.h"	42	#include "video.h"
42	#include "libavutil/common.h"	43	#include "libavutil/common.h"
43	#include "libavutil/mem.h"	44	#include "libavutil/mem.h"

libavfilter/vf_vflip.c+2−1

 #include "libavutil/pixdesc.h"
 #include "avfilter.h"
+#include "internal.h"
 #include "video.h"
 typedef struct {
     if (!(perms & AV_PERM_NEG_LINESIZES))
         return ff_default_get_video_buffer(link, perms, w, h);
-    picref = avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
+    picref = ff_get_video_buffer(link->dst->outputs[0], perms, w, h);
     for (i = 0; i < 4; i ++) {
         int vsub = i == 1 || i == 2 ? flip->vsub : 0;

libavfilter/vf_yadif.c+4−4

@@ -207,8 +207,8 @@ static void return_frame(AVFilterContext *ctx, int is_second) · 206 unmodified lines
207	}	207	}
208		208
209	if (is_second) {	209	if (is_second) {
210	yadif->out = avfilter_get_video_buffer(link, AV_PERM_WRITE \| AV_PERM_PRESERVE \|	210	yadif->out = ff_get_video_buffer(link, AV_PERM_WRITE \| AV_PERM_PRESERVE \|
211	AV_PERM_REUSE, link->w, link->h);	211	AV_PERM_REUSE, link->w, link->h);
212	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);	212	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);
213	yadif->out->video->interlaced = 0;	213	yadif->out->video->interlaced = 0;
214	}	214	}
@@ -269,8 +269,8 @@ static void start_frame(AVFilterLink link, AVFilterBufferRef picref) · 54 unmodified lines
269	if (!yadif->prev)	269	if (!yadif->prev)
270	yadif->prev = avfilter_ref_buffer(yadif->cur, AV_PERM_READ);	270	yadif->prev = avfilter_ref_buffer(yadif->cur, AV_PERM_READ);
271		271
272	yadif->out = avfilter_get_video_buffer(ctx->outputs[0], AV_PERM_WRITE \| AV_PERM_PRESERVE \|	272	yadif->out = ff_get_video_buffer(ctx->outputs[0], AV_PERM_WRITE \| AV_PERM_PRESERVE \|
273	AV_PERM_REUSE, link->w, link->h);	273	AV_PERM_REUSE, link->w, link->h);
274		274
275	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);	275	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);
276	yadif->out->video->interlaced = 0;	276	yadif->out->video->interlaced = 0;

libavfilter/video.c+11−7

 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);
 }
 AVFilterBufferRef *ff_default_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
     return NULL;
 }
-AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
+AVFilterBufferRef *ff_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
 {
     AVFilterBufferRef *ret = NULL;
 {
     AVFilterLink *outlink = NULL;
-    if (inlink->dst->output_count)
+    if (inlink->dst->nb_outputs)
         outlink = inlink->dst->outputs[0];
     if (outlink) {
-        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);
         avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
         ff_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
     }
                 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);
 {
     AVFilterLink *outlink = NULL;
-    if (inlink->dst->output_count)
+    if (inlink->dst->nb_outputs)
         outlink = inlink->dst->outputs[0];
     avfilter_unref_buffer(inlink->cur_buf);
 {
     AVFilterLink *outlink = NULL;
-    if (inlink->dst->output_count)
+    if (inlink->dst->nb_outputs)
         outlink = inlink->dst->outputs[0];
     if (outlink)
 {
     ff_draw_slice(link, y, h, slice_dir);
 }
+AVFilterBufferRef *avfilter_get_video_buffer(AVFilterLink *link, int perms, int w, int h)
+{
+    return ff_get_video_buffer(link, perms, w, h);
+}
 #endif

libavfilter/video.h+13−0

@@ -28,6 +28,19 @@ AVFilterBufferRef ff_default_get_video_buffer(AVFilterLink link, · 27 unmodified lines
28	int perms, int w, int h);	28	int perms, int w, int h);
29	AVFilterBufferRef ff_null_get_video_buffer(AVFilterLink link, int perms, int w, int h);	29	AVFilterBufferRef ff_null_get_video_buffer(AVFilterLink link, int perms, int w, int h);
30		30
		31	/**
		32	* Request a picture buffer with a specific set of permissions.
		33	*
		34	* @param link the output link to the filter from which the buffer will
		35	* be requested
		36	* @param perms the required access permissions
		37	* @param w the minimum width of the buffer to allocate
		38	* @param h the minimum height of the buffer to allocate
		39	* @return A reference to the buffer. This must be unreferenced with
		40	* avfilter_unref_buffer when you are finished with it.
		41	*/
		42	AVFilterBufferRef ff_get_video_buffer(AVFilterLink link, int perms,
		43	int w, int h);
31		44
32	void ff_null_start_frame(AVFilterLink link, AVFilterBufferRef picref);	45	void ff_null_start_frame(AVFilterLink link, AVFilterBufferRef picref);
33	void ff_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);	46	void ff_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir);

libavfilter/vsink_nullsink.c+1−0

@@ -17,6 +17,7 @@ · 16 unmodified lines
17	*/	17	*/
18		18
19	#include "avfilter.h"	19	#include "avfilter.h"
		20	#include "internal.h"
20		21
21	static void start_frame(AVFilterLink link, AVFilterBufferRef picref)	22	static void start_frame(AVFilterLink link, AVFilterBufferRef picref)
22	{	23	{

libavfilter/vsrc_color.c+2−1

 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 #include "libavutil/pixdesc.h"
 #include "libavutil/colorspace.h"
 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->sample_aspect_ratio = (AVRational) {1, 1};
     picref->pts = color->pts++;
     picref->pos = -1;

libavfilter/vsrc_testsrc.c+2−2

 #include "libavutil/parseutils.h"
 #include "avfilter.h"
 #include "formats.h"
+#include "internal.h"
 #include "video.h"
 typedef struct {
     if (test->max_pts >= 0 && test->pts >= test->max_pts)
         return AVERROR_EOF;
-    picref = avfilter_get_video_buffer(outlink, AV_PERM_WRITE,
+    picref = ff_get_video_buffer(outlink, AV_PERM_WRITE, test->w, test->h);
-                                       test->w, test->h);
     picref->pts = test->pts++;
     picref->pos = -1;
     picref->video->key_frame = 1;

libavformat/rtmpproto.c+62−24

     char*         tcurl;                      ///< url of the target stream
     char*         flashver;                   ///< version of the flash plugin
     char*         swfurl;                     ///< url of the swf player
+    int           server_bw;                  ///< server bandwidth
+    int           client_buffer_time;         ///< client buffer time in ms
 } RTMPContext;
 #define PLAYER_KEY_OPEN_PART_LEN 30   ///< length of partial key used for first client digest signing
 static int rtmp_write_amf_data(URLContext *s, char *param, uint8_t **p)
 {
-    char *field, *value, *saveptr;
+    char *field, *value;
     char type;
     /* The type must be B for Boolean, N for number, S for string, O for
         value = param + 2;
     } else if (param[0] == 'N' && param[1] && param[2] == ':') {
         type = param[1];
-        field = av_strtok(param + 3, ":", &saveptr);
+        field = param + 3;
-        value = av_strtok(NULL, ":", &saveptr);
+        value = strchr(field, ':');
+        if (!value)
+            goto fail;
+        *value = '\0';
+        value++;
         if (!field || !value)
             goto fail;
     ff_amf_write_object_end(&p);
     if (rt->conn) {
-        char *param, *saveptr;
+        char *param = rt->conn;
         // Write arbitrary AMF data to the Connect message.
-        param = av_strtok(rt->conn, " ", &saveptr);
         while (param != NULL) {
+            char *sep;
+            param += strspn(param, " ");
+            if (!*param)
+                break;
+            sep = strchr(param, ' ');
+            if (sep)
+                *sep = '\0';
             if ((ret = rtmp_write_amf_data(s, param, &p)) < 0) {
                 // Invalid AMF parameter.
                 ff_rtmp_packet_destroy(&pkt);
                 return ret;
             }
-            param = av_strtok(NULL, " ", &saveptr);
+            if (sep)
+                param = sep + 1;
+            else
+                break;
         }
     }
     return ret;
 }
+/**
+ * Generate client buffer time and send it to the server.
+ */
+static int gen_buffer_time(URLContext *s, RTMPContext *rt)
+{
+    RTMPPacket pkt;
+    uint8_t *p;
+    int ret;
+    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
+                                     1, 10)) < 0)
+        return ret;
+    p = pkt.data;
+    bytestream_put_be16(&p, 3);
+    bytestream_put_be32(&p, rt->main_channel_id);
+    bytestream_put_be32(&p, rt->client_buffer_time);
+    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
+                               rt->prev_pkt[1]);
+    ff_rtmp_packet_destroy(&pkt);
+    return ret;
+}
 /**
  * Generate 'play' call and send it to the server, then ping the server
  * to start actual playing.
                                rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
-    if (ret < 0)
-        return ret;
-    // set client buffer time disguised in ping packet
-    if ((ret = ff_rtmp_packet_create(&pkt, RTMP_NETWORK_CHANNEL, RTMP_PT_PING,
-                                     1, 10)) < 0)
-        return ret;
-    p = pkt.data;
-    bytestream_put_be16(&p, 3);
-    bytestream_put_be32(&p, 1);
-    bytestream_put_be32(&p, 256); //TODO: what is a good value here?
-    ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
-                               rt->prev_pkt[1]);
-    ff_rtmp_packet_destroy(&pkt);
     return ret;
 }
         return ret;
     p = pkt.data;
-    bytestream_put_be32(&p, 2500000);
+    bytestream_put_be32(&p, rt->server_bw);
     ret = ff_rtmp_packet_write(rt->stream, &pkt, rt->chunk_size,
                                rt->prev_pkt[1]);
     ff_rtmp_packet_destroy(&pkt);
         av_log(s, AV_LOG_DEBUG, "Client bandwidth = %d\n", AV_RB32(pkt->data));
         rt->client_report_size = AV_RB32(pkt->data) >> 1;
         break;
+    case RTMP_PT_SERVER_BW:
+        rt->server_bw = AV_RB32(pkt->data);
+        if (rt->server_bw <= 0) {
+            av_log(s, AV_LOG_ERROR, "Incorrect server bandwidth %d\n", rt->server_bw);
+            return AVERROR(EINVAL);
+        }
+        av_log(s, AV_LOG_DEBUG, "Server bandwidth = %d\n", rt->server_bw);
+        break;
     case RTMP_PT_INVOKE:
         //TODO: check for the messages sent for wrong state?
         if (!memcmp(pkt->data, "\002\000\006_error", 9)) {
                 if (rt->is_input) {
                     if ((ret = gen_play(s, rt)) < 0)
                         return ret;
+                    if ((ret = gen_buffer_time(s, rt)) < 0)
+                        return ret;
                 } else {
                     if ((ret = gen_publish(s, rt)) < 0)
                         return ret;
                 return ret;
         }
         break;
+    default:
+        av_log(s, AV_LOG_VERBOSE, "Unknown packet type received 0x%02X\n", pkt->type);
+        break;
     }
     return 0;
 }
     rt->client_report_size = 1048576;
     rt->bytes_read = 0;
     rt->last_bytes_read = 0;
+    rt->server_bw = 2500000;
     av_log(s, AV_LOG_DEBUG, "Proto = %s, path = %s, app = %s, fname = %s\n",
            proto, path, rt->app, rt->playpath);
 static const AVOption rtmp_options[] = {
     {"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
+    {"rtmp_buffer", "Set buffer time in milliseconds. The default is 3000.", OFFSET(client_buffer_time), AV_OPT_TYPE_INT, {3000}, 0, INT_MAX, DEC|ENC},
     {"rtmp_conn", "Append arbitrary AMF data to the Connect message", OFFSET(conn), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
     {"rtmp_flashver", "Version of the Flash plugin used to run the SWF player.", OFFSET(flashver), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
     {"rtmp_live", "Specify that the media is a live stream.", OFFSET(live), AV_OPT_TYPE_INT, {-2}, INT_MIN, INT_MAX, DEC, "rtmp_live"},

libswscale/input.c+97−41

     }
 }
-static void planar_rgb16le_to_y(uint8_t *_dst, 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 g = src[0][i];
-        int b = AV_RL16(src[1] + i);
+        int b = src[1][i];
-        int r = AV_RL16(src[2] + 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 + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
+        dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
     }
 }
-static void planar_rgb16be_to_y(uint8_t *_dst, const uint8_t *_src[4], int width)
+#define rdpx(src) \
+    is_be ? AV_RB16(src) : AV_RL16(src)
+static av_always_inline void planar_rgb16_to_y(uint8_t *_dst, const uint8_t *_src[4],
+                                               int width, int bpc, int is_be)
 {
     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_RB16(src[0] + i);
+        int g = rdpx(src[0] + i);
-        int b = AV_RB16(src[1] + i);
+        int b = rdpx(src[1] + i);
-        int r = AV_RB16(src[2] + i);
+        int r = rdpx(src[2] + i);
-        dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT - 1))) >> RGB2YUV_SHIFT);
+        dst[i] = ((RY * r + GY * g + BY * b + (33 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT);
     }
 }
-static void planar_rgb_to_uv(uint16_t *dstU, uint16_t *dstV, const uint8_t *src[4], int width)
+static void planar_rgb9le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
 {
-    int i;
+    planar_rgb16_to_y(dst, src, w, 9, 0);
-    for (i = 0; i < width; i++) {
+}
-        int g = src[0][i];
-        int b = src[1][i];
-        int r = src[2][i];
-        dstU[i] = (RU*r + GU*g + BU*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
+static void planar_rgb9be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
-        dstV[i] = (RV*r + GV*g + BV*b + (0x4001<<(RGB2YUV_SHIFT-7))) >> (RGB2YUV_SHIFT-6);
+{
-    }
+    planar_rgb16_to_y(dst, src, w, 9, 1);
 }
-static void planar_rgb16le_to_uv(uint8_t *_dstU, uint8_t *_dstV,
+static void planar_rgb10le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
-                                 const uint8_t *_src[4], int width)
 {
-    int i;
+    planar_rgb16_to_y(dst, src, w, 10, 0);
-    const uint16_t **src = (const uint16_t **)_src;
+}
-    uint16_t *dstU       = (uint16_t *)_dstU;
-    uint16_t *dstV       = (uint16_t *)_dstV;
-    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);
-        dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
+static void planar_rgb10be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
-        dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
+{
-    }
+    planar_rgb16_to_y(dst, src, w, 10, 1);
+}
+static void planar_rgb16le_to_y(uint8_t *dst, const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_y(dst, src, w, 16, 0);
 }
-static void planar_rgb16be_to_uv(uint8_t *_dstU, uint8_t *_dstV,
+static void planar_rgb16be_to_y(uint8_t *dst, const uint8_t *src[4], int w)
-                                 const uint8_t *_src[4], int width)
+{
+    planar_rgb16_to_y(dst, src, w, 16, 1);
+}
+static av_always_inline void planar_rgb16_to_uv(uint8_t *_dstU, uint8_t *_dstV,
+                                                const uint8_t *_src[4], int width,
+                                                int bpc, int is_be)
 {
     int i;
     const uint16_t **src = (const uint16_t **)_src;
     uint16_t *dstU       = (uint16_t *)_dstU;
     uint16_t *dstV       = (uint16_t *)_dstV;
     for (i = 0; i < width; i++) {
-        int g = AV_RB16(src[0] + i);
+        int g = rdpx(src[0] + i);
-        int b = AV_RB16(src[1] + i);
+        int b = rdpx(src[1] + i);
-        int r = AV_RB16(src[2] + i);
+        int r = rdpx(src[2] + i);
-        dstU[i] = (RU * r + GU * g + BU * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
+        dstU[i] = (RU * r + GU * g + BU * b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT;
-        dstV[i] = (RV * r + GV * g + BV * b + (257 << RGB2YUV_SHIFT)) >> (RGB2YUV_SHIFT + 1);
+        dstV[i] = (RV * r + GV * g + BV * b + (257 << (RGB2YUV_SHIFT + bpc - 9))) >> RGB2YUV_SHIFT;
     }
 }
+#undef rdpx
+static void planar_rgb9le_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 9, 0);
+}
+static void planar_rgb9be_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 9, 1);
+}
+static void planar_rgb10le_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                 const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 10, 0);
+}
+static void planar_rgb10be_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                 const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 10, 1);
+}
+static void planar_rgb16le_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                 const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 16, 0);
+}
+static void planar_rgb16be_to_uv(uint8_t *dstU, uint8_t *dstV,
+                                 const uint8_t *src[4], int w)
+{
+    planar_rgb16_to_uv(dstU, dstV, src, w, 16, 1);
+}
 av_cold void ff_sws_init_input_funcs(SwsContext *c)
 {
         c->chrToYV12 = palToUV_c;
         break;
     case PIX_FMT_GBRP9LE:
+        c->readChrPlanar = planar_rgb9le_to_uv;
+        break;
     case PIX_FMT_GBRP10LE:
+        c->readChrPlanar = planar_rgb10le_to_uv;
+        break;
     case PIX_FMT_GBRP16LE:
         c->readChrPlanar = planar_rgb16le_to_uv;
         break;
     case PIX_FMT_GBRP9BE:
+        c->readChrPlanar = planar_rgb9be_to_uv;
+        break;
     case PIX_FMT_GBRP10BE:
+        c->readChrPlanar = planar_rgb10be_to_uv;
+        break;
     case PIX_FMT_GBRP16BE:
         c->readChrPlanar = planar_rgb16be_to_uv;
         break;
     c->alpToYV12 = NULL;
     switch (srcFormat) {
     case PIX_FMT_GBRP9LE:
+        c->readLumPlanar = planar_rgb9le_to_y;
+        break;
     case PIX_FMT_GBRP10LE:
+        c->readLumPlanar = planar_rgb10le_to_y;
+        break;
     case PIX_FMT_GBRP16LE:
         c->readLumPlanar = planar_rgb16le_to_y;
         break;
     case PIX_FMT_GBRP9BE:
+        c->readLumPlanar = planar_rgb9be_to_y;
+        break;
     case PIX_FMT_GBRP10BE:
+        c->readLumPlanar = planar_rgb10be_to_y;
+        break;
     case PIX_FMT_GBRP16BE:
         c->readLumPlanar = planar_rgb16be_to_y;
         break;

tests/Makefile+1−1

@@ -148,7 +148,7 @@ fate-list: · 147 unmodified lines
148	clean:: testclean	148	clean:: testclean
149		149
150	testclean:	150	testclean:
151	$(RM) -r tests/vsynth1 tests/vsynth2 tests/data tools/lavfi-showfiltfmts$(EXESUF)	151	$(RM) -r tests/vsynth1 tests/data tools/lavfi-showfiltfmts$(EXESUF)
152	$(RM) $(CLEANSUFFIXES:%=tests/%)	152	$(RM) $(CLEANSUFFIXES:%=tests/%)
153	$(RM) $(TESTTOOLS:%=tests/%$(HOSTEXESUF))	153	$(RM) $(TESTTOOLS:%=tests/%$(HOSTEXESUF))
154		154

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -39,7 +39,7 @@ · 38 unmodified lines
39	#define PREFIX_h264_qpel16_v_lowpass_num altivec_put_h264_qpel16_v_lowpass_num	39	#define PREFIX_h264_qpel16_v_lowpass_num altivec_put_h264_qpel16_v_lowpass_num
40	#define PREFIX_h264_qpel16_hv_lowpass_altivec put_h264_qpel16_hv_lowpass_altivec	40	#define PREFIX_h264_qpel16_hv_lowpass_altivec put_h264_qpel16_hv_lowpass_altivec
41	#define PREFIX_h264_qpel16_hv_lowpass_num altivec_put_h264_qpel16_hv_lowpass_num	41	#define PREFIX_h264_qpel16_hv_lowpass_num altivec_put_h264_qpel16_hv_lowpass_num
42	#include "h264_template_altivec.c"	42	#include "h264_altivec_template.c"
43	#undef OP_U8_ALTIVEC	43	#undef OP_U8_ALTIVEC
44	#undef PREFIX_h264_chroma_mc8_altivec	44	#undef PREFIX_h264_chroma_mc8_altivec
45	#undef PREFIX_h264_chroma_mc8_num	45	#undef PREFIX_h264_chroma_mc8_num
@@ -59,7 +59,7 @@ · 13 unmodified lines
59	#define PREFIX_h264_qpel16_v_lowpass_num altivec_avg_h264_qpel16_v_lowpass_num	59	#define PREFIX_h264_qpel16_v_lowpass_num altivec_avg_h264_qpel16_v_lowpass_num
60	#define PREFIX_h264_qpel16_hv_lowpass_altivec avg_h264_qpel16_hv_lowpass_altivec	60	#define PREFIX_h264_qpel16_hv_lowpass_altivec avg_h264_qpel16_hv_lowpass_altivec
61	#define PREFIX_h264_qpel16_hv_lowpass_num altivec_avg_h264_qpel16_hv_lowpass_num	61	#define PREFIX_h264_qpel16_hv_lowpass_num altivec_avg_h264_qpel16_hv_lowpass_num
62	#include "h264_template_altivec.c"	62	#include "h264_altivec_template.c"
63	#undef OP_U8_ALTIVEC	63	#undef OP_U8_ALTIVEC
64	#undef PREFIX_h264_chroma_mc8_altivec	64	#undef PREFIX_h264_chroma_mc8_altivec
65	#undef PREFIX_h264_chroma_mc8_num	65	#undef PREFIX_h264_chroma_mc8_num