sigrid/ffmpeg

Changelog+1−0

@@ -30,6 +30,7 @@ version next: · 29 unmodified lines
30	- MicroDVD decoder	30	- MicroDVD decoder
31	- Avid Meridien (AVUI) decoder	31	- Avid Meridien (AVUI) decoder
32	- accept + prefix to -pix_fmt option to disable automatic conversions.	32	- accept + prefix to -pix_fmt option to disable automatic conversions.
		33	- audio filters support in libavfilter and avconv
33		34
34		35
35	version 0.10:	36	version 0.10:

doc/APIchanges+19−2

@@ -27,13 +27,30 @@ API changes, most recent first: · 26 unmodified lines
27	2012-03-26 - a67d9cf - lavfi 2.66.100	27	2012-03-26 - a67d9cf - lavfi 2.66.100
28	Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.	28	Add avfilter_fill_frame_from_{audio_,}buffer_ref() functions.
29		29
30	2012-xx-xx - xxxxxxx - lavc 54.13.1	30	2012-05-15 - lavfi 2.17.0
		31	Add support for audio filters
		32	ac71230/a2cd9be - add video/audio buffer sink in a new installed
		33	header buffersink.h
		34	720c6b7 - add av_buffersrc_write_frame(), deprecate
		35	av_vsrc_buffer_add_frame()
		36	ab16504 - add avfilter_copy_buf_props()
		37	9453c9e - add extended_data to AVFilterBuffer
		38	1b8c927 - add avfilter_get_audio_buffer_ref_from_arrays()
		39
		40	2012-05-09 - lavu 51.30.0 - samplefmt.h
		41	142e740 - add av_samples_copy()
		42	6d7f617 - add av_samples_set_silence()
		43
		44	2012-05-09 - a5117a2 - lavc 54.13.1
31	For audio formats with fixed frame size, the last frame	45	For audio formats with fixed frame size, the last frame
32	no longer needs to be padded with silence, libavcodec	46	no longer needs to be padded with silence, libavcodec
33	will handle this internally (effectively all encoders	47	will handle this internally (effectively all encoders
34	behave as if they had CODEC_CAP_SMALL_LAST_FRAME set).	48	behave as if they had CODEC_CAP_SMALL_LAST_FRAME set).
35		49
36	2012-xx-xx - xxxxxxx - lavr 0.0.1	50	2012-05-07 - 828bd08 - lavc 54.13.0 - avcodec.h
		51	Add sample_rate and channel_layout fields to AVFrame.
		52
		53	2012-05-01 - 4010d72 - lavr 0.0.1
37	Change AV_MIX_COEFF_TYPE_Q6 to AV_MIX_COEFF_TYPE_Q8.	54	Change AV_MIX_COEFF_TYPE_Q6 to AV_MIX_COEFF_TYPE_Q8.
38		55
39	2012-04-25 - 3527a73 - lavu 51.29.0 - cpu.h	56	2012-04-25 - 3527a73 - lavu 51.29.0 - cpu.h

doc/ffmpeg.texi+6−0

 @item -sample_fmt[:@var{stream_specifier}] @var{sample_fmt} (@emph{output,per-stream})
 Set the audio sample format. Use @code{-sample_fmts} to get a list
 of supported sample formats.
+@item -af @var{filter_graph} (@emph{output})
+@var{filter_graph} is a description of the filter graph to apply to
+the input audio.
+Use the option "-filters" to show all the available filters (including
+also sources and sinks).  This is an alias for @code{-filter:a}.
 @end table
 @section Advanced Audio options:
 the parameter is the maximum samples per second by which the audio is changed.
 -async 1 is a special case where only the start of the audio stream is corrected
 without any later correction.
+This option has been deprecated. Use the @code{asyncts} audio filter instead.
 @item -copyts
 Copy timestamps from input to output.
 @item -copytb @var{mode}

doc/filters.texi+79−0

@@ -211,6 +211,32 @@ amovie=input.mkv:si=5 [a5]; · 210 unmodified lines
211	[x3][a5] amerge" -c:a pcm_s16le output.mkv	211	[x3][a5] amerge" -c:a pcm_s16le output.mkv
212	@end example	212	@end example
213		213
		214	@section aformat
		215
		216	Convert the input audio to one of the specified formats. The framework will
		217	negotiate the most appropriate format to minimize conversions.
		218
		219	The filter accepts the following named parameters:
		220	@table @option
		221
		222	@item sample_fmts
		223	A comma-separated list of requested sample formats.
		224
		225	@item sample_rates
		226	A comma-separated list of requested sample rates.
		227
		228	@item channel_layouts
		229	A comma-separated list of requested channel layouts.
		230
		231	@end table
		232
		233	If a parameter is omitted, all values are allowed.
		234
		235	For example to force the output to either unsigned 8-bit or signed 16-bit stereo:
		236	@example
		237	aformat=sample_fmts\=u8\,s16:channel_layouts\=stereo
		238	@end example
		239
214	@section anull	240	@section anull
215		241
216	Pass the audio source unchanged to the output.	242	Pass the audio source unchanged to the output.
@@ -502,6 +528,25 @@ volume=-12dB · 285 unmodified lines
502	@end example	528	@end example
503	@end itemize	529	@end itemize
504		530
		531	@section asyncts
		532	Synchronize audio data with timestamps by squeezing/stretching it and/or
		533	dropping samples/adding silence when needed.
		534
		535	The filter accepts the following named parameters:
		536	@table @option
		537
		538	@item compensate
		539	Enable stretching/squeezing the data to make it match the timestamps.
		540
		541	@item min_delta
		542	Minimum difference between timestamps and audio data (in seconds) to trigger
		543	adding/dropping samples.
		544
		545	@item max_comp
		546	Maximum compensation in samples per second.
		547
		548	@end table
		549
505	@section resample	550	@section resample
506	Convert the audio sample format, sample rate and channel layout. This filter is	551	Convert the audio sample format, sample rate and channel layout. This filter is
507	not meant to be used directly.	552	not meant to be used directly.
@@ -721,6 +766,33 @@ anullsrc=r=48000:cl=4 · 213 unmodified lines
721	anullsrc=r=48000:cl=mono	766	anullsrc=r=48000:cl=mono
722	@end example	767	@end example
723		768
		769	@section abuffer
		770	Buffer audio frames, and make them available to the filter chain.
		771
		772	This source is not intended to be part of user-supplied graph descriptions but
		773	for insertion by calling programs through the interface defined in
		774	@file{libavfilter/buffersrc.h}.
		775
		776	It accepts the following named parameters:
		777	@table @option
		778
		779	@item time_base
		780	Timebase which will be used for timestamps of submitted frames. It must be
		781	either a floating-point number or in @var{numerator}/@var{denominator} form.
		782
		783	@item sample_rate
		784	Audio sample rate.
		785
		786	@item sample_fmt
		787	Name of the sample format, as returned by @code{av_get_sample_fmt_name()}.
		788
		789	@item channel_layout
		790	Channel layout of the audio data, in the form that can be accepted by
		791	@code{av_get_channel_layout()}.
		792	@end table
		793
		794	All the parameters need to be explicitly defined.
		795
724	@c man end AUDIO SOURCES	796	@c man end AUDIO SOURCES
725		797
726	@chapter Audio Sinks	798	@chapter Audio Sinks
@@ -745,6 +817,13 @@ Null audio sink, do absolutely nothing with the input audio. It is · 18 unmodified lines
745	mainly useful as a template and to be employed in analysis / debugging	817	mainly useful as a template and to be employed in analysis / debugging
746	tools.	818	tools.
747		819
		820	@section abuffersink
		821	This sink is intended for programmatic use. Frames that arrive on this sink can
		822	be retrieved by the calling program using the interface defined in
		823	@file{libavfilter/buffersink.h}.
		824
		825	This filter accepts no parameters.
		826
748	@c man end AUDIO SINKS	827	@c man end AUDIO SINKS
749		828
750	@chapter Video Filters	829	@chapter Video Filters

ffprobe.c+18−4

     return 0;
 }
+static void close_input_file(AVFormatContext **ctx_ptr)
+{
+    int i;
+    AVFormatContext *fmt_ctx = *ctx_ptr;
+    /* close decoder for each stream */
+    for (i = 0; i < fmt_ctx->nb_streams; i++)
+        if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE)
+            avcodec_close(fmt_ctx->streams[i]->codec);
+    avformat_close_input(ctx_ptr);
+}
 #define PRINT_CHAPTER(name) do {                                        \
     if (do_show_ ## name) {                                             \
         writer_print_chapter_header(wctx, #name);                       \
         }
         PRINT_CHAPTER(streams);
         PRINT_CHAPTER(format);
-        for (i = 0; i < fmt_ctx->nb_streams; i++)
+        close_input_file(&fmt_ctx);
-            if (fmt_ctx->streams[i]->codec->codec_id != CODEC_ID_NONE)
-                avcodec_close(fmt_ctx->streams[i]->codec);
-        avformat_close_input(&fmt_ctx);
         av_freep(&nb_streams_frames);
         av_freep(&nb_streams_packets);
     }
 end:
     av_freep(&print_format);
+    uninit_opts();
+    av_dict_free(&fmt_entries_to_show);
     avformat_network_deinit();
     return ret;

libavcodec/libmp3lame.c+4−7

@@ -26,6 +26,7 @@ · 25 unmodified lines
26		26
27	#include <lame/lame.h>	27	#include <lame/lame.h>
28		28
		29	#include "libavutil/audioconvert.h"
29	#include "libavutil/intreadwrite.h"	30	#include "libavutil/intreadwrite.h"
30	#include "libavutil/log.h"	31	#include "libavutil/log.h"
31	#include "libavutil/opt.h"	32	#include "libavutil/opt.h"
@@ -76,13 +77,7 @@ static av_cold int mp3lame_encode_init(AVCodecContext *avctx) · 44 unmodified lines
76	if ((s->gfp = lame_init()) == NULL)	77	if ((s->gfp = lame_init()) == NULL)
77	return AVERROR(ENOMEM);	78	return AVERROR(ENOMEM);
78		79
79	/* channels */	80
80	if (avctx->channels > 2) {
81	av_log(avctx, AV_LOG_ERROR,
82	"Invalid number of channels %d, must be <= 2\n", avctx->channels);
83	ret = AVERROR(EINVAL);
84	goto error;
85	}
86	lame_set_num_channels(s->gfp, avctx->channels);	81	lame_set_num_channels(s->gfp, avctx->channels);
87	lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);	82	lame_set_mode(s->gfp, avctx->channels > 1 ? JOINT_STEREO : MONO);
88		83
@@ -308,6 +303,8 @@ AVCodec ff_libmp3lame_encoder = { · 219 unmodified lines
308	AV_SAMPLE_FMT_S16,	303	AV_SAMPLE_FMT_S16,
309	AV_SAMPLE_FMT_NONE },	304	AV_SAMPLE_FMT_NONE },
310	.supported_samplerates = libmp3lame_sample_rates,	305	.supported_samplerates = libmp3lame_sample_rates,
		306	.channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_MONO,
		307	AV_CH_LAYOUT_STEREO },
311	.long_name = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),	308	.long_name = NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
312	.priv_class = &libmp3lame_class,	309	.priv_class = &libmp3lame_class,
313	.defaults = libmp3lame_defaults,	310	.defaults = libmp3lame_defaults,

libavfilter/Makefile+5−0

 NAME = avfilter
 FFLIBS = avutil swscale
+FFLIBS-$(CONFIG_ASYNCTS_FILTER) += avresample
 FFLIBS-$(CONFIG_RESAMPLE_FILTER) += avresample
 FFLIBS-$(CONFIG_ACONVERT_FILTER)             += swresample
        audio.o                                                          \
        avfilter.o                                                       \
        avfiltergraph.o                                                  \
+       buffer.o                                                         \
        buffersink.o                                                     \
        defaults.o                                                       \
        drawutils.o                                                      \
        src_buffer.o                                                     \
        transform.o                                                      \
        vf_scale.o                                                       \
+       video.o                                                          \
 OBJS-$(CONFIG_AVCODEC)                       += avcodec.o
 OBJS-$(CONFIG_AVFORMAT)                      += lavfutils.o
 OBJS-$(CONFIG_ASHOWINFO_FILTER)              += af_ashowinfo.o
 OBJS-$(CONFIG_ASPLIT_FILTER)                 += af_asplit.o
 OBJS-$(CONFIG_ASTREAMSYNC_FILTER)            += af_astreamsync.o
+OBJS-$(CONFIG_ASYNCTS_FILTER)                += af_asyncts.o
 OBJS-$(CONFIG_EARWAX_FILTER)                 += af_earwax.o
 OBJS-$(CONFIG_PAN_FILTER)                    += af_pan.o
 OBJS-$(CONFIG_RESAMPLE_FILTER)               += af_resample.o

libavfilter/af_aconvert.c+8−7

     AVFilterLink *inlink  = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
     int out_packing = av_sample_fmt_is_planar(aconvert->out_sample_fmt);
+    AVFilterChannelLayouts *layouts;
     avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),
                          &inlink->out_formats);
         avfilter_formats_ref(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO),
                              &outlink->in_formats);
-    avfilter_formats_ref(avfilter_make_all_channel_layouts(),
+    ff_channel_layouts_ref(ff_all_channel_layouts(),
-                         &inlink->out_chlayouts);
+                         &inlink->out_channel_layouts);
     if (aconvert->out_chlayout != 0) {
-        formats = NULL;
+        layouts = NULL;
-        avfilter_add_format(&formats, aconvert->out_chlayout);
+        ff_add_channel_layout(&layouts, aconvert->out_chlayout);
-        avfilter_formats_ref(formats, &outlink->in_chlayouts);
+        ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
     } else
-        avfilter_formats_ref(avfilter_make_all_channel_layouts(),
+        ff_channel_layouts_ref(ff_all_channel_layouts(),
-                             &outlink->in_chlayouts);
+                             &outlink->in_channel_layouts);
     avfilter_formats_ref(avfilter_make_all_packing_formats(),
                          &inlink->out_packing);

libavfilter/af_aformat.c+89−51

@@ -25,72 +25,110 @@ · 24 unmodified lines
25		25
26	#include "libavutil/audioconvert.h"	26	#include "libavutil/audioconvert.h"
27	#include "libavutil/avstring.h"	27	#include "libavutil/avstring.h"
28	#include "avfilter.h"	28	#include "libavutil/opt.h"
		29
29	#include "audio.h"	30	#include "audio.h"
		31	#include "avfilter.h"
		32	#include "formats.h"
30	#include "internal.h"	33	#include "internal.h"
31		34
32	typedef struct {	35	typedef struct AFormatContext {
33	AVFilterFormats formats, chlayouts, *packing;	36	const AVClass *class;
		37
		38	AVFilterFormats *formats;
		39	AVFilterFormats *sample_rates;
		40	AVFilterChannelLayouts *channel_layouts;
		41
		42	char *formats_str;
		43	char *sample_rates_str;
		44	char *channel_layouts_str;
34	} AFormatContext;	45	} AFormatContext;
35		46
		47	#define OFFSET(x) offsetof(AFormatContext, x)
		48	#define A AV_OPT_FLAG_AUDIO_PARAM
		49	static const AVOption options[] = {
		50	{ "sample_fmts", "A comma-separated list of sample formats.", OFFSET(formats_str), AV_OPT_TYPE_STRING, .flags = A },
		51	{ "sample_rates", "A comma-separated list of sample rates.", OFFSET(sample_rates_str), AV_OPT_TYPE_STRING, .flags = A },
		52	{ "channel_layouts", "A comma-separated list of channel layouts.", OFFSET(channel_layouts_str), AV_OPT_TYPE_STRING, .flags = A },
		53	{ NULL },
		54	};
		55
		56	static const AVClass aformat_class = {
		57	.class_name = "aformat filter",
		58	.item_name = av_default_item_name,
		59	.option = options,
		60	.version = LIBAVUTIL_VERSION_INT,
		61	};
		62
		63	#define PARSE_FORMATS(str, type, list, add_to_list, get_fmt, none, desc) \
		64	do { \
		65	char next, cur = str; \
		66	while (cur) { \
		67	type fmt; \
		68	next = strchr(cur, ','); \
		69	if (next) \
		70	*next++ = 0; \
		71	\
		72	if ((fmt = get_fmt(cur)) == none) { \
		73	av_log(ctx, AV_LOG_ERROR, "Error parsing " desc ": %s.\n", cur);\
		74	ret = AVERROR(EINVAL); \
		75	goto fail; \
		76	} \
		77	add_to_list(&list, fmt); \
		78	\
		79	cur = next; \
		80	} \
		81	} while (0)
		82
		83	static int get_sample_rate(const char *samplerate)
		84	{
		85	int ret = strtol(samplerate, NULL, 0);
		86	return FFMAX(ret, 0);
		87	}
		88
36	static av_cold int init(AVFilterContext ctx, const char args, void *opaque)	89	static av_cold int init(AVFilterContext ctx, const char args, void *opaque)
37	{	90	{
38	AFormatContext * const aformat = ctx->priv;	91	AFormatContext *s = ctx->priv;
39	char fmts_str = NULL, fmt_str, *ptr = NULL;
40	int64_t fmt;
41	int ret;	92	int ret;
42		93
43	if (!args)	94	if (!args) {
44	goto arg_fail;	95	av_log(ctx, AV_LOG_ERROR, "No parameters supplied.\n");
45		96	return AVERROR(EINVAL);
46	#define ADD_FORMATS(all_formats, fmt_name, fmt_type, fmts_list) do { \	97	}
47	fmts_str = av_get_token(&args, ":"); \
48	if (!fmts_str \|\| !*fmts_str) \
49	goto arg_fail; \
50	if (!strcmp(fmts_str, "all")) { \
51	aformat->fmts_list = all_formats; \
52	} else { \
53	for (fmt_str = fmts_str; \
54	fmt_str = av_strtok(fmt_str, ",", &ptr); fmt_str = NULL) { \
55	if ((ret = ff_parse_##fmt_name((fmt_type *)&fmt, \
56	fmt_str, ctx)) < 0) { \
57	av_freep(&fmts_str); \
58	return ret; \
59	} \
60	avfilter_add_format(&aformat->fmts_list, fmt); \
61	} \
62	} \
63	av_freep(&fmts_str); \
64	if (*args) \
65	args++; \
66	} while (0)
67		98
68	ADD_FORMATS(avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO), sample_format, int, formats);	99	s->class = &aformat_class;
69	ADD_FORMATS(avfilter_make_all_channel_layouts(), channel_layout, int64_t, chlayouts);	100	av_opt_set_defaults(s);
70	ADD_FORMATS(avfilter_make_all_packing_formats(), packing_format, int, packing);
71		101
72	return 0;	102	if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {
		103	av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);
		104	return ret;
		105	}
73		106
74	arg_fail:	107	PARSE_FORMATS(s->formats_str, enum AVSampleFormat, s->formats,
75	av_log(ctx, AV_LOG_ERROR, "Invalid arguments, they must be of the form "	108	avfilter_add_format, av_get_sample_fmt, AV_SAMPLE_FMT_NONE, "sample format");
76	"sample_fmts:channel_layouts:packing_fmts\n");	109	PARSE_FORMATS(s->sample_rates_str, int, s->sample_rates, avfilter_add_format,
77	av_freep(&fmts_str);	110	get_sample_rate, 0, "sample rate");
78	return AVERROR(EINVAL);	111	PARSE_FORMATS(s->channel_layouts_str, uint64_t, s->channel_layouts,
		112	ff_add_channel_layout, av_get_channel_layout, 0,
		113	"channel layout");
		114
		115	fail:
		116	av_opt_free(s);
		117	return ret;
79	}	118	}
80		119
81	static int query_formats(AVFilterContext *ctx)	120	static int query_formats(AVFilterContext *ctx)
82	{	121	{
83	AFormatContext * const aformat = ctx->priv;	122	AFormatContext *s = ctx->priv;
84		123
85	avfilter_set_common_sample_formats (ctx, aformat->formats);	124	avfilter_set_common_formats(ctx, s->formats ? s->formats :
86	avfilter_set_common_channel_layouts(ctx, aformat->chlayouts);	125	avfilter_all_formats(AVMEDIA_TYPE_AUDIO));
87	avfilter_set_common_packing_formats(ctx, aformat->packing);	126	ff_set_common_samplerates(ctx, s->sample_rates ? s->sample_rates :
88	return 0;	127	ff_all_samplerates());
89	}	128	ff_set_common_channel_layouts(ctx, s->channel_layouts ? s->channel_layouts :
		129	ff_all_channel_layouts());
90		130
91	static void filter_samples(AVFilterLink inlink, AVFilterBufferRef insamplesref)	131	return 0;
92	{
93	ff_filter_samples(inlink->dst->outputs[0], insamplesref);
94	}	132	}
95		133
96	AVFilter avfilter_af_aformat = {	134	AVFilter avfilter_af_aformat = {
@@ -100,11 +138,11 @@ AVFilter avfilter_af_aformat = { · 3 unmodified lines
100	.query_formats = query_formats,	138	.query_formats = query_formats,
101	.priv_size = sizeof(AFormatContext),	139	.priv_size = sizeof(AFormatContext),
102		140
103	.inputs = (const AVFilterPad[]) {{ .name = "default",	141	.inputs = (AVFilterPad[]) {{ .name = "default",
104	.type = AVMEDIA_TYPE_AUDIO,	142	.type = AVMEDIA_TYPE_AUDIO,
105	.filter_samples = filter_samples},	143	.filter_samples = ff_null_filter_samples },
106	{ .name = NULL}},	144	{ .name = NULL}},
107	.outputs = (const AVFilterPad[]) {{ .name = "default",	145	.outputs = (AVFilterPad[]) {{ .name = "default",
108	.type = AVMEDIA_TYPE_AUDIO},	146	.type = AVMEDIA_TYPE_AUDIO},
109	{ .name = NULL}},	147	{ .name = NULL}},
110	};	148	};

libavfilter/af_amerge.c+11−10

     int64_t inlayout[2], outlayout;
     const int packing_fmts[] = { AVFILTER_PACKED, -1 };
     AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
     int i;
     for (i = 0; i < 2; i++) {
-        if (!ctx->inputs[i]->in_chlayouts ||
+        if (!ctx->inputs[i]->in_channel_layouts ||
-            !ctx->inputs[i]->in_chlayouts->format_count) {
+            !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_chlayouts->formats[0];
+        inlayout[i] = ctx->inputs[i]->in_channel_layouts->channel_layouts[0];
-        if (ctx->inputs[i]->in_chlayouts->format_count > 1) {
+        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);
     formats = avfilter_make_format_list(packing_fmts);
     avfilter_set_common_packing_formats(ctx, formats);
     for (i = 0; i < 2; i++) {
-        formats = NULL;
+        layouts = NULL;
-        avfilter_add_format(&formats, inlayout[i]);
+        ff_add_channel_layout(&layouts, inlayout[i]);
-        avfilter_formats_ref(formats, &ctx->inputs[i]->out_chlayouts);
+        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
     }
-    formats = NULL;
+    layouts = NULL;
-    avfilter_add_format(&formats, outlayout);
+    ff_add_channel_layout(&layouts, outlayout);
-    avfilter_formats_ref(formats, &ctx->outputs[0]->in_chlayouts);
+    ff_channel_layouts_ref(layouts, &ctx->outputs[0]->in_channel_layouts);
     return 0;
 }

libavfilter/af_aresample.c+37−0

@@ -56,6 +56,42 @@ static av_cold void uninit(AVFilterContext *ctx) · 55 unmodified lines
56	swr_free(&aresample->swr);	56	swr_free(&aresample->swr);
57	}	57	}
58		58
		59	static int query_formats(AVFilterContext *ctx)
		60	{
		61	AResampleContext *aresample = ctx->priv;
		62
		63	AVFilterLink *inlink = ctx->inputs[0];
		64	AVFilterLink *outlink = ctx->outputs[0];
		65
		66	AVFilterFormats *in_formats = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
		67	AVFilterFormats *out_formats = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
		68	AVFilterFormats *in_samplerates = ff_all_samplerates();
		69	AVFilterFormats *out_samplerates;
		70
		71
		72	AVFilterChannelLayouts *in_layouts = ff_all_channel_layouts();
		73	AVFilterChannelLayouts *out_layouts = ff_all_channel_layouts();
		74
		75	avfilter_formats_ref(in_formats, &inlink->out_formats);
		76	avfilter_formats_ref(out_formats, &outlink->in_formats);
		77
		78	avfilter_formats_ref(in_samplerates, &inlink->out_samplerates);
		79
		80	ff_channel_layouts_ref(in_layouts, &inlink->out_channel_layouts);
		81	ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
		82
		83	if(aresample->out_rate > 0) {
		84	int sample_rates[] = { aresample->out_rate, -1 };
		85	ff_set_common_samplerates(ctx, avfilter_make_format_list(sample_rates));
		86	} else {
		87	out_samplerates = ff_all_samplerates();
		88	avfilter_formats_ref(out_samplerates, &outlink->in_samplerates);
		89	}
		90
		91	return 0;
		92	}
		93
		94
59	static int config_output(AVFilterLink *outlink)	95	static int config_output(AVFilterLink *outlink)
60	{	96	{
61	int ret;	97	int ret;
@@ -113,6 +149,7 @@ AVFilter avfilter_af_aresample = { · 51 unmodified lines
113	.description = NULL_IF_CONFIG_SMALL("Resample audio data."),	149	.description = NULL_IF_CONFIG_SMALL("Resample audio data."),
114	.init = init,	150	.init = init,
115	.uninit = uninit,	151	.uninit = uninit,
		152	.query_formats = query_formats,
116	.priv_size = sizeof(AResampleContext),	153	.priv_size = sizeof(AResampleContext),
117		154
118	.inputs = (const AVFilterPad[]) {{ .name = "default",	155	.inputs = (const AVFilterPad[]) {{ .name = "default",

libavfilter/af_astreamsync.c+4−3

 {
     int i;
     AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
     for (i = 0; i < 2; i++) {
         formats = ctx->inputs[i]->in_formats;
         formats = ctx->inputs[i]->in_packing;
         avfilter_formats_ref(formats, &ctx->inputs[i]->out_packing);
         avfilter_formats_ref(formats, &ctx->outputs[i]->in_packing);
-        formats = ctx->inputs[i]->in_chlayouts;
+        layouts = ctx->inputs[i]->in_channel_layouts;
-        avfilter_formats_ref(formats, &ctx->inputs[i]->out_chlayouts);
+        ff_channel_layouts_ref(layouts, &ctx->inputs[i]->out_channel_layouts);
-        avfilter_formats_ref(formats, &ctx->outputs[i]->in_chlayouts);
+        ff_channel_layouts_ref(layouts, &ctx->outputs[i]->in_channel_layouts);
     }
     return 0;
 }

libavfilter/af_asyncts.c+237−0

@@ -0,0 +1,237 @@
	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	#include "libavresample/avresample.h"
	20	#include "libavutil/audio_fifo.h"
	21	#include "libavutil/mathematics.h"
	22	#include "libavutil/opt.h"
	23	#include "libavutil/samplefmt.h"
	24
	25	#include "audio.h"
	26	#include "avfilter.h"
	27
	28	typedef struct ASyncContext {
	29	const AVClass *class;
	30
	31	AVAudioResampleContext *avr;
	32	int64_t pts; ///< timestamp in samples of the first sample in fifo
	33	int min_delta; ///< pad/trim min threshold in samples
	34
	35	/* options */
	36	int resample;
	37	float min_delta_sec;
	38	int max_comp;
	39	} ASyncContext;
	40
	41	#define OFFSET(x) offsetof(ASyncContext, x)
	42	#define A AV_OPT_FLAG_AUDIO_PARAM
	43	static const AVOption options[] = {
	44	{ "compensate", "Stretch/squeeze the data to make it match the timestamps", OFFSET(resample), AV_OPT_TYPE_INT, { 0 }, 0, 1, A },
	45	{ "min_delta", "Minimum difference between timestamps and audio data "
	46	"(in seconds) to trigger padding/trimmin the data.", OFFSET(min_delta_sec), AV_OPT_TYPE_FLOAT, { 0.1 }, 0, INT_MAX, A },
	47	{ "max_comp", "Maximum compensation in samples per second.", OFFSET(max_comp), AV_OPT_TYPE_INT, { 500 }, 0, INT_MAX, A },
	48	{ NULL },
	49	};
	50
	51	static const AVClass async_class = {
	52	.class_name = "asyncts filter",
	53	.item_name = av_default_item_name,
	54	.option = options,
	55	.version = LIBAVUTIL_VERSION_INT,
	56	};
	57
	58	static int init(AVFilterContext ctx, const char args, void *opaque)
	59	{
	60	ASyncContext *s = ctx->priv;
	61	int ret;
	62
	63	s->class = &async_class;
	64	av_opt_set_defaults(s);
	65
	66	if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {
	67	av_log(ctx, AV_LOG_ERROR, "Error parsing options string '%s'.\n", args);
	68	return ret;
	69	}
	70	av_opt_free(s);
	71
	72	s->pts = AV_NOPTS_VALUE;
	73
	74	return 0;
	75	}
	76
	77	static void uninit(AVFilterContext *ctx)
	78	{
	79	ASyncContext *s = ctx->priv;
	80
	81	if (s->avr) {
	82	avresample_close(s->avr);
	83	avresample_free(&s->avr);
	84	}
	85	}
	86
	87	static int config_props(AVFilterLink *link)
	88	{
	89	ASyncContext *s = link->src->priv;
	90	int ret;
	91
	92	s->min_delta = s->min_delta_sec * link->sample_rate;
	93	link->time_base = (AVRational){1, link->sample_rate};
	94
	95	s->avr = avresample_alloc_context();
	96	if (!s->avr)
	97	return AVERROR(ENOMEM);
	98
	99	av_opt_set_int(s->avr, "in_channel_layout", link->channel_layout, 0);
	100	av_opt_set_int(s->avr, "out_channel_layout", link->channel_layout, 0);
	101	av_opt_set_int(s->avr, "in_sample_fmt", link->format, 0);
	102	av_opt_set_int(s->avr, "out_sample_fmt", link->format, 0);
	103	av_opt_set_int(s->avr, "in_sample_rate", link->sample_rate, 0);
	104	av_opt_set_int(s->avr, "out_sample_rate", link->sample_rate, 0);
	105
	106	if (s->resample)
	107	av_opt_set_int(s->avr, "force_resampling", 1, 0);
	108
	109	if ((ret = avresample_open(s->avr)) < 0)
	110	return ret;
	111
	112	return 0;
	113	}
	114
	115	static int request_frame(AVFilterLink *link)
	116	{
	117	AVFilterContext *ctx = link->src;
	118	ASyncContext *s = ctx->priv;
	119	int ret = avfilter_request_frame(ctx->inputs[0]);
	120	int nb_samples;
	121
	122	/* flush the fifo */
	123	if (ret == AVERROR_EOF && (nb_samples = avresample_get_delay(s->avr))) {
	124	AVFilterBufferRef *buf = ff_get_audio_buffer(link, AV_PERM_WRITE,
	125	nb_samples);
	126	if (!buf)
	127	return AVERROR(ENOMEM);
	128	avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],
	129	nb_samples, NULL, 0, 0);
	130	buf->pts = s->pts;
	131	ff_filter_samples(link, buf);
	132	return 0;
	133	}
	134
	135	return ret;
	136	}
	137
	138	static void write_to_fifo(ASyncContext s, AVFilterBufferRef buf)
	139	{
	140	avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
	141	buf->linesize[0], buf->audio->nb_samples);
	142	avfilter_unref_buffer(buf);
	143	}
	144
	145	/* get amount of data currently buffered, in samples */
	146	static int64_t get_delay(ASyncContext *s)
	147	{
	148	return avresample_available(s->avr) + avresample_get_delay(s->avr);
	149	}
	150
	151	static void filter_samples(AVFilterLink inlink, AVFilterBufferRef buf)
	152	{
	153	AVFilterContext *ctx = inlink->dst;
	154	ASyncContext *s = ctx->priv;
	155	AVFilterLink *outlink = ctx->outputs[0];
	156	int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
	157	int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :
	158	av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);
	159	int out_size;
	160	int64_t delta;
	161
	162	/* buffer data until we get the first timestamp */
	163	if (s->pts == AV_NOPTS_VALUE) {
	164	if (pts != AV_NOPTS_VALUE) {
	165	s->pts = pts - get_delay(s);
	166	}
	167	write_to_fifo(s, buf);
	168	return;
	169	}
	170
	171	/* now wait for the next timestamp */
	172	if (pts == AV_NOPTS_VALUE) {
	173	write_to_fifo(s, buf);
	174	return;
	175	}
	176
	177	/* when we have two timestamps, compute how many samples would we have
	178	* to add/remove to get proper sync between data and timestamps */
	179	delta = pts - s->pts - get_delay(s);
	180	out_size = avresample_available(s->avr);
	181
	182	if (labs(delta) > s->min_delta) {
	183	av_log(ctx, AV_LOG_VERBOSE, "Discontinuity - %"PRId64" samples.\n", delta);
	184	out_size += delta;
	185	} else if (s->resample) {
	186	int comp = av_clip(delta, -s->max_comp, s->max_comp);
	187	av_log(ctx, AV_LOG_VERBOSE, "Compensating %d samples per second.\n", comp);
	188	avresample_set_compensation(s->avr, delta, inlink->sample_rate);
	189	}
	190
	191	if (out_size > 0) {
	192	AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,
	193	out_size);
	194	if (!buf_out)
	195	return;
	196
	197	avresample_read(s->avr, (void**)buf_out->extended_data, out_size);
	198	buf_out->pts = s->pts;
	199
	200	if (delta > 0) {
	201	av_samples_set_silence(buf_out->extended_data, out_size - delta,
	202	delta, nb_channels, buf->format);
	203	}
	204	ff_filter_samples(outlink, buf_out);
	205	} else {
	206	av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "
	207	"whole buffer.\n");
	208	}
	209
	210	/* drain any remaining buffered data */
	211	avresample_read(s->avr, NULL, avresample_available(s->avr));
	212
	213	s->pts = pts - avresample_get_delay(s->avr);
	214	avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
	215	buf->linesize[0], buf->audio->nb_samples);
	216	avfilter_unref_buffer(buf);
	217	}
	218
	219	AVFilter avfilter_af_asyncts = {
	220	.name = "asyncts",
	221	.description = NULL_IF_CONFIG_SMALL("Sync audio data to timestamps"),
	222
	223	.init = init,
	224	.uninit = uninit,
	225
	226	.priv_size = sizeof(ASyncContext),
	227
	228	.inputs = (const AVFilterPad[]) {{ .name = "default",
	229	.type = AVMEDIA_TYPE_AUDIO,
	230	.filter_samples = filter_samples },
	231	{ NULL }},
	232	.outputs = (const AVFilterPad[]) {{ .name = "default",
	233	.type = AVMEDIA_TYPE_AUDIO,
	234	.config_props = config_props,
	235	.request_frame = request_frame },
	236	{ NULL }},
	237	};

libavfilter/af_earwax.c+8−3

 #include "libavutil/audioconvert.h"
 #include "avfilter.h"
 #include "audio.h"
+#include "formats.h"
 #define NUMTAPS 64
 static int query_formats(AVFilterContext *ctx)
 {
+    int sample_rates[] = { 44100, -1 };
     AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layout = NULL;
     avfilter_add_format(&formats, AV_SAMPLE_FMT_S16);
     avfilter_set_common_sample_formats(ctx, formats);
-    formats = NULL;
+    ff_add_channel_layout(&layout, AV_CH_LAYOUT_STEREO);
-    avfilter_add_format(&formats, AV_CH_LAYOUT_STEREO);
+    ff_set_common_channel_layouts(ctx, layout);
-    avfilter_set_common_channel_layouts(ctx, formats);
     formats = NULL;
     avfilter_add_format(&formats, AVFILTER_PACKED);
     avfilter_set_common_packing_formats(ctx, formats);
+    ff_set_common_samplerates(ctx, avfilter_make_format_list(sample_rates));
     return 0;
 }

libavfilter/af_pan.c+7−6

 #include "libswresample/swresample.h"
 #include "audio.h"
 #include "avfilter.h"
+#include "formats.h"
 #define MAX_CHANNELS 63
     PanContext *pan = ctx->priv;
     AVFilterLink *inlink  = ctx->inputs[0];
     AVFilterLink *outlink = ctx->outputs[0];
-    AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
     pan->pure_gains = are_gains_pure(pan);
     /* libswr supports any sample and packing formats */
     avfilter_set_common_packing_formats(ctx, avfilter_make_all_packing_formats());
     // inlink supports any channel layout
-    formats = avfilter_make_all_channel_layouts();
+    layouts = ff_all_channel_layouts();
-    avfilter_formats_ref(formats, &inlink->out_chlayouts);
+    ff_channel_layouts_ref(layouts, &inlink->out_channel_layouts);
     // outlink supports only requested output channel layout
-    formats = NULL;
+    layouts = NULL;
-    avfilter_add_format(&formats, pan->out_channel_layout);
+    ff_add_channel_layout(&layouts, pan->out_channel_layout);
-    avfilter_formats_ref(formats, &outlink->in_chlayouts);
+    ff_channel_layouts_ref(layouts, &outlink->in_channel_layouts);
     return 0;
 }

libavfilter/af_resample.c+11−0

 #include "audio.h"
 #include "avfilter.h"
+#include "formats.h"
 #include "internal.h"
 typedef struct ResampleContext {
     AVFilterFormats        *in_formats      = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
     AVFilterFormats        *out_formats     = avfilter_all_formats(AVMEDIA_TYPE_AUDIO);
+    AVFilterFormats        *in_samplerates  = ff_all_samplerates();
+    AVFilterFormats        *out_samplerates = ff_all_samplerates();
+    AVFilterChannelLayouts *in_layouts      = ff_all_channel_layouts();
+    AVFilterChannelLayouts *out_layouts     = ff_all_channel_layouts();
     avfilter_formats_ref(in_formats,  &inlink->out_formats);
     avfilter_formats_ref(out_formats, &outlink->in_formats);
+    avfilter_formats_ref(in_samplerates,  &inlink->out_samplerates);
+    avfilter_formats_ref(out_samplerates, &outlink->in_samplerates);
+    ff_channel_layouts_ref(in_layouts,  &inlink->out_channel_layouts);
+    ff_channel_layouts_ref(out_layouts, &outlink->in_channel_layouts);
     return 0;
 }

libavfilter/af_silencedetect.c+10−3

 #include "libavutil/opt.h"
 #include "libavutil/timestamp.h"
 #include "audio.h"
+#include "formats.h"
 #include "avfilter.h"
 typedef struct {
 static int query_formats(AVFilterContext *ctx)
 {
     AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts = NULL;
     enum AVSampleFormat sample_fmts[] = {
         AV_SAMPLE_FMT_DBL,
         AV_SAMPLE_FMT_NONE
     };
     int packing_fmts[] = { AVFILTER_PACKED, -1 };
-    formats = avfilter_make_all_channel_layouts();
+    layouts = ff_all_channel_layouts();
-    if (!formats)
+    if (!layouts)
         return AVERROR(ENOMEM);
-    avfilter_set_common_channel_layouts(ctx, formats);
+    ff_set_common_channel_layouts(ctx, layouts);
     formats = avfilter_make_format_list(sample_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     avfilter_set_common_packing_formats(ctx, formats);
+    formats = ff_all_samplerates();
+    if (!formats)
+        return AVERROR(ENOMEM);
+    ff_set_common_samplerates(ctx, formats);
     return 0;
 }

libavfilter/af_volume.c+10−3

 #include "libavutil/eval.h"
 #include "audio.h"
 #include "avfilter.h"
+#include "formats.h"
 typedef struct {
     double volume;
 static int query_formats(AVFilterContext *ctx)
 {
     AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts;
     enum AVSampleFormat sample_fmts[] = {
         AV_SAMPLE_FMT_U8,
         AV_SAMPLE_FMT_S16,
     };
     int packing_fmts[] = { AVFILTER_PACKED, -1 };
-    formats = avfilter_make_all_channel_layouts();
+    layouts = ff_all_channel_layouts();
-    if (!formats)
+    if (!layouts)
         return AVERROR(ENOMEM);
-    avfilter_set_common_channel_layouts(ctx, formats);
+    ff_set_common_channel_layouts(ctx, layouts);
     formats = avfilter_make_format_list(sample_fmts);
     if (!formats)
         return AVERROR(ENOMEM);
     avfilter_set_common_packing_formats(ctx, formats);
+    formats = ff_all_samplerates();
+    if (!formats)
+        return AVERROR(ENOMEM);
+    ff_set_common_samplerates(ctx, formats);
     return 0;
 }

libavfilter/allfilters.c+9−1

     REGISTER_FILTER (ASHOWINFO,   ashowinfo,   af);
     REGISTER_FILTER (ASPLIT,      asplit,      af);
     REGISTER_FILTER (ASTREAMSYNC, astreamsync, af);
+    REGISTER_FILTER (ASYNCTS,     asyncts,     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 (ABUFFER,     abuffer,     asrc);
     REGISTER_FILTER (AEVALSRC,    aevalsrc,    asrc);
     REGISTER_FILTER (AMOVIE,      amovie,      asrc);
     REGISTER_FILTER (ANULLSRC,    anullsrc,    asrc);
         extern AVFilter avfilter_vsrc_buffer;
         avfilter_register(&avfilter_vsrc_buffer);
     }
+    {
+        extern AVFilter avfilter_asrc_abuffer;
+        avfilter_register(&avfilter_asrc_abuffer);
+    }
     {
         extern AVFilter avfilter_vsink_buffer;
         avfilter_register(&avfilter_vsink_buffer);
     }
+    {
+        extern AVFilter avfilter_asink_abuffer;
+        avfilter_register(&avfilter_asink_abuffer);
+    }
     {
         extern AVFilter avfilter_vf_scale;
         avfilter_register(&avfilter_vf_scale);

libavfilter/asrc_aevalsrc.c+1−1

@@ -190,7 +190,7 @@ static int query_formats(AVFilterContext *ctx) · 189 unmodified lines
190	int packing_fmts[] = { AVFILTER_PLANAR, -1 };	190	int packing_fmts[] = { AVFILTER_PLANAR, -1 };
191		191
192	avfilter_set_common_sample_formats (ctx, avfilter_make_format_list(sample_fmts));	192	avfilter_set_common_sample_formats (ctx, avfilter_make_format_list(sample_fmts));
193	avfilter_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));	193	ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
194	avfilter_set_common_packing_formats(ctx, avfilter_make_format_list(packing_fmts));	194	avfilter_set_common_packing_formats(ctx, avfilter_make_format_list(packing_fmts));
195		195
196	return 0;	196	return 0;

libavfilter/avcodec.c+0−71

@@ -24,77 +24,6 @@ · 23 unmodified lines
24	#include "avcodec.h"	24	#include "avcodec.h"
25	#include "libavutil/opt.h"	25	#include "libavutil/opt.h"
26		26
27	int avfilter_copy_frame_props(AVFilterBufferRef dst, const AVFrame src)
28	{
29	dst->pts = src->pts;
30	dst->pos = src->pkt_pos;
31	dst->format = src->format;
32
33	switch (dst->type) {
34	case AVMEDIA_TYPE_VIDEO:
35	dst->video->w = src->width;
36	dst->video->h = src->height;
37	dst->video->sample_aspect_ratio = src->sample_aspect_ratio;
38	dst->video->interlaced = src->interlaced_frame;
39	dst->video->top_field_first = src->top_field_first;
40	dst->video->key_frame = src->key_frame;
41	dst->video->pict_type = src->pict_type;
42	break;
43	case AVMEDIA_TYPE_AUDIO:
44	dst->audio->sample_rate = src->sample_rate;
45	dst->audio->channel_layout = src->channel_layout;
46	break;
47	default:
48	return AVERROR(EINVAL);
49	}
50
51	return 0;
52	}
53
54	int avfilter_copy_buf_props(AVFrame dst, const AVFilterBufferRef src)
55	{
56	int planes, nb_channels;
57
58	memcpy(dst->data, src->data, sizeof(dst->data));
59	memcpy(dst->linesize, src->linesize, sizeof(dst->linesize));
60
61	dst->pts = src->pts;
62	dst->format = src->format;
63
64	switch (src->type) {
65	case AVMEDIA_TYPE_VIDEO:
66	dst->width = src->video->w;
67	dst->height = src->video->h;
68	dst->sample_aspect_ratio = src->video->sample_aspect_ratio;
69	dst->interlaced_frame = src->video->interlaced;
70	dst->top_field_first = src->video->top_field_first;
71	dst->key_frame = src->video->key_frame;
72	dst->pict_type = src->video->pict_type;
73	break;
74	case AVMEDIA_TYPE_AUDIO:
75	nb_channels = av_get_channel_layout_nb_channels(src->audio->channel_layout);
76	planes = av_sample_fmt_is_planar(src->format) ? nb_channels : 1;
77
78	if (planes > FF_ARRAY_ELEMS(dst->data)) {
79	dst->extended_data = av_mallocz(planes * sizeof(*dst->extended_data));
80	if (!dst->extended_data)
81	return AVERROR(ENOMEM);
82	memcpy(dst->extended_data, src->extended_data,
83	planes * sizeof(dst->extended_data));
84	} else
85	dst->extended_data = dst->data;
86
87	dst->sample_rate = src->audio->sample_rate;
88	dst->channel_layout = src->audio->channel_layout;
89	dst->nb_samples = src->audio->nb_samples;
90	break;
91	default:
92	return AVERROR(EINVAL);
93	}
94
95	return 0;
96	}
97
98	AVFilterBufferRef avfilter_get_video_buffer_ref_from_frame(const AVFrame frame,	27	AVFilterBufferRef avfilter_get_video_buffer_ref_from_frame(const AVFrame frame,
99	int perms)	28	int perms)
100	{	29	{

libavfilter/avfilter.c+20−354

@@ -24,11 +24,11 @@ · 23 unmodified lines
24	#include "libavutil/pixdesc.h"	24	#include "libavutil/pixdesc.h"
25	#include "libavutil/rational.h"	25	#include "libavutil/rational.h"
26	#include "libavutil/audioconvert.h"	26	#include "libavutil/audioconvert.h"
27	#include "libavutil/imgutils.h"
28	#include "libavutil/avassert.h"	27	#include "libavutil/avassert.h"
29	#include "libavutil/avstring.h"	28	#include "libavutil/avstring.h"
30		29
31	#include "avfilter.h"	30	#include "avfilter.h"
		31	#include "formats.h"
32	#include "internal.h"	32	#include "internal.h"
33		33
34	unsigned avfilter_version(void) {	34	unsigned avfilter_version(void) {
@@ -47,7 +47,7 @@ const char *avfilter_license(void) · 12 unmodified lines
47	return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;	47	return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
48	}	48	}
49		49
50	static void command_queue_pop(AVFilterContext *filter)	50	void ff_command_queue_pop(AVFilterContext *filter)
51	{	51	{
52	AVFilterCommand *c= filter->command_queue;	52	AVFilterCommand *c= filter->command_queue;
53	av_freep(&c->arg);	53	av_freep(&c->arg);
@@ -56,133 +56,6 @@ static void command_queue_pop(AVFilterContext *filter) · 2 unmodified lines
56	av_free(c);	56	av_free(c);
57	}	57	}
58		58
59	AVFilterBufferRef avfilter_ref_buffer(AVFilterBufferRef ref, int pmask)
60	{
61	AVFilterBufferRef *ret = av_malloc(sizeof(AVFilterBufferRef));
62	if (!ret)
63	return NULL;
64	ret = ref;
65	if (ref->type == AVMEDIA_TYPE_VIDEO) {
66	ret->video = av_malloc(sizeof(AVFilterBufferRefVideoProps));
67	if (!ret->video) {
68	av_free(ret);
69	return NULL;
70	}
71	ret->video = ref->video;
72	ret->extended_data = ret->data;
73	} else if (ref->type == AVMEDIA_TYPE_AUDIO) {
74	ret->audio = av_malloc(sizeof(AVFilterBufferRefAudioProps));
75	if (!ret->audio) {
76	av_free(ret);
77	return NULL;
78	}
79	ret->audio = ref->audio;
80
81	if (ref->extended_data && ref->extended_data != ref->data) {
82	int nb_channels = av_get_channel_layout_nb_channels(ref->audio->channel_layout);
83	if (!(ret->extended_data = av_malloc(sizeof(ret->extended_data)
84	nb_channels))) {
85	av_freep(&ret->audio);
86	av_freep(&ret);
87	return NULL;
88	}
89	memcpy(ret->extended_data, ref->extended_data,
90	sizeof(ret->extended_data) nb_channels);
91	} else
92	ret->extended_data = ret->data;
93	}
94	ret->perms &= pmask;
95	ret->buf->refcount ++;
96	return ret;
97	}
98
99	static void free_pool(AVFilterPool *pool)
100	{
101	int i;
102
103	av_assert0(pool->refcount > 0);
104
105	for (i = 0; i < POOL_SIZE; i++) {
106	if (pool->pic[i]) {
107	AVFilterBufferRef *picref = pool->pic[i];
108	/* free buffer: picrefs stored in the pool are not
109	* supposed to contain a free callback */
110	av_assert0(!picref->buf->refcount);
111	av_freep(&picref->buf->data[0]);
112	av_freep(&picref->buf);
113
114	av_freep(&picref->audio);
115	av_freep(&picref->video);
116	av_freep(&pool->pic[i]);
117	pool->count--;
118	}
119	}
120	pool->draining = 1;
121
122	if (!--pool->refcount) {
123	av_assert0(!pool->count);
124	av_free(pool);
125	}
126	}
127
128	static void store_in_pool(AVFilterBufferRef *ref)
129	{
130	int i;
131	AVFilterPool *pool= ref->buf->priv;
132
133	av_assert0(ref->buf->data[0]);
134	av_assert0(pool->refcount>0);
135
136	if (pool->count == POOL_SIZE) {
137	AVFilterBufferRef *ref1 = pool->pic[0];
138	av_freep(&ref1->video);
139	av_freep(&ref1->audio);
140	av_freep(&ref1->buf->data[0]);
141	av_freep(&ref1->buf);
142	av_free(ref1);
143	memmove(&pool->pic[0], &pool->pic[1], sizeof(void)(POOL_SIZE-1));
144	pool->count--;
145	pool->pic[POOL_SIZE-1] = NULL;
146	}
147
148	for (i = 0; i < POOL_SIZE; i++) {
149	if (!pool->pic[i]) {
150	pool->pic[i] = ref;
151	pool->count++;
152	break;
153	}
154	}
155	if (pool->draining) {
156	free_pool(pool);
157	} else
158	--pool->refcount;
159	}
160
161	void avfilter_unref_buffer(AVFilterBufferRef *ref)
162	{
163	if (!ref)
164	return;
165	av_assert0(ref->buf->refcount > 0);
166	if (!(--ref->buf->refcount)) {
167	if (!ref->buf->free) {
168	store_in_pool(ref);
169	return;
170	}
171	ref->buf->free(ref->buf);
172	}
173	if (ref->extended_data != ref->data)
174	av_freep(&ref->extended_data);
175	av_freep(&ref->video);
176	av_freep(&ref->audio);
177	av_free(ref);
178	}
179
180	void avfilter_unref_bufferp(AVFilterBufferRef **ref)
181	{
182	avfilter_unref_buffer(*ref);
183	*ref = NULL;
184	}
185
186	void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,	59	void avfilter_insert_pad(unsigned idx, unsigned *count, size_t padidx_off,
187	AVFilterPad pads, AVFilterLink *links,	60	AVFilterPad pads, AVFilterLink *links,
188	AVFilterPad *newpad)	61	AVFilterPad *newpad)
@@ -240,7 +113,7 @@ void avfilter_link_free(AVFilterLink **link) · 51 unmodified lines
240	return;	113	return;
241		114
242	if ((*link)->pool)	115	if ((*link)->pool)
243	free_pool((*link)->pool);	116	ff_free_pool((*link)->pool);
244		117
245	av_freep(link);	118	av_freep(link);
246	}	119	}
@@ -272,12 +145,15 @@ int avfilter_insert_filter(AVFilterLink link, AVFilterContext filt, · 25 unmodified lines
272	if (link->out_formats)	145	if (link->out_formats)
273	avfilter_formats_changeref(&link->out_formats,	146	avfilter_formats_changeref(&link->out_formats,
274	&filt->outputs[filt_dstpad_idx]->out_formats);	147	&filt->outputs[filt_dstpad_idx]->out_formats);
275	if (link->out_chlayouts)	148	if (link->out_channel_layouts)
276	avfilter_formats_changeref(&link->out_chlayouts,	149	ff_channel_layouts_changeref(&link->out_channel_layouts,
277	&filt->outputs[filt_dstpad_idx]->out_chlayouts);	150	&filt->outputs[filt_dstpad_idx]->out_channel_layouts);
278	if (link->out_packing)	151	if (link->out_packing)
279	avfilter_formats_changeref(&link->out_packing,	152	avfilter_formats_changeref(&link->out_packing,
280	&filt->outputs[filt_dstpad_idx]->out_packing);	153	&filt->outputs[filt_dstpad_idx]->out_packing);
		154	if (link->out_samplerates)
		155	avfilter_formats_changeref(&link->out_samplerates,
		156	&filt->outputs[filt_dstpad_idx]->out_samplerates);
281		157
282	return 0;	158	return 0;
283	}	159	}
@@ -329,6 +205,7 @@ int avfilter_config_links(AVFilterContext *filter) · 45 unmodified lines
329	link->sample_aspect_ratio = inlink ?	205	link->sample_aspect_ratio = inlink ?
330	inlink->sample_aspect_ratio : (AVRational){1,1};	206	inlink->sample_aspect_ratio : (AVRational){1,1};
331		207
		208	#if 1
332	if (inlink) {	209	if (inlink) {
333	if (!link->w)	210	if (!link->w)
334	link->w = inlink->w;	211	link->w = inlink->w;
@@ -359,6 +236,7 @@ int avfilter_config_links(AVFilterContext *filter) · 24 unmodified lines
359	link->time_base = (AVRational) {1, link->sample_rate};	236	link->time_base = (AVRational) {1, link->sample_rate};
360	}	237	}
361		238
		239	#endif
362	if ((config_link = link->dstpad->config_props))	240	if ((config_link = link->dstpad->config_props))
363	if ((ret = config_link(link)) < 0)	241	if ((ret = config_link(link)) < 0)
364	return ret;	242	return ret;
@@ -370,47 +248,6 @@ int avfilter_config_links(AVFilterContext *filter) · 5 unmodified lines
370	return 0;	248	return 0;
371	}	249	}
372		250
373	static char ff_get_ref_perms_string(char buf, size_t buf_size, int perms)
374	{
375	snprintf(buf, buf_size, "%s%s%s%s%s%s",
376	perms & AV_PERM_READ ? "r" : "",
377	perms & AV_PERM_WRITE ? "w" : "",
378	perms & AV_PERM_PRESERVE ? "p" : "",
379	perms & AV_PERM_REUSE ? "u" : "",
380	perms & AV_PERM_REUSE2 ? "U" : "",
381	perms & AV_PERM_NEG_LINESIZES ? "n" : "");
382	return buf;
383	}
384
385	static void ff_dlog_ref(void ctx, AVFilterBufferRef ref, int end)
386	{
387	av_unused char buf[16];
388	av_dlog(ctx,
389	"ref[%p buf:%p refcount:%d perms:%s data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
390	ref, ref->buf, ref->buf->refcount, ff_get_ref_perms_string(buf, sizeof(buf), ref->perms), ref->data[0],
391	ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
392	ref->pts, ref->pos);
393
394	if (ref->video) {
395	av_dlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
396	ref->video->sample_aspect_ratio.num, ref->video->sample_aspect_ratio.den,
397	ref->video->w, ref->video->h,
398	!ref->video->interlaced ? 'P' : /* Progressive */
399	ref->video->top_field_first ? 'T' : 'B', /* Top / Bottom */
400	ref->video->key_frame,
401	av_get_picture_type_char(ref->video->pict_type));
402	}
403	if (ref->audio) {
404	av_dlog(ctx, " cl:%"PRId64"d n:%d r:%d p:%d",
405	ref->audio->channel_layout,
406	ref->audio->nb_samples,
407	ref->audio->sample_rate,
408	ref->audio->planar);
409	}
410
411	av_dlog(ctx, "]%s", end ? "\n" : "");
412	}
413
414	void ff_dlog_link(void ctx, AVFilterLink link, int end)	251	void ff_dlog_link(void ctx, AVFilterLink link, int end)
415	{	252	{
416	if (link->type == AVMEDIA_TYPE_VIDEO) {	253	if (link->type == AVMEDIA_TYPE_VIDEO) {
@@ -435,71 +272,6 @@ void ff_dlog_link(void ctx, AVFilterLink link, int end) · 18 unmodified lines
435	}	272	}
436	}	273	}
437		274
438	AVFilterBufferRef avfilter_get_video_buffer(AVFilterLink link, int perms, int w, int h)
439	{
440	AVFilterBufferRef *ret = NULL;
441
442	av_unused char buf[16];
443	FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0);
444	av_dlog(NULL, " perms:%s w:%d h:%d\n", ff_get_ref_perms_string(buf, sizeof(buf), perms), w, h);
445
446	if (link->dstpad->get_video_buffer)
447	ret = link->dstpad->get_video_buffer(link, perms, w, h);
448
449	if (!ret)
450	ret = avfilter_default_get_video_buffer(link, perms, w, h);
451
452	if (ret)
453	ret->type = AVMEDIA_TYPE_VIDEO;
454
455	FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " returning "); ff_dlog_ref(NULL, ret, 1);
456
457	return ret;
458	}
459
460	AVFilterBufferRef *
461	avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms,
462	int w, int h, enum PixelFormat format)
463	{
464	AVFilterBuffer *pic = av_mallocz(sizeof(AVFilterBuffer));
465	AVFilterBufferRef *picref = av_mallocz(sizeof(AVFilterBufferRef));
466
467	if (!pic \|\| !picref)
468	goto fail;
469
470	picref->buf = pic;
471	picref->buf->free = ff_avfilter_default_free_buffer;
472	if (!(picref->video = av_mallocz(sizeof(AVFilterBufferRefVideoProps))))
473	goto fail;
474
475	pic->w = picref->video->w = w;
476	pic->h = picref->video->h = h;
477
478	/* make sure the buffer gets read permission or it's useless for output */
479	picref->perms = perms \| AV_PERM_READ;
480
481	pic->refcount = 1;
482	picref->type = AVMEDIA_TYPE_VIDEO;
483	pic->format = picref->format = format;
484
485	memcpy(pic->data, data, 4*sizeof(data[0]));
486	memcpy(pic->linesize, linesize, 4*sizeof(linesize[0]));
487	memcpy(picref->data, pic->data, sizeof(picref->data));
488	memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
489
490	pic-> extended_data = pic->data;
491	picref->extended_data = picref->data;
492
493	return picref;
494
495	fail:
496	if (picref && picref->video)
497	av_free(picref->video);
498	av_free(picref);
499	av_free(pic);
500	return NULL;
501	}
502
503	int avfilter_request_frame(AVFilterLink *link)	275	int avfilter_request_frame(AVFilterLink *link)
504	{	276	{
505	FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);	277	FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1);
@@ -538,107 +310,6 @@ void ff_update_link_current_pts(AVFilterLink *link, int64_t pts) · 32 unmodified lines
538	ff_avfilter_graph_update_heap(link->graph, link);	310	ff_avfilter_graph_update_heap(link->graph, link);
539	}	311	}
540		312
541	/* XXX: should we do the duplicating of the picture ref here, instead of
542	* forcing the source filter to do it? */
543	void avfilter_start_frame(AVFilterLink link, AVFilterBufferRef picref)
544	{
545	void (start_frame)(AVFilterLink , AVFilterBufferRef *);
546	AVFilterPad *dst = link->dstpad;
547	int perms = picref->perms;
548	AVFilterCommand *cmd= link->dst->command_queue;
549
550	FF_DPRINTF_START(NULL, start_frame); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " "); ff_dlog_ref(NULL, picref, 1);
551
552	if (!(start_frame = dst->start_frame))
553	start_frame = avfilter_default_start_frame;
554
555	if (picref->linesize[0] < 0)
556	perms \|= AV_PERM_NEG_LINESIZES;
557	/* prepare to copy the picture if it has insufficient permissions */
558	if ((dst->min_perms & perms) != dst->min_perms \|\| dst->rej_perms & perms) {
559	av_log(link->dst, AV_LOG_DEBUG,
560	"frame copy needed (have perms %x, need %x, reject %x)\n",
561	picref->perms,
562	link->dstpad->min_perms, link->dstpad->rej_perms);
563
564	link->cur_buf = avfilter_get_video_buffer(link, dst->min_perms, link->w, link->h);
565	link->src_buf = picref;
566	avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);
567	}
568	else
569	link->cur_buf = picref;
570
571	while(cmd && cmd->time <= picref->pts * av_q2d(link->time_base)){
572	av_log(link->dst, AV_LOG_DEBUG,
573	"Processing command time:%f command:%s arg:%s\n",
574	cmd->time, cmd->command, cmd->arg);
575	avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
576	command_queue_pop(link->dst);
577	cmd= link->dst->command_queue;
578	}
579
580	start_frame(link, link->cur_buf);
581	ff_update_link_current_pts(link, link->cur_buf->pts);
582	}
583
584	void avfilter_end_frame(AVFilterLink *link)
585	{
586	void (end_frame)(AVFilterLink );
587
588	if (!(end_frame = link->dstpad->end_frame))
589	end_frame = avfilter_default_end_frame;
590
591	end_frame(link);
592
593	/* unreference the source picture if we're feeding the destination filter
594	* a copied version dues to permission issues */
595	if (link->src_buf) {
596	avfilter_unref_buffer(link->src_buf);
597	link->src_buf = NULL;
598	}
599	}
600
601	void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
602	{
603	uint8_t src[4], dst[4];
604	int i, j, vsub;
605	void (draw_slice)(AVFilterLink , int, int, int);
606
607	FF_DPRINTF_START(NULL, draw_slice); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
608
609	/* copy the slice if needed for permission reasons */
610	if (link->src_buf) {
611	vsub = av_pix_fmt_descriptors[link->format].log2_chroma_h;
612
613	for (i = 0; i < 4; i++) {
614	if (link->src_buf->data[i]) {
615	src[i] = link->src_buf-> data[i] +
616	(y >> (i==1 \|\| i==2 ? vsub : 0)) * link->src_buf-> linesize[i];
617	dst[i] = link->cur_buf->data[i] +
618	(y >> (i==1 \|\| i==2 ? vsub : 0)) * link->cur_buf->linesize[i];
619	} else
620	src[i] = dst[i] = NULL;
621	}
622
623	for (i = 0; i < 4; i++) {
624	int planew =
625	av_image_get_linesize(link->format, link->cur_buf->video->w, i);
626
627	if (!src[i]) continue;
628
629	for (j = 0; j < h >> (i==1 \|\| i==2 ? vsub : 0); j++) {
630	memcpy(dst[i], src[i], planew);
631	src[i] += link->src_buf->linesize[i];
632	dst[i] += link->cur_buf->linesize[i];
633	}
634	}
635	}
636
637	if (!(draw_slice = link->dstpad->draw_slice))
638	draw_slice = avfilter_default_draw_slice;
639	draw_slice(link, y, h, slice_dir);
640	}
641
642	int avfilter_process_command(AVFilterContext filter, const char cmd, const char arg, char res, int res_len, int flags)	313	int avfilter_process_command(AVFilterContext filter, const char cmd, const char arg, char res, int res_len, int flags)
643	{	314	{
644	if(!strcmp(cmd, "ping")){	315	if(!strcmp(cmd, "ping")){
@@ -788,6 +459,10 @@ void avfilter_free(AVFilterContext *filter) · 143 unmodified lines
788	link->src->outputs[link->srcpad - link->src->output_pads] = NULL;	459	link->src->outputs[link->srcpad - link->src->output_pads] = NULL;
789	avfilter_formats_unref(&link->in_formats);	460	avfilter_formats_unref(&link->in_formats);
790	avfilter_formats_unref(&link->out_formats);	461	avfilter_formats_unref(&link->out_formats);
		462	avfilter_formats_unref(&link->in_samplerates);
		463	avfilter_formats_unref(&link->out_samplerates);
		464	ff_channel_layouts_unref(&link->in_channel_layouts);
		465	ff_channel_layouts_unref(&link->out_channel_layouts);
791	}	466	}
792	avfilter_link_free(&link);	467	avfilter_link_free(&link);
793	}	468	}
@@ -797,6 +472,10 @@ void avfilter_free(AVFilterContext *filter) · 3 unmodified lines
797	link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;	472	link->dst->inputs[link->dstpad - link->dst->input_pads] = NULL;
798	avfilter_formats_unref(&link->in_formats);	473	avfilter_formats_unref(&link->in_formats);
799	avfilter_formats_unref(&link->out_formats);	474	avfilter_formats_unref(&link->out_formats);
		475	avfilter_formats_unref(&link->in_samplerates);
		476	avfilter_formats_unref(&link->out_samplerates);
		477	ff_channel_layouts_unref(&link->in_channel_layouts);
		478	ff_channel_layouts_unref(&link->out_channel_layouts);
800	}	479	}
801	avfilter_link_free(&link);	480	avfilter_link_free(&link);
802	}	481	}
@@ -808,7 +487,7 @@ void avfilter_free(AVFilterContext *filter) · 5 unmodified lines
808	av_freep(&filter->outputs);	487	av_freep(&filter->outputs);
809	av_freep(&filter->priv);	488	av_freep(&filter->priv);
810	while(filter->command_queue){	489	while(filter->command_queue){
811	command_queue_pop(filter);	490	ff_command_queue_pop(filter);
812	}	491	}
813	av_free(filter);	492	av_free(filter);
814	}	493	}
@@ -821,16 +500,3 @@ int avfilter_init_filter(AVFilterContext filter, const char args, void *opaque · 6 unmodified lines
821	ret = filter->filter->init(filter, args, opaque);	500	ret = filter->filter->init(filter, args, opaque);
822	return ret;	501	return ret;
823	}	502	}
824
825	void avfilter_copy_buffer_ref_props(AVFilterBufferRef dst, AVFilterBufferRef src)
826	{
827	// copy common properties
828	dst->pts = src->pts;
829	dst->pos = src->pos;
830
831	switch (src->type) {
832	case AVMEDIA_TYPE_VIDEO: dst->video = src->video; break;
833	case AVMEDIA_TYPE_AUDIO: dst->audio = src->audio; break;
834	default: break;
835	}
836	}

libavfilter/avfilter.h+17−15

  * pointer to each of the pointers to itself.
  */
 typedef struct AVFilterFormats {
-    unsigned format_count;      ///< number of formats
     int64_t *formats;           ///< list of media formats
+    unsigned format_count;      ///< number of formats
     unsigned refcount;          ///< number of references to this list
     struct AVFilterFormats ***refs; ///< references to this list
  * @return the format list, with no existing references
  */
 AVFilterFormats *avfilter_make_format_list(const int *fmts);
-AVFilterFormats *avfilter_make_format64_list(const int64_t *fmts);
 /**
  * Add fmt to the list of media formats contained in *avff.
  */
 extern const int64_t avfilter_all_channel_layouts[];
-/**
- * Return a list of all channel layouts supported by FFmpeg.
- */
-AVFilterFormats *avfilter_make_all_channel_layouts(void);
 /**
  * Return a list of all audio packing formats.
  */
  * formats/layouts. If there are no links hooked to this filter, the list
  * of formats is freed.
  */
+void avfilter_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats);
 void avfilter_set_common_pixel_formats(AVFilterContext *ctx, AVFilterFormats *formats);
 void avfilter_set_common_sample_formats(AVFilterContext *ctx, AVFilterFormats *formats);
 void avfilter_set_common_channel_layouts(AVFilterContext *ctx, AVFilterFormats *formats);
     AVFilterFormats *in_formats;
     AVFilterFormats *out_formats;
-    AVFilterFormats *in_chlayouts;
-    AVFilterFormats *out_chlayouts;
     AVFilterFormats *in_packing;
     AVFilterFormats *out_packing;
      */
     int64_t current_pts;
-    /**
+    /*****************************************************************
-     * Private fields
+     * All fields below this line are not part of the public API. They
-     *
+     * may not be used outside of libavfilter and can be changed and
-     * The following fields are for internal use only.
+     * removed at will.
-     * Their type, offset, number and semantic can change without notice.
+     * New public fields should be added right above.
+     *****************************************************************
      */
     /**
      * Index in the age array.
      */
     int age_index;
+    /**
+     * Lists of channel layouts and sample rates used for automatic
+     * negotiation.
+     */
+    AVFilterFormats  *in_samplerates;
+    AVFilterFormats *out_samplerates;
+    struct AVFilterChannelLayouts  *in_channel_layouts;
+    struct AVFilterChannelLayouts *out_channel_layouts;
 };
 /**

libavfilter/avfiltergraph.c+286−50

@@ -28,8 +28,10 @@ · 27 unmodified lines
28	#include "libavutil/pixdesc.h"	28	#include "libavutil/pixdesc.h"
29	#include "avfilter.h"	29	#include "avfilter.h"
30	#include "avfiltergraph.h"	30	#include "avfiltergraph.h"
		31	#include "formats.h"
31	#include "internal.h"	32	#include "internal.h"
32		33
		34	#include "libavutil/audioconvert.h"
33	#include "libavutil/log.h"	35	#include "libavutil/log.h"
34		36
35	static const AVClass filtergraph_class = {	37	static const AVClass filtergraph_class = {
@@ -198,10 +200,10 @@ static int insert_conv_filter(AVFilterGraph graph, AVFilterLink link, · 162 unmodified lines
198		200
199	if (link->type == AVMEDIA_TYPE_AUDIO &&	201	if (link->type == AVMEDIA_TYPE_AUDIO &&
200	(((link = filt_ctx-> inputs[0]) &&	202	(((link = filt_ctx-> inputs[0]) &&
201	(!avfilter_merge_formats(link->in_chlayouts, link->out_chlayouts) \|\|	203	(!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) \|\|
202	!avfilter_merge_formats(link->in_packing, link->out_packing))) \|\|	204	!avfilter_merge_formats(link->in_packing, link->out_packing))) \|\|
203	((link = filt_ctx->outputs[0]) &&	205	((link = filt_ctx->outputs[0]) &&
204	(!avfilter_merge_formats(link->in_chlayouts, link->out_chlayouts) \|\|	206	(!ff_merge_channel_layouts(link->in_channel_layouts, link->out_channel_layouts) \|\|
205	!avfilter_merge_formats(link->in_packing, link->out_packing))))	207	!avfilter_merge_formats(link->in_packing, link->out_packing))))
206	) {	208	) {
207	av_log(NULL, AV_LOG_ERROR,	209	av_log(NULL, AV_LOG_ERROR,
@@ -217,7 +219,10 @@ static int query_formats(AVFilterGraph graph, AVClass log_ctx) · 9 unmodified lines
217	{	219	{
218	int i, j, ret;	220	int i, j, ret;
219	char filt_args[128];	221	char filt_args[128];
220	AVFilterFormats formats, chlayouts, *packing;	222	AVFilterFormats formats, packing;
		223	AVFilterChannelLayouts *chlayouts;
		224	AVFilterFormats *samplerates;
		225	int scaler_count = 0, resampler_count = 0;
221		226
222	/* ask all the sub-filters for their supported media formats */	227	/* ask all the sub-filters for their supported media formats */
223	for (i = 0; i < graph->filter_count; i++) {	228	for (i = 0; i < graph->filter_count; i++) {
@@ -233,6 +238,7 @@ static int query_formats(AVFilterGraph graph, AVClass log_ctx) · 9 unmodified lines
233		238
234	for (j = 0; j < filter->input_count; j++) {	239	for (j = 0; j < filter->input_count; j++) {
235	AVFilterLink *link = filter->inputs[j];	240	AVFilterLink *link = filter->inputs[j];
		241	#if 0
236	if (!link) continue;	242	if (!link) continue;
237		243
238	if (!link->in_formats \|\| !link->out_formats)	244	if (!link->in_formats \|\| !link->out_formats)
@@ -248,7 +254,7 @@ static int query_formats(AVFilterGraph graph, AVClass log_ctx) · 9 unmodified lines
248	return ret;	254	return ret;
249	}	255	}
250	else if (link->type == AVMEDIA_TYPE_AUDIO) {	256	else if (link->type == AVMEDIA_TYPE_AUDIO) {
251	if (!link->in_chlayouts \|\| !link->out_chlayouts \|\|	257	if (!link->in_channel_layouts \|\| !link->out_channel_layouts \|\|
252	!link->in_packing \|\| !link->out_packing)	258	!link->in_packing \|\| !link->out_packing)
253	return AVERROR(EINVAL);	259	return AVERROR(EINVAL);
254		260
@@ -256,11 +262,100 @@ static int query_formats(AVFilterGraph graph, AVClass log_ctx) · 1 unmodified line
256	* three categories, aconvert will use a common format	262	* three categories, aconvert will use a common format
257	* whenever possible. */	263	* whenever possible. */
258	formats = avfilter_merge_formats(link->in_formats, link->out_formats);	264	formats = avfilter_merge_formats(link->in_formats, link->out_formats);
259	chlayouts = avfilter_merge_formats(link->in_chlayouts, link->out_chlayouts);	265	chlayouts = ff_merge_channel_layouts(link->in_channel_layouts , link->out_channel_layouts);
		266	samplerates = ff_merge_samplerates (link->in_samplerates, link->out_samplerates);
260	packing = avfilter_merge_formats(link->in_packing, link->out_packing);	267	packing = avfilter_merge_formats(link->in_packing, link->out_packing);
261	if (!formats \|\| !chlayouts \|\| !packing)	268
		269	if (!formats \|\| !chlayouts \|\| !packing \|\| !samplerates)
262	if (ret = insert_conv_filter(graph, link, "aconvert", NULL))	270	if (ret = insert_conv_filter(graph, link, "aconvert", NULL))
263	return ret;	271	return ret;
		272	#else
		273	int convert_needed = 0;
		274
		275	if (!link)
		276	continue;
		277
		278	if (link->in_formats != link->out_formats &&
		279	!avfilter_merge_formats(link->in_formats,
		280	link->out_formats))
		281	convert_needed = 1;
		282	if (link->type == AVMEDIA_TYPE_AUDIO) {
		283	if (link->in_channel_layouts != link->out_channel_layouts &&
		284	!ff_merge_channel_layouts(link->in_channel_layouts,
		285	link->out_channel_layouts))
		286	convert_needed = 1;
		287	if (link->in_samplerates != link->out_samplerates &&
		288	!ff_merge_samplerates(link->in_samplerates,
		289	link->out_samplerates))
		290	convert_needed = 1;
		291	}
		292
		293	if (convert_needed) {
		294	AVFilterContext *convert;
		295	AVFilter *filter;
		296	AVFilterLink inlink, outlink;
		297	char scale_args[256];
		298	char inst_name[30];
		299
		300	/* couldn't merge format lists. auto-insert conversion filter */
		301	switch (link->type) {
		302	case AVMEDIA_TYPE_VIDEO:
		303	snprintf(inst_name, sizeof(inst_name), "auto-inserted scaler %d",
		304	scaler_count++);
		305	snprintf(scale_args, sizeof(scale_args), "0:0:%s", graph->scale_sws_opts);
		306	if ((ret = avfilter_graph_create_filter(&convert,
		307	avfilter_get_by_name("scale"),
		308	inst_name, scale_args, NULL,
		309	graph)) < 0)
		310	return ret;
		311	break;
		312	case AVMEDIA_TYPE_AUDIO:
		313	if (!(filter = avfilter_get_by_name("resample"))) {
		314	av_log(log_ctx, AV_LOG_ERROR, "'resample' filter "
		315	"not present, cannot convert audio formats.\n");
		316	return AVERROR(EINVAL);
		317	}
		318
		319	snprintf(inst_name, sizeof(inst_name), "auto-inserted resampler %d",
		320	resampler_count++);
		321	if ((ret = avfilter_graph_create_filter(&convert,
		322	avfilter_get_by_name("resample"),
		323	inst_name, NULL, NULL, graph)) < 0)
		324	return ret;
		325	break;
		326	default:
		327	return AVERROR(EINVAL);
		328	}
		329
		330	if ((ret = avfilter_insert_filter(link, convert, 0, 0)) < 0)
		331	return ret;
		332
		333	convert->filter->query_formats(convert);
		334	inlink = convert->inputs[0];
		335	outlink = convert->outputs[0];
		336	if (!avfilter_merge_formats( inlink->in_formats, inlink->out_formats) \|\|
		337	!avfilter_merge_formats(outlink->in_formats, outlink->out_formats))
		338	ret \|= AVERROR(ENOSYS);
		339	if (inlink->type == AVMEDIA_TYPE_AUDIO &&
		340	(!ff_merge_samplerates(inlink->in_samplerates,
		341	inlink->out_samplerates) \|\|
		342	!ff_merge_channel_layouts(inlink->in_channel_layouts,
		343	inlink->out_channel_layouts)))
		344	ret \|= AVERROR(ENOSYS);
		345	if (outlink->type == AVMEDIA_TYPE_AUDIO &&
		346	(!ff_merge_samplerates(outlink->in_samplerates,
		347	outlink->out_samplerates) \|\|
		348	!ff_merge_channel_layouts(outlink->in_channel_layouts,
		349	outlink->out_channel_layouts)))
		350	ret \|= AVERROR(ENOSYS);
		351
		352	if (ret < 0) {
		353	av_log(log_ctx, AV_LOG_ERROR,
		354	"Impossible to convert between the formats supported by the filter "
		355	"'%s' and the filter '%s'\n", link->src->name, link->dst->name);
		356	return ret;
		357	}
		358	#endif
264	}	359	}
265	}	360	}
266	}	361	}
@@ -268,10 +363,10 @@ static int query_formats(AVFilterGraph graph, AVClass log_ctx) · 1 unmodified line
268	return 0;	363	return 0;
269	}	364	}
270		365
271	static void pick_format(AVFilterLink link, AVFilterLink ref)	366	static int pick_format(AVFilterLink link, AVFilterLink ref)
272	{	367	{
273	if (!link \|\| !link->in_formats)	368	if (!link \|\| !link->in_formats)
274	return;	369	return 0;
275		370
276	if (link->type == AVMEDIA_TYPE_VIDEO) {	371	if (link->type == AVMEDIA_TYPE_VIDEO) {
277	if(ref && ref->type == AVMEDIA_TYPE_VIDEO){	372	if(ref && ref->type == AVMEDIA_TYPE_VIDEO){
@@ -288,50 +383,83 @@ static void pick_format(AVFilterLink link, AVFilterLink ref) · 10 unmodified lines
288		383
289	link->in_formats->format_count = 1;	384	link->in_formats->format_count = 1;
290	link->format = link->in_formats->formats[0];	385	link->format = link->in_formats->formats[0];
291	avfilter_formats_unref(&link->in_formats);
292	avfilter_formats_unref(&link->out_formats);
293		386
294	if (link->type == AVMEDIA_TYPE_AUDIO) {	387	if (link->type == AVMEDIA_TYPE_AUDIO) {
295	link->in_chlayouts->format_count = 1;	388	if (!link->in_samplerates->format_count) {
296	link->channel_layout = link->in_chlayouts->formats[0];	389	av_log(link->src, AV_LOG_ERROR, "Cannot select sample rate for"
297	avfilter_formats_unref(&link->in_chlayouts);	390	" the link between filters %s and %s.\n", link->src->name,
298	avfilter_formats_unref(&link->out_chlayouts);	391	link->dst->name);
299		392	return AVERROR(EINVAL);
300	link->in_packing->format_count = 1;	393	}
301	link->planar = link->in_packing->formats[0] == AVFILTER_PLANAR;	394	link->in_samplerates->format_count = 1;
302	avfilter_formats_unref(&link->in_packing);	395	link->sample_rate = link->in_samplerates->formats[0];
303	avfilter_formats_unref(&link->out_packing);	396
		397	if (!link->in_channel_layouts->nb_channel_layouts) {
		398	av_log(link->src, AV_LOG_ERROR, "Cannot select channel layout for"
		399	"the link between filters %s and %s.\n", link->src->name,
		400	link->dst->name);
		401	return AVERROR(EINVAL);
		402	}
		403	link->in_channel_layouts->nb_channel_layouts = 1;
		404	link->channel_layout = link->in_channel_layouts->channel_layouts[0];
304	}	405	}
		406
		407	avfilter_formats_unref(&link->in_formats);
		408	avfilter_formats_unref(&link->out_formats);
		409	avfilter_formats_unref(&link->in_samplerates);
		410	avfilter_formats_unref(&link->out_samplerates);
		411	ff_channel_layouts_unref(&link->in_channel_layouts);
		412	ff_channel_layouts_unref(&link->out_channel_layouts);
		413
		414	return 0;
305	}	415	}
306		416
		417	#define REDUCE_FORMATS(fmt_type, list_type, list, var, nb, add_format) \
		418	do { \
		419	for (i = 0; i < filter->input_count; i++) { \
		420	AVFilterLink *link = filter->inputs[i]; \
		421	fmt_type fmt; \
		422	\
		423	if (!link->out_ ## list \|\| link->out_ ## list->nb != 1) \
		424	continue; \
		425	fmt = link->out_ ## list->var[0]; \
		426	\
		427	for (j = 0; j < filter->output_count; j++) { \
		428	AVFilterLink *out_link = filter->outputs[j]; \
		429	list_type *fmts; \
		430	\
		431	if (link->type != out_link->type \|\| \
		432	out_link->in_ ## list->nb == 1) \
		433	continue; \
		434	fmts = out_link->in_ ## list; \
		435	\
		436	if (!out_link->in_ ## list->nb) { \
		437	add_format(&out_link->in_ ##list, fmt); \
		438	break; \
		439	} \
		440	\
		441	for (k = 0; k < out_link->in_ ## list->nb; k++) \
		442	if (fmts->var[k] == fmt) { \
		443	fmts->var[0] = fmt; \
		444	fmts->nb = 1; \
		445	ret = 1; \
		446	break; \
		447	} \
		448	} \
		449	} \
		450	} while (0)
		451
307	static int reduce_formats_on_filter(AVFilterContext *filter)	452	static int reduce_formats_on_filter(AVFilterContext *filter)
308	{	453	{
309	int i, j, k, ret = 0;	454	int i, j, k, ret = 0;
310		455
311	for (i = 0; i < filter->input_count; i++) {	456	REDUCE_FORMATS(int, AVFilterFormats, formats, formats,
312	AVFilterLink *link = filter->inputs[i];	457	format_count, avfilter_add_format);
313	int format = link->out_formats->formats[0];	458	REDUCE_FORMATS(int, AVFilterFormats, samplerates, formats,
314		459	format_count, avfilter_add_format);
315	if (link->out_formats->format_count != 1)	460	REDUCE_FORMATS(uint64_t, AVFilterChannelLayouts, channel_layouts,
316	continue;	461	channel_layouts, nb_channel_layouts, ff_add_channel_layout);
317
318	for (j = 0; j < filter->output_count; j++) {
319	AVFilterLink *out_link = filter->outputs[j];
320	AVFilterFormats *fmts = out_link->in_formats;
321
322	if (link->type != out_link->type \|\|
323	out_link->in_formats->format_count == 1)
324	continue;
325		462
326	for (k = 0; k < out_link->in_formats->format_count; k++)
327	if (fmts->formats[k] == format) {
328	fmts->formats[0] = format;
329	fmts->format_count = 1;
330	ret = 1;
331	break;
332	}
333	}
334	}
335	return ret;	463	return ret;
336	}	464	}
337		465
@@ -347,9 +475,109 @@ static void reduce_formats(AVFilterGraph *graph) · 9 unmodified lines
347	} while (reduced);	475	} while (reduced);
348	}	476	}
349		477
350	static void pick_formats(AVFilterGraph *graph)	478	static void swap_samplerates_on_filter(AVFilterContext *filter)
		479	{
		480	AVFilterLink *link = NULL;
		481	int sample_rate;
		482	int i, j;
		483
		484	for (i = 0; i < filter->input_count; i++) {
		485	link = filter->inputs[i];
		486
		487	if (link->type == AVMEDIA_TYPE_AUDIO &&
		488	link->out_samplerates->format_count == 1)
		489	break;
		490	}
		491	if (i == filter->input_count)
		492	return;
		493
		494	sample_rate = link->out_samplerates->formats[0];
		495
		496	for (i = 0; i < filter->output_count; i++) {
		497	AVFilterLink *outlink = filter->outputs[i];
		498	int best_idx, best_diff = INT_MAX;
		499
		500	if (outlink->type != AVMEDIA_TYPE_AUDIO \|\|
		501	outlink->in_samplerates->format_count < 2)
		502	continue;
		503
		504	for (j = 0; j < outlink->in_samplerates->format_count; j++) {
		505	int diff = abs(sample_rate - outlink->in_samplerates->formats[j]);
		506
		507	if (diff < best_diff) {
		508	best_diff = diff;
		509	best_idx = j;
		510	}
		511	}
		512	FFSWAP(int, outlink->in_samplerates->formats[0],
		513	outlink->in_samplerates->formats[best_idx]);
		514	}
		515	}
		516
		517	static void swap_samplerates(AVFilterGraph *graph)
351	{	518	{
		519	int i;
		520
		521	for (i = 0; i < graph->filter_count; i++)
		522	swap_samplerates_on_filter(graph->filters[i]);
		523	}
		524
		525	static void swap_channel_layouts_on_filter(AVFilterContext *filter)
		526	{
		527	AVFilterLink *link = NULL;
		528	uint64_t chlayout;
352	int i, j;	529	int i, j;
		530
		531	for (i = 0; i < filter->input_count; i++) {
		532	link = filter->inputs[i];
		533
		534	if (link->type == AVMEDIA_TYPE_AUDIO &&
		535	link->out_channel_layouts->nb_channel_layouts == 1)
		536	break;
		537	}
		538	if (i == filter->input_count)
		539	return;
		540
		541	chlayout = link->out_channel_layouts->channel_layouts[0];
		542
		543	for (i = 0; i < filter->output_count; i++) {
		544	AVFilterLink *outlink = filter->outputs[i];
		545	int best_idx, best_score = INT_MIN;
		546
		547	if (outlink->type != AVMEDIA_TYPE_AUDIO \|\|
		548	outlink->in_channel_layouts->nb_channel_layouts < 2)
		549	continue;
		550
		551	for (j = 0; j < outlink->in_channel_layouts->nb_channel_layouts; j++) {
		552	uint64_t out_chlayout = outlink->in_channel_layouts->channel_layouts[j];
		553	int matched_channels = av_get_channel_layout_nb_channels(chlayout &
		554	out_chlayout);
		555	int extra_channels = av_get_channel_layout_nb_channels(out_chlayout &
		556	(~chlayout));
		557	int score = matched_channels - extra_channels;
		558
		559	if (score > best_score) {
		560	best_score = score;
		561	best_idx = j;
		562	}
		563	}
		564	FFSWAP(uint64_t, outlink->in_channel_layouts->channel_layouts[0],
		565	outlink->in_channel_layouts->channel_layouts[best_idx]);
		566	}
		567
		568	}
		569
		570	static void swap_channel_layouts(AVFilterGraph *graph)
		571	{
		572	int i;
		573
		574	for (i = 0; i < graph->filter_count; i++)
		575	swap_channel_layouts_on_filter(graph->filters[i]);
		576	}
		577
		578	static int pick_formats(AVFilterGraph *graph)
		579	{
		580	int i, j, ret;
353	int change;	581	int change;
354		582
355	do{	583	do{
@@ -385,13 +613,15 @@ static void pick_formats(AVFilterGraph *graph) · 29 unmodified lines
385		613
386	for (i = 0; i < graph->filter_count; i++) {	614	for (i = 0; i < graph->filter_count; i++) {
387	AVFilterContext *filter = graph->filters[i];	615	AVFilterContext *filter = graph->filters[i];
388	if (1) {	616
389	for (j = 0; j < filter->input_count; j++)	617	for (j = 0; j < filter->input_count; j++)
390	pick_format(filter->inputs[j], NULL);	618	if ((ret = pick_format(filter->inputs[j], NULL)) < 0)
391	for (j = 0; j < filter->output_count; j++)	619	return ret;
392	pick_format(filter->outputs[j], NULL);	620	for (j = 0; j < filter->output_count; j++)
393	}	621	if ((ret = pick_format(filter->outputs[j], NULL)) < 0)
		622	return ret;
394	}	623	}
		624	return 0;
395	}	625	}
396		626
397	int ff_avfilter_graph_config_formats(AVFilterGraph graph, AVClass log_ctx)	627	int ff_avfilter_graph_config_formats(AVFilterGraph graph, AVClass log_ctx)
@@ -407,7 +637,13 @@ int ff_avfilter_graph_config_formats(AVFilterGraph graph, AVClass log_ctx) · 9 unmodified lines
407	* of format conversion inside filters */	637	* of format conversion inside filters */
408	reduce_formats(graph);	638	reduce_formats(graph);
409		639
410	pick_formats(graph);	640	/* for audio filters, ensure the best sample rate and channel layout
		641	* is selected */
		642	swap_samplerates(graph);
		643	swap_channel_layouts(graph);
		644
		645	if ((ret = pick_formats(graph)) < 0)
		646	return ret;
411		647
412	return 0;	648	return 0;
413	}	649	}

libavfilter/buffer.c+244−0

@@ -0,0 +1,244 @@
	1	/*
	2	* This file is part of FFmpeg.
	3	*
	4	* FFmpeg 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	* FFmpeg 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 FFmpeg; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#include "libavutil/audioconvert.h"
	20	#include "libavutil/avassert.h"
	21	#include "libavcodec/avcodec.h"
	22
	23	#include "avfilter.h"
	24	#include "internal.h"
	25	#include "avcodec.h"
	26
	27	void ff_avfilter_default_free_buffer(AVFilterBuffer *ptr)
	28	{
	29	if (ptr->extended_data != ptr->data)
	30	av_freep(&ptr->extended_data);
	31	av_free(ptr->data[0]);
	32	av_free(ptr);
	33	}
	34
	35	AVFilterBufferRef avfilter_ref_buffer(AVFilterBufferRef ref, int pmask)
	36	{
	37	AVFilterBufferRef *ret = av_malloc(sizeof(AVFilterBufferRef));
	38	if (!ret)
	39	return NULL;
	40	ret = ref;
	41	if (ref->type == AVMEDIA_TYPE_VIDEO) {
	42	ret->video = av_malloc(sizeof(AVFilterBufferRefVideoProps));
	43	if (!ret->video) {
	44	av_free(ret);
	45	return NULL;
	46	}
	47	ret->video = ref->video;
	48	ret->extended_data = ret->data;
	49	} else if (ref->type == AVMEDIA_TYPE_AUDIO) {
	50	ret->audio = av_malloc(sizeof(AVFilterBufferRefAudioProps));
	51	if (!ret->audio) {
	52	av_free(ret);
	53	return NULL;
	54	}
	55	ret->audio = ref->audio;
	56
	57	if (ref->extended_data && ref->extended_data != ref->data) {
	58	int nb_channels = av_get_channel_layout_nb_channels(ref->audio->channel_layout);
	59	if (!(ret->extended_data = av_malloc(sizeof(ret->extended_data)
	60	nb_channels))) {
	61	av_freep(&ret->audio);
	62	av_freep(&ret);
	63	return NULL;
	64	}
	65	memcpy(ret->extended_data, ref->extended_data,
	66	sizeof(ret->extended_data) nb_channels);
	67	} else
	68	ret->extended_data = ret->data;
	69	}
	70	ret->perms &= pmask;
	71	ret->buf->refcount ++;
	72	return ret;
	73	}
	74
	75	void ff_free_pool(AVFilterPool *pool)
	76	{
	77	int i;
	78
	79	av_assert0(pool->refcount > 0);
	80
	81	for (i = 0; i < POOL_SIZE; i++) {
	82	if (pool->pic[i]) {
	83	AVFilterBufferRef *picref = pool->pic[i];
	84	/* free buffer: picrefs stored in the pool are not
	85	* supposed to contain a free callback */
	86	av_assert0(!picref->buf->refcount);
	87	av_freep(&picref->buf->data[0]);
	88	av_freep(&picref->buf);
	89
	90	av_freep(&picref->audio);
	91	av_freep(&picref->video);
	92	av_freep(&pool->pic[i]);
	93	pool->count--;
	94	}
	95	}
	96	pool->draining = 1;
	97
	98	if (!--pool->refcount) {
	99	av_assert0(!pool->count);
	100	av_free(pool);
	101	}
	102	}
	103
	104	static void store_in_pool(AVFilterBufferRef *ref)
	105	{
	106	int i;
	107	AVFilterPool *pool= ref->buf->priv;
	108
	109	av_assert0(ref->buf->data[0]);
	110	av_assert0(pool->refcount>0);
	111
	112	if (pool->count == POOL_SIZE) {
	113	AVFilterBufferRef *ref1 = pool->pic[0];
	114	av_freep(&ref1->video);
	115	av_freep(&ref1->audio);
	116	av_freep(&ref1->buf->data[0]);
	117	av_freep(&ref1->buf);
	118	av_free(ref1);
	119	memmove(&pool->pic[0], &pool->pic[1], sizeof(void)(POOL_SIZE-1));
	120	pool->count--;
	121	pool->pic[POOL_SIZE-1] = NULL;
	122	}
	123
	124	for (i = 0; i < POOL_SIZE; i++) {
	125	if (!pool->pic[i]) {
	126	pool->pic[i] = ref;
	127	pool->count++;
	128	break;
	129	}
	130	}
	131	if (pool->draining) {
	132	ff_free_pool(pool);
	133	} else
	134	--pool->refcount;
	135	}
	136
	137	void avfilter_unref_buffer(AVFilterBufferRef *ref)
	138	{
	139	if (!ref)
	140	return;
	141	av_assert0(ref->buf->refcount > 0);
	142	if (!(--ref->buf->refcount)) {
	143	if (!ref->buf->free) {
	144	store_in_pool(ref);
	145	return;
	146	}
	147	ref->buf->free(ref->buf);
	148	}
	149	if (ref->extended_data != ref->data)
	150	av_freep(&ref->extended_data);
	151	av_freep(&ref->video);
	152	av_freep(&ref->audio);
	153	av_free(ref);
	154	}
	155
	156	void avfilter_unref_bufferp(AVFilterBufferRef **ref)
	157	{
	158	avfilter_unref_buffer(*ref);
	159	*ref = NULL;
	160	}
	161
	162	int avfilter_copy_frame_props(AVFilterBufferRef dst, const AVFrame src)
	163	{
	164	dst->pts = src->pts;
	165	dst->pos = src->pkt_pos;
	166	dst->format = src->format;
	167
	168	switch (dst->type) {
	169	case AVMEDIA_TYPE_VIDEO:
	170	dst->video->w = src->width;
	171	dst->video->h = src->height;
	172	dst->video->sample_aspect_ratio = src->sample_aspect_ratio;
	173	dst->video->interlaced = src->interlaced_frame;
	174	dst->video->top_field_first = src->top_field_first;
	175	dst->video->key_frame = src->key_frame;
	176	dst->video->pict_type = src->pict_type;
	177	break;
	178	case AVMEDIA_TYPE_AUDIO:
	179	dst->audio->sample_rate = src->sample_rate;
	180	dst->audio->channel_layout = src->channel_layout;
	181	break;
	182	default:
	183	return AVERROR(EINVAL);
	184	}
	185
	186	return 0;
	187	}
	188
	189	int avfilter_copy_buf_props(AVFrame dst, const AVFilterBufferRef src)
	190	{
	191	int planes, nb_channels;
	192
	193	memcpy(dst->data, src->data, sizeof(dst->data));
	194	memcpy(dst->linesize, src->linesize, sizeof(dst->linesize));
	195
	196	dst->pts = src->pts;
	197	dst->format = src->format;
	198
	199	switch (src->type) {
	200	case AVMEDIA_TYPE_VIDEO:
	201	dst->width = src->video->w;
	202	dst->height = src->video->h;
	203	dst->sample_aspect_ratio = src->video->sample_aspect_ratio;
	204	dst->interlaced_frame = src->video->interlaced;
	205	dst->top_field_first = src->video->top_field_first;
	206	dst->key_frame = src->video->key_frame;
	207	dst->pict_type = src->video->pict_type;
	208	break;
	209	case AVMEDIA_TYPE_AUDIO:
	210	nb_channels = av_get_channel_layout_nb_channels(src->audio->channel_layout);
	211	planes = av_sample_fmt_is_planar(src->format) ? nb_channels : 1;
	212
	213	if (planes > FF_ARRAY_ELEMS(dst->data)) {
	214	dst->extended_data = av_mallocz(planes * sizeof(*dst->extended_data));
	215	if (!dst->extended_data)
	216	return AVERROR(ENOMEM);
	217	memcpy(dst->extended_data, src->extended_data,
	218	planes * sizeof(dst->extended_data));
	219	} else
	220	dst->extended_data = dst->data;
	221
	222	dst->sample_rate = src->audio->sample_rate;
	223	dst->channel_layout = src->audio->channel_layout;
	224	dst->nb_samples = src->audio->nb_samples;
	225	break;
	226	default:
	227	return AVERROR(EINVAL);
	228	}
	229
	230	return 0;
	231	}
	232
	233	void avfilter_copy_buffer_ref_props(AVFilterBufferRef dst, AVFilterBufferRef src)
	234	{
	235	// copy common properties
	236	dst->pts = src->pts;
	237	dst->pos = src->pos;
	238
	239	switch (src->type) {
	240	case AVMEDIA_TYPE_VIDEO: dst->video = src->video; break;
	241	case AVMEDIA_TYPE_AUDIO: dst->audio = src->audio; break;
	242	default: break;
	243	}
	244	}

libavfilter/buffersink.c+98−4

@@ -23,13 +23,20 @@ · 22 unmodified lines
23	* buffer sink	23	* buffer sink
24	*/	24	*/
25		25
		26	#include "libavutil/audio_fifo.h"
		27	#include "libavutil/audioconvert.h"
26	#include "libavutil/fifo.h"	28	#include "libavutil/fifo.h"
		29	#include "libavutil/mathematics.h"
27		30
		31	#include "audio.h"
28	#include "avfilter.h"	32	#include "avfilter.h"
29	#include "buffersink.h"	33	#include "buffersink.h"
30		34
31	typedef struct {	35	typedef struct {
32	AVFifoBuffer *fifo; ///< FIFO buffer of video frame references	36	AVFifoBuffer *fifo; ///< FIFO buffer of frame references
		37
		38	AVAudioFifo *audio_fifo; ///< FIFO for audio samples
		39	int64_t next_pts; ///< interpolating audio pts
33	} BufferSinkContext;	40	} BufferSinkContext;
34		41
35	#define FIFO_INIT_SIZE 8	42	#define FIFO_INIT_SIZE 8
@@ -44,6 +51,9 @@ static av_cold void uninit(AVFilterContext *ctx) · 8 unmodified lines
44	avfilter_unref_buffer(buf);	51	avfilter_unref_buffer(buf);
45	}	52	}
46	av_fifo_free(sink->fifo);	53	av_fifo_free(sink->fifo);
		54
		55	if (sink->audio_fifo)
		56	av_audio_fifo_free(sink->audio_fifo);
47	}	57	}
48		58
49	static av_cold int init(AVFilterContext ctx, const char args, void *opaque)	59	static av_cold int init(AVFilterContext ctx, const char args, void *opaque)
@@ -58,9 +68,8 @@ static av_cold int init(AVFilterContext ctx, const char args, void *opaque) · 8 unmodified lines
58	return 0;	68	return 0;
59	}	69	}
60		70
61	static void end_frame(AVFilterLink *link)	71	static void write_buf(AVFilterContext ctx, AVFilterBufferRef buf)
62	{	72	{
63	AVFilterContext *ctx = link->dst;
64	BufferSinkContext *sink = ctx->priv;	73	BufferSinkContext *sink = ctx->priv;
65		74
66	if (av_fifo_space(sink->fifo) < sizeof(AVFilterBufferRef *) &&	75	if (av_fifo_space(sink->fifo) < sizeof(AVFilterBufferRef *) &&
@@ -69,10 +78,20 @@ static void end_frame(AVFilterLink *link) · 2 unmodified lines
69	return;	78	return;
70	}	79	}
71		80
72	av_fifo_generic_write(sink->fifo, &link->cur_buf, sizeof(link->cur_buf), NULL);	81	av_fifo_generic_write(sink->fifo, &buf, sizeof(buf), NULL);
		82	}
		83
		84	static void end_frame(AVFilterLink *link)
		85	{
		86	write_buf(link->dst, link->cur_buf);
73	link->cur_buf = NULL;	87	link->cur_buf = NULL;
74	}	88	}
75		89
		90	static void filter_samples(AVFilterLink link, AVFilterBufferRef buf)
		91	{
		92	write_buf(link->dst, buf);
		93	}
		94
76	int av_buffersink_read(AVFilterContext ctx, AVFilterBufferRef *buf)	95	int av_buffersink_read(AVFilterContext ctx, AVFilterBufferRef *buf)
77	{	96	{
78	BufferSinkContext *sink = ctx->priv;	97	BufferSinkContext *sink = ctx->priv;
@@ -98,6 +117,66 @@ int av_buffersink_read(AVFilterContext ctx, AVFilterBufferRef *buf) · 19 unmodified lines
98	return 0;	117	return 0;
99	}	118	}
100		119
		120	static int read_from_fifo(AVFilterContext ctx, AVFilterBufferRef *pbuf,
		121	int nb_samples)
		122	{
		123	BufferSinkContext *s = ctx->priv;
		124	AVFilterLink *link = ctx->inputs[0];
		125	AVFilterBufferRef *buf;
		126
		127	if (!(buf = ff_get_audio_buffer(link, AV_PERM_WRITE, nb_samples)))
		128	return AVERROR(ENOMEM);
		129	av_audio_fifo_read(s->audio_fifo, (void**)buf->extended_data, nb_samples);
		130
		131	buf->pts = s->next_pts;
		132	s->next_pts += av_rescale_q(nb_samples, (AVRational){1, link->sample_rate},
		133	link->time_base);
		134
		135	*pbuf = buf;
		136	return 0;
		137
		138	}
		139
		140	int av_buffersink_read_samples(AVFilterContext ctx, AVFilterBufferRef *pbuf,
		141	int nb_samples)
		142	{
		143	BufferSinkContext *s = ctx->priv;
		144	AVFilterLink *link = ctx->inputs[0];
		145	int ret = 0;
		146
		147	if (!s->audio_fifo) {
		148	int nb_channels = av_get_channel_layout_nb_channels(link->channel_layout);
		149	if (!(s->audio_fifo = av_audio_fifo_alloc(link->format, nb_channels, nb_samples)))
		150	return AVERROR(ENOMEM);
		151	}
		152
		153	while (ret >= 0) {
		154	AVFilterBufferRef *buf;
		155
		156	if (av_audio_fifo_size(s->audio_fifo) >= nb_samples)
		157	return read_from_fifo(ctx, pbuf, nb_samples);
		158
		159	ret = av_buffersink_read(ctx, &buf);
		160	if (ret == AVERROR_EOF && av_audio_fifo_size(s->audio_fifo))
		161	return read_from_fifo(ctx, pbuf, av_audio_fifo_size(s->audio_fifo));
		162	else if (ret < 0)
		163	return ret;
		164
		165	if (buf->pts != AV_NOPTS_VALUE) {
		166	s->next_pts = buf->pts -
		167	av_rescale_q(av_audio_fifo_size(s->audio_fifo),
		168	(AVRational){ 1, link->sample_rate },
		169	link->time_base);
		170	}
		171
		172	ret = av_audio_fifo_write(s->audio_fifo, (void**)buf->extended_data,
		173	buf->audio->nb_samples);
		174	avfilter_unref_buffer(buf);
		175	}
		176
		177	return ret;
		178	}
		179
101	AVFilter avfilter_vsink_buffer = {	180	AVFilter avfilter_vsink_buffer = {
102	.name = "buffersink_old",	181	.name = "buffersink_old",
103	.description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),	182	.description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them available to the end of the filter graph."),
@@ -112,3 +191,18 @@ AVFilter avfilter_vsink_buffer = { · 8 unmodified lines
112	{ .name = NULL }},	191	{ .name = NULL }},
113	.outputs = (AVFilterPad[]) {{ .name = NULL }},	192	.outputs = (AVFilterPad[]) {{ .name = NULL }},
114	};	193	};
		194
		195	AVFilter avfilter_asink_abuffer = {
		196	.name = "abuffersink_old",
		197	.description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them available to the end of the filter graph."),
		198	.priv_size = sizeof(BufferSinkContext),
		199	.init = init,
		200	.uninit = uninit,
		201
		202	.inputs = (AVFilterPad[]) {{ .name = "default",
		203	.type = AVMEDIA_TYPE_AUDIO,
		204	.filter_samples = filter_samples,
		205	.min_perms = AV_PERM_READ, },
		206	{ .name = NULL }},
		207	.outputs = (AVFilterPad[]) {{ .name = NULL }},
		208	};

libavfilter/buffersink.h+20−1

@@ -101,7 +101,7 @@ int av_vsink_buffer_get_video_buffer_ref(AVFilterContext *buffer_sink, · 100 unmodified lines
101	/**	101	/**
102	* Get a buffer with filtered data from sink and put it in buf.	102	* Get a buffer with filtered data from sink and put it in buf.
103	*	103	*
104	* @param sink pointer to a context of a buffersink AVFilter.	104	* @param sink pointer to a context of a buffersink or abuffersink AVFilter.
105	* @param buf pointer to the buffer will be written here if buf is non-NULL. buf	105	* @param buf pointer to the buffer will be written here if buf is non-NULL. buf
106	* must be freed by the caller using avfilter_unref_buffer().	106	* must be freed by the caller using avfilter_unref_buffer().
107	* Buf may also be NULL to query whether a buffer is ready to be	107	* Buf may also be NULL to query whether a buffer is ready to be
@@ -112,4 +112,23 @@ int av_vsink_buffer_get_video_buffer_ref(AVFilterContext *buffer_sink, · 4 unmodified lines
112	*/	112	*/
113	int av_buffersink_read(AVFilterContext sink, AVFilterBufferRef *buf);	113	int av_buffersink_read(AVFilterContext sink, AVFilterBufferRef *buf);
114		114
		115	/**
		116	* Same as av_buffersink_read, but with the ability to specify the number of
		117	* samples read. This function is less efficient than av_buffersink_read(),
		118	* because it copies the data around.
		119	*
		120	* @param sink pointer to a context of the abuffersink AVFilter.
		121	* @param buf pointer to the buffer will be written here if buf is non-NULL. buf
		122	* must be freed by the caller using avfilter_unref_buffer(). buf
		123	* will contain exactly nb_samples audio samples, except at the end
		124	* of stream, when it can contain less than nb_samples.
		125	* Buf may also be NULL to query whether a buffer is ready to be
		126	* output.
		127	*
		128	* @warning do not mix this function with av_buffersink_read(). Use only one or
		129	* the other with a single sink, not both.
		130	*/
		131	int av_buffersink_read_samples(AVFilterContext ctx, AVFilterBufferRef *buf,
		132	int nb_samples);
		133
115	#endif /* AVFILTER_BUFFERSINK_H */	134	#endif /* AVFILTER_BUFFERSINK_H */

libavfilter/buffersrc.c+403−0

@@ -0,0 +1,403 @@
	1	/*
	2	* Copyright (c) 2008 Vitor Sessak
	3	*
	4	* This file is part of FFmpeg.
	5	*
	6	* FFmpeg is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU Lesser General Public
	8	* License as published by the Free Software Foundation; either
	9	* version 2.1 of the License, or (at your option) any later version.
	10	*
	11	* FFmpeg is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* Lesser General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU Lesser General Public
	17	* License along with FFmpeg; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
	20
	21	/**
	22	* @file
	23	* memory buffer source filter
	24	*/
	25
	26	#include "audio.h"
	27	#include "avfilter.h"
	28	#include "buffersrc.h"
	29	#include "formats.h"
	30	#include "vsrc_buffer.h"
	31	#include "avcodec.h"
	32
	33	#include "libavutil/audioconvert.h"
	34	#include "libavutil/fifo.h"
	35	#include "libavutil/imgutils.h"
	36	#include "libavutil/opt.h"
	37	#include "libavutil/samplefmt.h"
	38
	39	typedef struct {
	40	const AVClass *class;
	41	AVFifoBuffer *fifo;
	42	AVRational time_base; ///< time_base to set in the output link
	43
	44	/* video only */
	45	int h, w;
	46	enum PixelFormat pix_fmt;
	47	AVRational pixel_aspect;
	48
	49	/* audio only */
	50	int sample_rate;
	51	enum AVSampleFormat sample_fmt;
	52	char *sample_fmt_str;
	53	uint64_t channel_layout;
	54	char *channel_layout_str;
	55
	56	int eof;
	57	} BufferSourceContext;
	58
	59	#define CHECK_VIDEO_PARAM_CHANGE(s, c, width, height, format)\
	60	if (c->w != width \|\| c->h != height \|\| c->pix_fmt != format) {\
	61	av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
	62	return AVERROR(EINVAL);\
	63	}
	64
	65	#define CHECK_AUDIO_PARAM_CHANGE(s, c, srate, ch_layout, format)\
	66	if (c->sample_fmt != format \|\| c->sample_rate != srate \|\|\
	67	c->channel_layout != ch_layout) {\
	68	av_log(s, AV_LOG_ERROR, "Changing frame properties on the fly is not supported.\n");\
	69	return AVERROR(EINVAL);\
	70	}
	71
	72	#if FF_API_VSRC_BUFFER_ADD_FRAME
	73	static int av_vsrc_buffer_add_frame_alt(AVFilterContext buffer_filter, AVFrame frame,
	74	int64_t pts, AVRational pixel_aspect)
	75	{
	76	int64_t orig_pts = frame->pts;
	77	AVRational orig_sar = frame->sample_aspect_ratio;
	78	int ret;
	79
	80	frame->pts = pts;
	81	frame->sample_aspect_ratio = pixel_aspect;
	82	if ((ret = av_buffersrc_write_frame(buffer_filter, frame)) < 0)
	83	return ret;
	84	frame->pts = orig_pts;
	85	frame->sample_aspect_ratio = orig_sar;
	86
	87	return 0;
	88	}
	89	#endif
	90
	91	int av_buffersrc_write_frame(AVFilterContext buffer_filter, AVFrame frame)
	92	{
	93	BufferSourceContext *c = buffer_filter->priv;
	94	AVFilterBufferRef *buf;
	95	int ret;
	96
	97	if (!frame) {
	98	c->eof = 1;
	99	return 0;
	100	} else if (c->eof)
	101	return AVERROR(EINVAL);
	102
	103	if (!av_fifo_space(c->fifo) &&
	104	(ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
	105	sizeof(buf))) < 0)
	106	return ret;
	107
	108	switch (buffer_filter->outputs[0]->type) {
	109	case AVMEDIA_TYPE_VIDEO:
	110	CHECK_VIDEO_PARAM_CHANGE(buffer_filter, c, frame->width, frame->height,
	111	frame->format);
	112	buf = avfilter_get_video_buffer(buffer_filter->outputs[0], AV_PERM_WRITE,
	113	c->w, c->h);
	114	av_image_copy(buf->data, buf->linesize, frame->data, frame->linesize,
	115	c->pix_fmt, c->w, c->h);
	116	break;
	117	case AVMEDIA_TYPE_AUDIO:
	118	CHECK_AUDIO_PARAM_CHANGE(buffer_filter, c, frame->sample_rate, frame->channel_layout,
	119	frame->format);
	120	buf = ff_get_audio_buffer(buffer_filter->outputs[0], AV_PERM_WRITE,
	121	frame->nb_samples);
	122	av_samples_copy(buf->extended_data, frame->extended_data,
	123	0, 0, frame->nb_samples,
	124	av_get_channel_layout_nb_channels(frame->channel_layout),
	125	frame->format);
	126	break;
	127	default:
	128	return AVERROR(EINVAL);
	129	}
	130
	131	avfilter_copy_frame_props(buf, frame);
	132
	133	if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0) {
	134	avfilter_unref_buffer(buf);
	135	return ret;
	136	}
	137
	138	return 0;
	139	}
	140
	141	static int av_buffersrc_buffer(AVFilterContext s, AVFilterBufferRef buf)
	142	{
	143	BufferSourceContext *c = s->priv;
	144	int ret;
	145
	146	if (!buf) {
	147	c->eof = 1;
	148	return 0;
	149	} else if (c->eof)
	150	return AVERROR(EINVAL);
	151
	152	if (!av_fifo_space(c->fifo) &&
	153	(ret = av_fifo_realloc2(c->fifo, av_fifo_size(c->fifo) +
	154	sizeof(buf))) < 0)
	155	return ret;
	156
	157	switch (s->outputs[0]->type) {
	158	case AVMEDIA_TYPE_VIDEO:
	159	CHECK_VIDEO_PARAM_CHANGE(s, c, buf->video->w, buf->video->h, buf->format);
	160	break;
	161	case AVMEDIA_TYPE_AUDIO:
	162	CHECK_AUDIO_PARAM_CHANGE(s, c, buf->audio->sample_rate, buf->audio->channel_layout,
	163	buf->format);
	164	break;
	165	default:
	166	return AVERROR(EINVAL);
	167	}
	168
	169	if ((ret = av_fifo_generic_write(c->fifo, &buf, sizeof(buf), NULL)) < 0)
	170	return ret;
	171
	172	return 0;
	173	}
	174
	175	static av_cold int init_video(AVFilterContext ctx, const char args, void *opaque)
	176	{
	177	BufferSourceContext *c = ctx->priv;
	178	char pix_fmt_str[128];
	179	int n = 0;
	180
	181	if (!args \|\|
	182	(n = sscanf(args, "%d:%d:%127[^:]:%d:%d:%d:%d", &c->w, &c->h, pix_fmt_str,
	183	&c->time_base.num, &c->time_base.den,
	184	&c->pixel_aspect.num, &c->pixel_aspect.den)) != 7) {
	185	av_log(ctx, AV_LOG_ERROR, "Expected 7 arguments, but %d found in '%s'\n", n, args);
	186	return AVERROR(EINVAL);
	187	}
	188	if ((c->pix_fmt = av_get_pix_fmt(pix_fmt_str)) == PIX_FMT_NONE) {
	189	char *tail;
	190	c->pix_fmt = strtol(pix_fmt_str, &tail, 10);
	191	if (*tail \|\| c->pix_fmt < 0 \|\| c->pix_fmt >= PIX_FMT_NB) {
	192	av_log(ctx, AV_LOG_ERROR, "Invalid pixel format string '%s'\n", pix_fmt_str);
	193	return AVERROR(EINVAL);
	194	}
	195	}
	196
	197	if (!(c->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*))))
	198	return AVERROR(ENOMEM);
	199
	200	av_log(ctx, AV_LOG_INFO, "w:%d h:%d pixfmt:%s\n", c->w, c->h, av_pix_fmt_descriptors[c->pix_fmt].name);
	201	return 0;
	202	}
	203
	204	#define OFFSET(x) offsetof(BufferSourceContext, x)
	205	#define A AV_OPT_FLAG_AUDIO_PARAM
	206	static const AVOption audio_options[] = {
	207	{ "time_base", NULL, OFFSET(time_base), AV_OPT_TYPE_RATIONAL, { 0 }, 0, INT_MAX, A },
	208	{ "sample_rate", NULL, OFFSET(sample_rate), AV_OPT_TYPE_INT, { 0 }, 0, INT_MAX, A },
	209	{ "sample_fmt", NULL, OFFSET(sample_fmt_str), AV_OPT_TYPE_STRING, .flags = A },
	210	{ "channel_layout", NULL, OFFSET(channel_layout_str), AV_OPT_TYPE_STRING, .flags = A },
	211	{ NULL },
	212	};
	213
	214	static const AVClass abuffer_class = {
	215	.class_name = "abuffer source",
	216	.item_name = av_default_item_name,
	217	.option = audio_options,
	218	.version = LIBAVUTIL_VERSION_INT,
	219	};
	220
	221	static av_cold int init_audio(AVFilterContext ctx, const char args, void *opaque)
	222	{
	223	BufferSourceContext *s = ctx->priv;
	224	int ret = 0;
	225
	226	s->class = &abuffer_class;
	227	av_opt_set_defaults(s);
	228
	229	if ((ret = av_set_options_string(s, args, "=", ":")) < 0) {
	230	av_log(ctx, AV_LOG_ERROR, "Error parsing options string: %s.\n", args);
	231	goto fail;
	232	}
	233
	234	s->sample_fmt = av_get_sample_fmt(s->sample_fmt_str);
	235	if (s->sample_fmt == AV_SAMPLE_FMT_NONE) {
	236	av_log(ctx, AV_LOG_ERROR, "Invalid sample format %s.\n",
	237	s->sample_fmt_str);
	238	ret = AVERROR(EINVAL);
	239	goto fail;
	240	}
	241
	242	s->channel_layout = av_get_channel_layout(s->channel_layout_str);
	243	if (!s->channel_layout) {
	244	av_log(ctx, AV_LOG_ERROR, "Invalid channel layout %s.\n",
	245	s->channel_layout_str);
	246	ret = AVERROR(EINVAL);
	247	goto fail;
	248	}
	249
	250	if (!(s->fifo = av_fifo_alloc(sizeof(AVFilterBufferRef*)))) {
	251	ret = AVERROR(ENOMEM);
	252	goto fail;
	253	}
	254
	255	if (!s->time_base.num)
	256	s->time_base = (AVRational){1, s->sample_rate};
	257
	258	av_log(ctx, AV_LOG_VERBOSE, "tb:%d/%d samplefmt:%s samplerate: %d "
	259	"ch layout:%s\n", s->time_base.num, s->time_base.den, s->sample_fmt_str,
	260	s->sample_rate, s->channel_layout_str);
	261
	262	fail:
	263	av_opt_free(s);
	264	return ret;
	265	}
	266
	267	static av_cold void uninit(AVFilterContext *ctx)
	268	{
	269	BufferSourceContext *s = ctx->priv;
	270	while (s->fifo && av_fifo_size(s->fifo)) {
	271	AVFilterBufferRef *buf;
	272	av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL);
	273	avfilter_unref_buffer(buf);
	274	}
	275	av_fifo_free(s->fifo);
	276	s->fifo = NULL;
	277	}
	278
	279	static int query_formats(AVFilterContext *ctx)
	280	{
	281	BufferSourceContext *c = ctx->priv;
	282	AVFilterChannelLayouts *channel_layouts = NULL;
	283	AVFilterFormats *formats = NULL;
	284	AVFilterFormats *samplerates = NULL;
	285
	286	switch (ctx->outputs[0]->type) {
	287	case AVMEDIA_TYPE_VIDEO:
	288	avfilter_add_format(&formats, c->pix_fmt);
	289	avfilter_set_common_formats(ctx, formats);
	290	break;
	291	case AVMEDIA_TYPE_AUDIO:
	292	avfilter_add_format(&formats, c->sample_fmt);
	293	avfilter_set_common_formats(ctx, formats);
	294
	295	avfilter_add_format(&samplerates, c->sample_rate);
	296	ff_set_common_samplerates(ctx, samplerates);
	297
	298	ff_add_channel_layout(&channel_layouts, c->channel_layout);
	299	ff_set_common_channel_layouts(ctx, channel_layouts);
	300	break;
	301	default:
	302	return AVERROR(EINVAL);
	303	}
	304
	305	return 0;
	306	}
	307
	308	static int config_props(AVFilterLink *link)
	309	{
	310	BufferSourceContext *c = link->src->priv;
	311
	312	switch (link->type) {
	313	case AVMEDIA_TYPE_VIDEO:
	314	link->w = c->w;
	315	link->h = c->h;
	316	link->sample_aspect_ratio = c->pixel_aspect;
	317	break;
	318	case AVMEDIA_TYPE_AUDIO:
	319	link->channel_layout = c->channel_layout;
	320	link->sample_rate = c->sample_rate;
	321	break;
	322	default:
	323	return AVERROR(EINVAL);
	324	}
	325
	326	link->time_base = c->time_base;
	327	return 0;
	328	}
	329
	330	static int request_frame(AVFilterLink *link)
	331	{
	332	BufferSourceContext *c = link->src->priv;
	333	AVFilterBufferRef *buf;
	334
	335	if (!av_fifo_size(c->fifo)) {
	336	if (c->eof)
	337	return AVERROR_EOF;
	338	return AVERROR(EAGAIN);
	339	}
	340	av_fifo_generic_read(c->fifo, &buf, sizeof(buf), NULL);
	341
	342	switch (link->type) {
	343	case AVMEDIA_TYPE_VIDEO:
	344	avfilter_start_frame(link, avfilter_ref_buffer(buf, ~0));
	345	avfilter_draw_slice(link, 0, link->h, 1);
	346	avfilter_end_frame(link);
	347	break;
	348	case AVMEDIA_TYPE_AUDIO:
	349	ff_filter_samples(link, avfilter_ref_buffer(buf, ~0));
	350	break;
	351	default:
	352	return AVERROR(EINVAL);
	353	}
	354
	355	avfilter_unref_buffer(buf);
	356
	357	return 0;
	358	}
	359
	360	static int poll_frame(AVFilterLink *link)
	361	{
	362	BufferSourceContext *c = link->src->priv;
	363	int size = av_fifo_size(c->fifo);
	364	if (!size && c->eof)
	365	return AVERROR_EOF;
	366	return size/sizeof(AVFilterBufferRef*);
	367	}
	368
	369	AVFilter avfilter_vsrc_buffer = {
	370	.name = "buffer",
	371	.description = NULL_IF_CONFIG_SMALL("Buffer video frames, and make them accessible to the filterchain."),
	372	.priv_size = sizeof(BufferSourceContext),
	373	.query_formats = query_formats,
	374
	375	.init = init_video,
	376	.uninit = uninit,
	377
	378	.inputs = (AVFilterPad[]) {{ .name = NULL }},
	379	.outputs = (AVFilterPad[]) {{ .name = "default",
	380	.type = AVMEDIA_TYPE_VIDEO,
	381	.request_frame = request_frame,
	382	.poll_frame = poll_frame,
	383	.config_props = config_props, },
	384	{ .name = NULL}},
	385	};
	386
	387	AVFilter avfilter_asrc_abuffer = {
	388	.name = "abuffer",
	389	.description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
	390	.priv_size = sizeof(BufferSourceContext),
	391	.query_formats = query_formats,
	392
	393	.init = init_audio,
	394	.uninit = uninit,
	395
	396	.inputs = (AVFilterPad[]) {{ .name = NULL }},
	397	.outputs = (AVFilterPad[]) {{ .name = "default",
	398	.type = AVMEDIA_TYPE_AUDIO,
	399	.request_frame = request_frame,
	400	.poll_frame = poll_frame,
	401	.config_props = config_props, },
	402	{ .name = NULL}},
	403	};

libavfilter/buffersrc.h+11−0

@@ -62,4 +62,15 @@ int av_buffersrc_add_ref(AVFilterContext *buffer_src, · 61 unmodified lines
62	*/	62	*/
63	unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src);	63	unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src);
64		64
		65	/**
		66	* Add a frame to the buffer source.
		67	*
		68	* @param s an instance of the buffersrc filter.
		69	* @param frame frame to be added.
		70	*
		71	* @warning frame data will be memcpy()ed, which may be a big performance
		72	* hit. Use av_buffersrc_buffer() to avoid copying the data.
		73	*/
		74	int av_buffersrc_write_frame(AVFilterContext s, AVFrame frame);
		75
65	#endif /* AVFILTER_BUFFERSRC_H */	76	#endif /* AVFILTER_BUFFERSRC_H */

libavfilter/defaults.c+3−137

@@ -26,111 +26,7 @@ · 25 unmodified lines
26		26
27	#include "avfilter.h"	27	#include "avfilter.h"
28	#include "internal.h"	28	#include "internal.h"
29		29	#include "formats.h"
30	void ff_avfilter_default_free_buffer(AVFilterBuffer *ptr)
31	{
32	if (ptr->extended_data != ptr->data)
33	av_freep(&ptr->extended_data);
34	av_free(ptr->data[0]);
35	av_free(ptr);
36	}
37
38	/* TODO: set the buffer's priv member to a context structure for the whole
39	* filter chain. This will allow for a buffer pool instead of the constant
40	* alloc & free cycle currently implemented. */
41	AVFilterBufferRef avfilter_default_get_video_buffer(AVFilterLink link, int perms, int w, int h)
42	{
43	int linesize[4];
44	uint8_t *data[4];
45	int i;
46	AVFilterBufferRef *picref = NULL;
47	AVFilterPool *pool = link->pool;
48
49	if (pool) {
50	for (i = 0; i < POOL_SIZE; i++) {
51	picref = pool->pic[i];
52	if (picref && picref->buf->format == link->format && picref->buf->w == w && picref->buf->h == h) {
53	AVFilterBuffer *pic = picref->buf;
54	pool->pic[i] = NULL;
55	pool->count--;
56	picref->video->w = w;
57	picref->video->h = h;
58	picref->perms = perms \| AV_PERM_READ;
59	picref->format = link->format;
60	pic->refcount = 1;
61	memcpy(picref->data, pic->data, sizeof(picref->data));
62	memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
63	pool->refcount++;
64	return picref;
65	}
66	}
67	} else {
68	pool = link->pool = av_mallocz(sizeof(AVFilterPool));
69	pool->refcount = 1;
70	}
71
72	// align: +2 is needed for swscaler, +16 to be SIMD-friendly
73	if ((i = av_image_alloc(data, linesize, w, h, link->format, 32)) < 0)
74	return NULL;
75
76	picref = avfilter_get_video_buffer_ref_from_arrays(data, linesize,
77	perms, w, h, link->format);
78	if (!picref) {
79	av_free(data[0]);
80	return NULL;
81	}
82	memset(data[0], 128, i);
83
84	picref->buf->priv = pool;
85	picref->buf->free = NULL;
86	pool->refcount++;
87
88	return picref;
89	}
90
91	void avfilter_default_start_frame(AVFilterLink inlink, AVFilterBufferRef picref)
92	{
93	AVFilterLink *outlink = NULL;
94
95	if (inlink->dst->output_count)
96	outlink = inlink->dst->outputs[0];
97
98	if (outlink) {
99	outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
100	avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
101	avfilter_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
102	}
103	}
104
105	void avfilter_default_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
106	{
107	AVFilterLink *outlink = NULL;
108
109	if (inlink->dst->output_count)
110	outlink = inlink->dst->outputs[0];
111
112	if (outlink)
113	avfilter_draw_slice(outlink, y, h, slice_dir);
114	}
115
116	void avfilter_default_end_frame(AVFilterLink *inlink)
117	{
118	AVFilterLink *outlink = NULL;
119
120	if (inlink->dst->output_count)
121	outlink = inlink->dst->outputs[0];
122
123	avfilter_unref_buffer(inlink->cur_buf);
124	inlink->cur_buf = NULL;
125
126	if (outlink) {
127	if (outlink->out_buf) {
128	avfilter_unref_buffer(outlink->out_buf);
129	outlink->out_buf = NULL;
130	}
131	avfilter_end_frame(outlink);
132	}
133	}
134		30
135	static void set_common_formats(AVFilterContext ctx, AVFilterFormats fmts,	31	static void set_common_formats(AVFilterContext ctx, AVFilterFormats fmts,
136	enum AVMediaType type, int offin, int offout)	32	enum AVMediaType type, int offin, int offout)
@@ -170,8 +66,8 @@ void avfilter_set_common_sample_formats(AVFilterContext ctx, AVFilterFormats f · 33 unmodified lines
170	void avfilter_set_common_channel_layouts(AVFilterContext ctx, AVFilterFormats formats)	66	void avfilter_set_common_channel_layouts(AVFilterContext ctx, AVFilterFormats formats)
171	{	67	{
172	set_common_formats(ctx, formats, AVMEDIA_TYPE_AUDIO,	68	set_common_formats(ctx, formats, AVMEDIA_TYPE_AUDIO,
173	offsetof(AVFilterLink, in_chlayouts),	69	offsetof(AVFilterLink, in_channel_layouts),
174	offsetof(AVFilterLink, out_chlayouts));	70	offsetof(AVFilterLink, out_channel_layouts));
175	}	71	}
176		72
177	void avfilter_set_common_packing_formats(AVFilterContext ctx, AVFilterFormats formats)	73	void avfilter_set_common_packing_formats(AVFilterContext ctx, AVFilterFormats formats)
@@ -180,33 +76,3 @@ void avfilter_set_common_packing_formats(AVFilterContext ctx, AVFilterFormats · 2 unmodified lines
180	offsetof(AVFilterLink, in_packing),	76	offsetof(AVFilterLink, in_packing),
181	offsetof(AVFilterLink, out_packing));	77	offsetof(AVFilterLink, out_packing));
182	}	78	}
183
184	int avfilter_default_query_formats(AVFilterContext *ctx)
185	{
186	avfilter_set_common_pixel_formats(ctx, avfilter_make_all_formats(AVMEDIA_TYPE_VIDEO));
187	avfilter_set_common_sample_formats(ctx, avfilter_make_all_formats(AVMEDIA_TYPE_AUDIO));
188	avfilter_set_common_channel_layouts(ctx, avfilter_make_all_channel_layouts());
189	avfilter_set_common_packing_formats(ctx, avfilter_make_all_packing_formats());
190
191	return 0;
192	}
193
194	void avfilter_null_start_frame(AVFilterLink link, AVFilterBufferRef picref)
195	{
196	avfilter_start_frame(link->dst->outputs[0], picref);
197	}
198
199	void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
200	{
201	avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
202	}
203
204	void avfilter_null_end_frame(AVFilterLink *link)
205	{
206	avfilter_end_frame(link->dst->outputs[0]);
207	}
208
209	AVFilterBufferRef avfilter_null_get_video_buffer(AVFilterLink link, int perms, int w, int h)
210	{
211	return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
212	}

libavfilter/formats.c+282−87

@@ -24,63 +24,138 @@ · 23 unmodified lines
24	#include "libavutil/audioconvert.h"	24	#include "libavutil/audioconvert.h"
25	#include "avfilter.h"	25	#include "avfilter.h"
26	#include "internal.h"	26	#include "internal.h"
		27	#include "formats.h"
27		28
28	/**	29	/**
29	* Add all refs from a to ret and destroy a.	30	* Add all refs from a to ret and destroy a.
30	*/	31	*/
31	static void merge_ref(AVFilterFormats ret, AVFilterFormats a)	32	#define MERGE_REF(ret, a, fmts, type, fail) \
32	{	33	do { \
33	int i;	34	type ***tmp; \
34		35	int i; \
35	for (i = 0; i < a->refcount; i++) {	36	\
36	ret->refs[ret->refcount] = a->refs[i];	37	if (!(tmp = av_realloc(ret->refs, \
37	*ret->refs[ret->refcount++] = ret;	38	sizeof(tmp) (ret->refcount + a->refcount)))) \
38	}	39	goto fail; \
		40	ret->refs = tmp; \
		41	\
		42	for (i = 0; i < a->refcount; i ++) { \
		43	ret->refs[ret->refcount] = a->refs[i]; \
		44	*ret->refs[ret->refcount++] = ret; \
		45	} \
		46	\
		47	av_freep(&a->refs); \
		48	av_freep(&a->fmts); \
		49	av_freep(&a); \
		50	} while (0)
39		51
40	av_free(a->refs);	52	/**
41	av_free(a->formats);	53	* Add all formats common for a and b to ret, copy the refs and destroy
42	av_free(a);	54	* a and b.
43	}	55	*/
		56	#define MERGE_FORMATS(ret, a, b, fmts, nb, type, fail) \
		57	do { \
		58	int i, j, k = 0, count = FFMIN(a->nb, b->nb); \
		59	\
		60	if (!(ret = av_mallocz(sizeof(*ret)))) \
		61	goto fail; \
		62	\
		63	if (count) { \
		64	if (!(ret->fmts = av_malloc(sizeof(ret->fmts) count))) \
		65	goto fail; \
		66	for (i = 0; i < a->nb; i++) \
		67	for (j = 0; j < b->nb; j++) \
		68	if (a->fmts[i] == b->fmts[j]) { \
		69	if(k >= FFMIN(a->nb, b->nb)){ \
		70	av_log(0, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n"); \
		71	av_free(ret->fmts); \
		72	av_free(ret); \
		73	return NULL; \
		74	} \
		75	ret->fmts[k++] = a->fmts[i]; \
		76	} \
		77	} \
		78	ret->nb = k; \
		79	/* check that there was at least one common format */ \
		80	if (!ret->nb) \
		81	goto fail; \
		82	\
		83	MERGE_REF(ret, a, fmts, type, fail); \
		84	MERGE_REF(ret, b, fmts, type, fail); \
		85	} while (0)
44		86
45	AVFilterFormats avfilter_merge_formats(AVFilterFormats a, AVFilterFormats *b)	87	AVFilterFormats avfilter_merge_formats(AVFilterFormats a, AVFilterFormats *b)
46	{	88	{
47	AVFilterFormats *ret;	89	AVFilterFormats *ret = NULL;
48	unsigned i, j, k = 0;
49		90
50	if (a == b)	91	if (a == b)
51	return a;	92	return a;
52		93
53	ret = av_mallocz(sizeof(*ret));	94	MERGE_FORMATS(ret, a, b, formats, format_count, AVFilterFormats, fail);
54		95
55	/* merge list of formats */	96	return ret;
56	ret->formats = av_malloc(sizeof(ret->formats) FFMIN(a->format_count,	97	fail:
57	b->format_count));	98	if (ret) {
58	for (i = 0; i < a->format_count; i++)	99	av_freep(&ret->refs);
59	for (j = 0; j < b->format_count; j++)	100	av_freep(&ret->formats);
60	if (a->formats[i] == b->formats[j]){
61	if(k >= FFMIN(a->format_count, b->format_count)){
62	av_log(0, AV_LOG_ERROR, "Duplicate formats in avfilter_merge_formats() detected\n");
63	av_free(ret->formats);
64	av_free(ret);
65	return NULL;
66	}
67	ret->formats[k++] = a->formats[i];
68	}
69
70	ret->format_count = k;
71	/* check that there was at least one common format */
72	if (!ret->format_count) {
73	av_free(ret->formats);
74	av_free(ret);
75	return NULL;
76	}	101	}
		102	av_freep(&ret);
		103	return NULL;
		104	}
		105
		106	AVFilterFormats ff_merge_samplerates(AVFilterFormats a,
		107	AVFilterFormats *b)
		108	{
		109	AVFilterFormats *ret = NULL;
77		110
78	ret->refs = av_malloc(sizeof(ret->refs) (a->refcount + b->refcount));	111	if (a == b) return a;
79		112
80	merge_ref(ret, a);	113	if (a->format_count && b->format_count) {
81	merge_ref(ret, b);	114	MERGE_FORMATS(ret, a, b, formats, format_count, AVFilterFormats, fail);
		115	} else if (a->format_count) {
		116	MERGE_REF(a, b, formats, AVFilterFormats, fail);
		117	ret = a;
		118	} else {
		119	MERGE_REF(b, a, formats, AVFilterFormats, fail);
		120	ret = b;
		121	}
82		122
83	return ret;	123	return ret;
		124	fail:
		125	if (ret) {
		126	av_freep(&ret->refs);
		127	av_freep(&ret->formats);
		128	}
		129	av_freep(&ret);
		130	return NULL;
		131	}
		132
		133	AVFilterChannelLayouts ff_merge_channel_layouts(AVFilterChannelLayouts a,
		134	AVFilterChannelLayouts *b)
		135	{
		136	AVFilterChannelLayouts *ret = NULL;
		137
		138	if (a == b) return a;
		139
		140	if (a->nb_channel_layouts && b->nb_channel_layouts) {
		141	MERGE_FORMATS(ret, a, b, channel_layouts, nb_channel_layouts,
		142	AVFilterChannelLayouts, fail);
		143	} else if (a->nb_channel_layouts) {
		144	MERGE_REF(a, b, channel_layouts, AVFilterChannelLayouts, fail);
		145	ret = a;
		146	} else {
		147	MERGE_REF(b, a, channel_layouts, AVFilterChannelLayouts, fail);
		148	ret = b;
		149	}
		150
		151	return ret;
		152	fail:
		153	if (ret) {
		154	av_freep(&ret->refs);
		155	av_freep(&ret->channel_layouts);
		156	}
		157	av_freep(&ret);
		158	return NULL;
84	}	159	}
85		160
86	int ff_fmt_is_in(int fmt, const int *fmts)	161	int ff_fmt_is_in(int fmt, const int *fmts)
@@ -146,30 +221,40 @@ AVFilterFormats avfilter_make_format_list(const int fmts) · 59 unmodified lines
146	return formats;	221	return formats;
147	}	222	}
148		223
149	AVFilterFormats avfilter_make_format64_list(const int64_t fmts)	224	AVFilterChannelLayouts avfilter_make_format64_list(const int64_t fmts)
150	{	225	{
151	MAKE_FORMAT_LIST();	226	MAKE_FORMAT_LIST();
152	if (count)	227	if (count)
153	memcpy(formats->formats, fmts, sizeof(formats->formats) count);	228	memcpy(formats->formats, fmts, sizeof(formats->formats) count);
154		229
155	return formats;	230	return (AVFilterChannelLayouts*)formats;
156	}	231	}
157		232
		233	#define ADD_FORMAT(f, fmt, type, list, nb) \
		234	do { \
		235	type *fmts; \
		236	\
		237	if (!(f) && !(f = av_mallocz(sizeof(**f)))) \
		238	return AVERROR(ENOMEM); \
		239	\
		240	fmts = av_realloc((*f)->list, \
		241	sizeof((f)->list) * ((*f)->nb + 1));\
		242	if (!fmts) \
		243	return AVERROR(ENOMEM); \
		244	\
		245	(*f)->list = fmts; \
		246	(f)->list[(f)->nb++] = fmt; \
		247	return 0; \
		248	} while (0)
		249
158	int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)	250	int avfilter_add_format(AVFilterFormats **avff, int64_t fmt)
159	{	251	{
160	int64_t *fmts;	252	ADD_FORMAT(avff, fmt, int64_t, formats, format_count);
161		253	}
162	if (!(avff) && !(avff = av_mallocz(sizeof(**avff))))
163	return AVERROR(ENOMEM);
164
165	fmts = av_realloc((*avff)->formats,
166	sizeof((avff)->formats) * ((*avff)->format_count+1));
167	if (!fmts)
168	return AVERROR(ENOMEM);
169		254
170	(*avff)->formats = fmts;	255	int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout)
171	(avff)->formats[(avff)->format_count++] = fmt;	256	{
172	return 0;	257	ADD_FORMAT(l, channel_layout, uint64_t, channel_layouts, nb_channel_layouts);
173	}	258	}
174		259
175	#if FF_API_OLD_ALL_FORMATS_API	260	#if FF_API_OLD_ALL_FORMATS_API
@@ -199,10 +284,10 @@ const int64_t avfilter_all_channel_layouts[] = { · 23 unmodified lines
199	-1	284	-1
200	};	285	};
201		286
202	AVFilterFormats *avfilter_make_all_channel_layouts(void)	287	// AVFilterFormats *avfilter_make_all_channel_layouts(void)
203	{	288	// {
204	return avfilter_make_format64_list(avfilter_all_channel_layouts);	289	// return avfilter_make_format64_list(avfilter_all_channel_layouts);
205	}	290	// }
206		291
207	AVFilterFormats *avfilter_make_all_packing_formats(void)	292	AVFilterFormats *avfilter_make_all_packing_formats(void)
208	{	293	{
@@ -215,53 +300,163 @@ AVFilterFormats *avfilter_make_all_packing_formats(void) · 6 unmodified lines
215	return avfilter_make_format_list(packing);	300	return avfilter_make_format_list(packing);
216	}	301	}
217		302
218	void avfilter_formats_ref(AVFilterFormats f, AVFilterFormats *ref)	303	AVFilterFormats *ff_all_samplerates(void)
219	{	304	{
220	*ref = f;	305	AVFilterFormats ret = av_mallocz(sizeof(ret));
221	f->refs = av_realloc(f->refs, sizeof(f->refs) ++f->refcount);	306	return ret;
222	f->refs[f->refcount-1] = ref;
223	}	307	}
224		308
225	static int find_ref_index(AVFilterFormats **ref)	309	AVFilterChannelLayouts *ff_all_channel_layouts(void)
226	{	310	{
227	int i;	311	AVFilterChannelLayouts ret = av_mallocz(sizeof(ret));
228	for (i = 0; i < (*ref)->refcount; i++)	312	return ret;
229	if ((*ref)->refs[i] == ref)
230	return i;
231	return -1;
232	}	313	}
233		314
234	void avfilter_formats_unref(AVFilterFormats **ref)	315	#define FORMATS_REF(f, ref) \
		316	do { \
		317	*ref = f; \
		318	f->refs = av_realloc(f->refs, sizeof(f->refs) ++f->refcount); \
		319	f->refs[f->refcount-1] = ref; \
		320	} while (0)
		321
		322	void ff_channel_layouts_ref(AVFilterChannelLayouts f, AVFilterChannelLayouts *ref)
		323	{
		324	FORMATS_REF(f, ref);
		325	}
		326
		327	void avfilter_formats_ref(AVFilterFormats f, AVFilterFormats *ref)
235	{	328	{
236	int idx;	329	FORMATS_REF(f, ref);
		330	}
237		331
238	if (!*ref)	332	#define FIND_REF_INDEX(ref, idx) \
239	return;	333	do { \
		334	int i; \
		335	for (i = 0; i < (*ref)->refcount; i ++) \
		336	if((*ref)->refs[i] == ref) { \
		337	idx = i; \
		338	break; \
		339	} \
		340	} while (0)
		341
		342	#define FORMATS_UNREF(ref, list) \
		343	do { \
		344	int idx = -1; \
		345	\
		346	if (!*ref) \
		347	return; \
		348	\
		349	FIND_REF_INDEX(ref, idx); \
		350	\
		351	if (idx >= 0) \
		352	memmove((ref)->refs + idx, (ref)->refs + idx + 1, \
		353	sizeof((ref)->refs) * ((*ref)->refcount - idx - 1)); \
		354	\
		355	if(!--(*ref)->refcount) { \
		356	av_free((*ref)->list); \
		357	av_free((*ref)->refs); \
		358	av_free(*ref); \
		359	} \
		360	*ref = NULL; \
		361	} while (0)
240		362
241	idx = find_ref_index(ref);	363	void avfilter_formats_unref(AVFilterFormats **ref)
		364	{
		365	FORMATS_UNREF(ref, formats);
		366	}
242		367
243	if(idx >= 0)	368	void ff_channel_layouts_unref(AVFilterChannelLayouts **ref)
244	memmove((ref)->refs + idx, (ref)->refs + idx + 1,	369	{
245	sizeof((ref)->refs) * ((*ref)->refcount - idx - 1));	370	FORMATS_UNREF(ref, channel_layouts);
		371	}
246		372
247	if (!--(*ref)->refcount) {	373	#define FORMATS_CHANGEREF(oldref, newref) \
248	av_free((*ref)->formats);	374	do { \
249	av_free((*ref)->refs);	375	int idx = -1; \
250	av_free(*ref);	376	\
251	}	377	FIND_REF_INDEX(oldref, idx); \
252	*ref = NULL;	378	\
		379	if (idx >= 0) { \
		380	(*oldref)->refs[idx] = newref; \
		381	newref = oldref; \
		382	*oldref = NULL; \
		383	} \
		384	} while (0)
		385
		386	void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
		387	AVFilterChannelLayouts **newref)
		388	{
		389	FORMATS_CHANGEREF(oldref, newref);
253	}	390	}
254		391
255	void avfilter_formats_changeref(AVFilterFormats **oldref,	392	void avfilter_formats_changeref(AVFilterFormats **oldref,
256	AVFilterFormats **newref)	393	AVFilterFormats **newref)
257	{	394	{
258	int idx = find_ref_index(oldref);	395	FORMATS_CHANGEREF(oldref, newref);
		396	}
		397
		398	#define SET_COMMON_FORMATS(ctx, fmts, in_fmts, out_fmts, ref, list) \
		399	{ \
		400	int count = 0, i; \
		401	\
		402	for (i = 0; i < ctx->input_count; i++) { \
		403	if (ctx->inputs[i]) { \
		404	ref(fmts, &ctx->inputs[i]->out_fmts); \
		405	count++; \
		406	} \
		407	} \
		408	for (i = 0; i < ctx->output_count; i++) { \
		409	if (ctx->outputs[i]) { \
		410	ref(fmts, &ctx->outputs[i]->in_fmts); \
		411	count++; \
		412	} \
		413	} \
		414	\
		415	if (!count) { \
		416	av_freep(&fmts->list); \
		417	av_freep(&fmts->refs); \
		418	av_freep(&fmts); \
		419	} \
		420	}
		421
		422	void ff_set_common_channel_layouts(AVFilterContext *ctx,
		423	AVFilterChannelLayouts *layouts)
		424	{
		425	SET_COMMON_FORMATS(ctx, layouts, in_channel_layouts, out_channel_layouts,
		426	ff_channel_layouts_ref, channel_layouts);
		427	}
		428
		429	void ff_set_common_samplerates(AVFilterContext *ctx,
		430	AVFilterFormats *samplerates)
		431	{
		432	SET_COMMON_FORMATS(ctx, samplerates, in_samplerates, out_samplerates,
		433	avfilter_formats_ref, formats);
		434	}
		435
		436	/**
		437	* A helper for query_formats() which sets all links to the same list of
		438	* formats. If there are no links hooked to this filter, the list of formats is
		439	* freed.
		440	*/
		441	void avfilter_set_common_formats(AVFilterContext ctx, AVFilterFormats formats)
		442	{
		443	SET_COMMON_FORMATS(ctx, formats, in_formats, out_formats,
		444	avfilter_formats_ref, formats);
		445	}
259		446
260	if (idx >= 0) {	447	int avfilter_default_query_formats(AVFilterContext *ctx)
261	(*oldref)->refs[idx] = newref;	448	{
262	newref = oldref;	449	enum AVMediaType type = ctx->inputs && ctx->inputs [0] ? ctx->inputs [0]->type :
263	*oldref = NULL;	450	ctx->outputs && ctx->outputs[0] ? ctx->outputs[0]->type :
		451	AVMEDIA_TYPE_VIDEO;
		452
		453	avfilter_set_common_formats(ctx, avfilter_all_formats(type));
		454	if (type == AVMEDIA_TYPE_AUDIO) {
		455	ff_set_common_channel_layouts(ctx, ff_all_channel_layouts());
		456	ff_set_common_samplerates(ctx, ff_all_samplerates());
264	}	457	}
		458
		459	return 0;
265	}	460	}
266		461
267	/* internal functions for parsing audio format arguments */	462	/* internal functions for parsing audio format arguments */

libavfilter/formats.h+81−0

@@ -0,0 +1,81 @@
	1	/*
	2	* This file is part of FFMpeg.
	3	*
	4	* FFmpeg 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	* FFmpeg 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 FFmpeg; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#ifndef AVFILTER_FORMATS_H
	20	#define AVFILTER_FORMATS_H
	21
	22	#include "avfilter.h"
	23
	24	typedef struct AVFilterChannelLayouts {
	25	uint64_t *channel_layouts; ///< list of channel layouts
	26	int nb_channel_layouts; ///< number of channel layouts
	27
	28	unsigned refcount; ///< number of references to this list
	29	struct AVFilterChannelLayouts ***refs; ///< references to this list
	30	} AVFilterChannelLayouts;
	31
	32	/**
	33	* Return a channel layouts/samplerates list which contains the intersection of
	34	* the layouts/samplerates of a and b. Also, all the references of a, all the
	35	* references of b, and a and b themselves will be deallocated.
	36	*
	37	* If a and b do not share any common elements, neither is modified, and NULL
	38	* is returned.
	39	*/
	40	AVFilterChannelLayouts ff_merge_channel_layouts(AVFilterChannelLayouts a,
	41	AVFilterChannelLayouts *b);
	42	AVFilterFormats ff_merge_samplerates(AVFilterFormats a,
	43	AVFilterFormats *b);
	44
	45	/**
	46	* Construct an empty AVFilterChannelLayouts/AVFilterFormats struct --
	47	* representing any channel layout/sample rate.
	48	*/
	49	AVFilterChannelLayouts *ff_all_channel_layouts(void);
	50	AVFilterFormats *ff_all_samplerates(void);
	51
	52	AVFilterChannelLayouts avfilter_make_format64_list(const int64_t fmts);
	53
	54
	55	/**
	56	* A helper for query_formats() which sets all links to the same list of channel
	57	* layouts/sample rates. If there are no links hooked to this filter, the list
	58	* is freed.
	59	*/
	60	void ff_set_common_channel_layouts(AVFilterContext *ctx,
	61	AVFilterChannelLayouts *layouts);
	62	void ff_set_common_samplerates(AVFilterContext *ctx,
	63	AVFilterFormats *samplerates);
	64
	65	int ff_add_channel_layout(AVFilterChannelLayouts **l, uint64_t channel_layout);
	66
	67	/**
	68	* Add *ref as a new reference to f.
	69	*/
	70	void ff_channel_layouts_ref(AVFilterChannelLayouts *f,
	71	AVFilterChannelLayouts **ref);
	72
	73	/**
	74	* Remove a reference to a channel layouts list.
	75	*/
	76	void ff_channel_layouts_unref(AVFilterChannelLayouts **ref);
	77
	78	void ff_channel_layouts_changeref(AVFilterChannelLayouts **oldref,
	79	AVFilterChannelLayouts **newref);
	80
	81	#endif // AVFILTER_FORMATS_H

libavfilter/internal.h+5−0

 #include "avfilter.h"
 #include "avfiltergraph.h"
+#include "formats.h"
 #define POOL_SIZE 32
 typedef struct AVFilterPool {
 void ff_update_link_current_pts(AVFilterLink *link, int64_t pts);
+void ff_free_pool(AVFilterPool *pool);
+void ff_command_queue_pop(AVFilterContext *filter);
 #define FF_DPRINTF_START(ctx, func) av_dlog(NULL, "%-16s: ", #func)
 void ff_dlog_link(void *ctx, AVFilterLink *link, int end);

libavfilter/sink_buffer.c+5−2

 {
     BufferSinkContext *buf = ctx->priv;
     AVFilterFormats *formats = NULL;
+    AVFilterChannelLayouts *layouts = NULL;
     if (!(formats = avfilter_make_format_list(buf->sample_fmts)))
         return AVERROR(ENOMEM);
     avfilter_set_common_sample_formats(ctx, formats);
-    if (!(formats = avfilter_make_format64_list(buf->channel_layouts)))
+    if (!(layouts = avfilter_make_format64_list(buf->channel_layouts)))
         return AVERROR(ENOMEM);
-    avfilter_set_common_channel_layouts(ctx, formats);
+    ff_set_common_channel_layouts(ctx, layouts);
     if (!(formats = avfilter_make_format_list(buf->packing_fmts)))
         return AVERROR(ENOMEM);
     avfilter_set_common_packing_formats(ctx, formats);
+    ff_set_common_samplerates          (ctx, ff_all_samplerates());
     return 0;
 }

libavfilter/src_buffer.c+4−6

 {
     BufferSourceContext *abuffer = ctx->priv;
     AVFilterFormats *formats;
+    AVFilterChannelLayouts *layouts;
     formats = NULL;
     avfilter_add_format(&formats, abuffer->sample_format);
     avfilter_set_common_sample_formats(ctx, formats);
-    formats = NULL;
+    layouts = NULL;
-    avfilter_add_format(&formats, abuffer->channel_layout);
+    ff_add_channel_layout(&layouts, abuffer->channel_layout);
-    avfilter_set_common_channel_layouts(ctx, formats);
+    ff_set_common_channel_layouts(ctx, layouts);
     formats = NULL;
     avfilter_add_format(&formats, abuffer->packing_format);
                                   { .name = NULL}},
 };
-#if CONFIG_ABUFFER_FILTER
 AVFilter avfilter_asrc_abuffer = {
     .name        = "abuffer",
     .description = NULL_IF_CONFIG_SMALL("Buffer audio frames, and make them accessible to the filterchain."),
                                     { .name = NULL}},
 };
-#endif

libavfilter/src_movie.c+4−1

 #include "audio.h"
 #include "avcodec.h"
 #include "avfilter.h"
+#include "formats.h"
 typedef struct {
     /* common A/V fields */
     enum AVSampleFormat sample_fmts[] = { c->sample_fmt, -1 };
     int packing_fmts[] = { AVFILTER_PACKED, -1 };
+    int sample_rates[] = { c->sample_rate, -1 };
     int64_t chlayouts[] = { c->channel_layout ? c->channel_layout :
                             av_get_default_channel_layout(c->channels), -1 };
     avfilter_set_common_sample_formats (ctx, avfilter_make_format_list(sample_fmts));
     avfilter_set_common_packing_formats(ctx, avfilter_make_format_list(packing_fmts));
-    avfilter_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
+    ff_set_common_samplerates          (ctx, avfilter_make_format_list(sample_rates));
+    ff_set_common_channel_layouts(ctx, avfilter_make_format64_list(chlayouts));
     return 0;
 }

libavfilter/version.h+4−1

 #include "libavutil/avutil.h"
 #define LIBAVFILTER_VERSION_MAJOR  2
-#define LIBAVFILTER_VERSION_MINOR 73
+#define LIBAVFILTER_VERSION_MINOR 74
 #define LIBAVFILTER_VERSION_MICRO 100
 #define LIBAVFILTER_VERSION_INT AV_VERSION_INT(LIBAVFILTER_VERSION_MAJOR, \
 #ifndef FF_API_SAMPLERATE64
 #define FF_API_SAMPLERATE64             (LIBAVFILTER_VERSION_MAJOR < 3)
 #endif
+#ifndef FF_API_VSRC_BUFFER_ADD_FRAME
+#define FF_API_VSRC_BUFFER_ADD_FRAME        (LIBAVFILTER_VERSION_MAJOR < 3)
+#endif
 #endif // AVFILTER_VERSION_H

libavfilter/vf_yadif.c+36−18

@@ -59,6 +59,7 @@ typedef struct { · 58 unmodified lines
59	int w, int prefs, int mrefs, int parity, int mode);	59	int w, int prefs, int mrefs, int parity, int mode);
60		60
61	const AVPixFmtDescriptor *csp;	61	const AVPixFmtDescriptor *csp;
		62	int eof;
62	} YADIFContext;	63	} YADIFContext;
63		64
64	#define CHECK(j)\	65	#define CHECK(j)\
@@ -216,22 +217,11 @@ static void return_frame(AVFilterContext *ctx, int is_second) · 151 unmodified lines
216	filter(ctx, yadif->out, tff ^ !is_second, tff);	217	filter(ctx, yadif->out, tff ^ !is_second, tff);
217		218
218	if (is_second) {	219	if (is_second) {
219	if (yadif->next->pts != AV_NOPTS_VALUE &&	220	int64_t cur_pts = yadif->cur->pts;
220	yadif->cur->pts != AV_NOPTS_VALUE) {	221	int64_t next_pts = yadif->next->pts;
221	uint64_t next_pts = yadif->next->pts;	222
222	uint64_t cur_pts = yadif->cur->pts;	223	if (next_pts != AV_NOPTS_VALUE && cur_pts != AV_NOPTS_VALUE) {
223	uint64_t prev_pts = yadif->prev->pts;	224	yadif->out->pts = cur_pts + next_pts;
224
225	uint64_t ft = FFMIN3( cur_pts-prev_pts,
226	next_pts-cur_pts,
227	(next_pts-prev_pts)/2);
228
229	if(next_pts - cur_pts < 2*ft)
230	yadif->out->pts =
231	(next_pts&cur_pts) +
232	((next_pts^cur_pts)>>1);
233	else
234	yadif->out->pts = cur_pts + ft/2;
235	} else {	225	} else {
236	yadif->out->pts = AV_NOPTS_VALUE;	226	yadif->out->pts = AV_NOPTS_VALUE;
237	}	227	}
@@ -264,6 +254,8 @@ static void start_frame(AVFilterLink link, AVFilterBufferRef picref) · 26 unmodified lines
264	yadif->out = avfilter_ref_buffer(yadif->cur, AV_PERM_READ);	254	yadif->out = avfilter_ref_buffer(yadif->cur, AV_PERM_READ);
265	avfilter_unref_buffer(yadif->prev);	255	avfilter_unref_buffer(yadif->prev);
266	yadif->prev = NULL;	256	yadif->prev = NULL;
		257	if (yadif->out->pts != AV_NOPTS_VALUE)
		258	yadif->out->pts *= 2;
267	avfilter_start_frame(ctx->outputs[0], yadif->out);	259	avfilter_start_frame(ctx->outputs[0], yadif->out);
268	return;	260	return;
269	}	261	}
@@ -276,6 +268,8 @@ static void start_frame(AVFilterLink link, AVFilterBufferRef picref) · 6 unmodified lines
276		268
277	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);	269	avfilter_copy_buffer_ref_props(yadif->out, yadif->cur);
278	yadif->out->video->interlaced = 0;	270	yadif->out->video->interlaced = 0;
		271	if (yadif->out->pts != AV_NOPTS_VALUE)
		272	yadif->out->pts *= 2;
279	avfilter_start_frame(ctx->outputs[0], yadif->out);	273	avfilter_start_frame(ctx->outputs[0], yadif->out);
280	}	274	}
281		275
@@ -309,8 +303,21 @@ static int request_frame(AVFilterLink *link) · 27 unmodified lines
309	do {	303	do {
310	int ret;	304	int ret;
311		305
312	if ((ret = avfilter_request_frame(link->src->inputs[0])))	306	if (yadif->eof)
		307	return AVERROR_EOF;
		308
		309	ret = avfilter_request_frame(link->src->inputs[0]);
		310
		311	if (ret == AVERROR_EOF && yadif->next) {
		312	AVFilterBufferRef *next = avfilter_ref_buffer(yadif->next, AV_PERM_READ);
		313	next->pts = yadif->next->pts * 2 - yadif->cur->pts;
		314
		315	start_frame(link->src->inputs[0], next);
		316	end_frame(link->src->inputs[0]);
		317	yadif->eof = 1;
		318	} else if (ret < 0) {
313	return ret;	319	return ret;
		320	}
314	} while (!yadif->cur);	321	} while (!yadif->cur);
315		322
316	return 0;	323	return 0;
@@ -411,6 +418,16 @@ static av_cold int init(AVFilterContext ctx, const char args, void *opaque) · 94 unmodified lines
411		418
412	static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }	419	static void null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir) { }
413		420
		421	static int config_props(AVFilterLink *link)
		422	{
		423	link->time_base.num = link->src->inputs[0]->time_base.num;
		424	link->time_base.den = link->src->inputs[0]->time_base.den * 2;
		425	link->w = link->src->inputs[0]->w;
		426	link->h = link->src->inputs[0]->h;
		427
		428	return 0;
		429	}
		430
414	AVFilter avfilter_vf_yadif = {	431	AVFilter avfilter_vf_yadif = {
415	.name = "yadif",	432	.name = "yadif",
416	.description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),	433	.description = NULL_IF_CONFIG_SMALL("Deinterlace the input image."),
@@ -432,6 +449,7 @@ AVFilter avfilter_vf_yadif = { · 15 unmodified lines
432	.outputs = (const AVFilterPad[]) {{ .name = "default",	449	.outputs = (const AVFilterPad[]) {{ .name = "default",
433	.type = AVMEDIA_TYPE_VIDEO,	450	.type = AVMEDIA_TYPE_VIDEO,
434	.poll_frame = poll_frame,	451	.poll_frame = poll_frame,
435	.request_frame = request_frame, },	452	.request_frame = request_frame,
		453	.config_props = config_props, },
436	{ .name = NULL}},	454	{ .name = NULL}},
437	};	455	};

libavfilter/video.c+345−0

@@ -0,0 +1,345 @@
	1	/*
	2	* This file is part of FFmpeg.
	3	*
	4	* FFmpeg 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	* FFmpeg 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 FFmpeg; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	17	*/
	18
	19	#include "libavutil/imgutils.h"
	20
	21	#include "avfilter.h"
	22	#include "internal.h"
	23
	24	static char ff_get_ref_perms_string(char buf, size_t buf_size, int perms)
	25	{
	26	snprintf(buf, buf_size, "%s%s%s%s%s%s",
	27	perms & AV_PERM_READ ? "r" : "",
	28	perms & AV_PERM_WRITE ? "w" : "",
	29	perms & AV_PERM_PRESERVE ? "p" : "",
	30	perms & AV_PERM_REUSE ? "u" : "",
	31	perms & AV_PERM_REUSE2 ? "U" : "",
	32	perms & AV_PERM_NEG_LINESIZES ? "n" : "");
	33	return buf;
	34	}
	35
	36	static void ff_dlog_ref(void ctx, AVFilterBufferRef ref, int end)
	37	{
	38	av_unused char buf[16];
	39	av_dlog(ctx,
	40	"ref[%p buf:%p refcount:%d perms:%s data:%p linesize[%d, %d, %d, %d] pts:%"PRId64" pos:%"PRId64,
	41	ref, ref->buf, ref->buf->refcount, ff_get_ref_perms_string(buf, sizeof(buf), ref->perms), ref->data[0],
	42	ref->linesize[0], ref->linesize[1], ref->linesize[2], ref->linesize[3],
	43	ref->pts, ref->pos);
	44
	45	if (ref->video) {
	46	av_dlog(ctx, " a:%d/%d s:%dx%d i:%c iskey:%d type:%c",
	47	ref->video->sample_aspect_ratio.num, ref->video->sample_aspect_ratio.den,
	48	ref->video->w, ref->video->h,
	49	!ref->video->interlaced ? 'P' : /* Progressive */
	50	ref->video->top_field_first ? 'T' : 'B', /* Top / Bottom */
	51	ref->video->key_frame,
	52	av_get_picture_type_char(ref->video->pict_type));
	53	}
	54	if (ref->audio) {
	55	av_dlog(ctx, " cl:%"PRId64"d n:%d r:%d p:%d",
	56	ref->audio->channel_layout,
	57	ref->audio->nb_samples,
	58	ref->audio->sample_rate,
	59	ref->audio->planar);
	60	}
	61
	62	av_dlog(ctx, "]%s", end ? "\n" : "");
	63	}
	64
	65	AVFilterBufferRef avfilter_null_get_video_buffer(AVFilterLink link, int perms, int w, int h)
	66	{
	67	return avfilter_get_video_buffer(link->dst->outputs[0], perms, w, h);
	68	}
	69
	70	AVFilterBufferRef avfilter_default_get_video_buffer(AVFilterLink link, int perms, int w, int h)
	71	{
	72	int linesize[4];
	73	uint8_t *data[4];
	74	int i;
	75	AVFilterBufferRef *picref = NULL;
	76	AVFilterPool *pool = link->pool;
	77
	78	if (pool) {
	79	for (i = 0; i < POOL_SIZE; i++) {
	80	picref = pool->pic[i];
	81	if (picref && picref->buf->format == link->format && picref->buf->w == w && picref->buf->h == h) {
	82	AVFilterBuffer *pic = picref->buf;
	83	pool->pic[i] = NULL;
	84	pool->count--;
	85	picref->video->w = w;
	86	picref->video->h = h;
	87	picref->perms = perms \| AV_PERM_READ;
	88	picref->format = link->format;
	89	pic->refcount = 1;
	90	memcpy(picref->data, pic->data, sizeof(picref->data));
	91	memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
	92	pool->refcount++;
	93	return picref;
	94	}
	95	}
	96	} else {
	97	pool = link->pool = av_mallocz(sizeof(AVFilterPool));
	98	pool->refcount = 1;
	99	}
	100
	101	// align: +2 is needed for swscaler, +16 to be SIMD-friendly
	102	if ((i = av_image_alloc(data, linesize, w, h, link->format, 32)) < 0)
	103	return NULL;
	104
	105	picref = avfilter_get_video_buffer_ref_from_arrays(data, linesize,
	106	perms, w, h, link->format);
	107	if (!picref) {
	108	av_free(data[0]);
	109	return NULL;
	110	}
	111
	112	memset(data[0], 128, i);
	113
	114	picref->buf->priv = pool;
	115	picref->buf->free = NULL;
	116	pool->refcount++;
	117
	118	return picref;
	119	}
	120
	121	AVFilterBufferRef *
	122	avfilter_get_video_buffer_ref_from_arrays(uint8_t * const data[4], const int linesize[4], int perms,
	123	int w, int h, enum PixelFormat format)
	124	{
	125	AVFilterBuffer *pic = av_mallocz(sizeof(AVFilterBuffer));
	126	AVFilterBufferRef *picref = av_mallocz(sizeof(AVFilterBufferRef));
	127
	128	if (!pic \|\| !picref)
	129	goto fail;
	130
	131	picref->buf = pic;
	132	picref->buf->free = ff_avfilter_default_free_buffer;
	133	if (!(picref->video = av_mallocz(sizeof(AVFilterBufferRefVideoProps))))
	134	goto fail;
	135
	136	pic->w = picref->video->w = w;
	137	pic->h = picref->video->h = h;
	138
	139	/* make sure the buffer gets read permission or it's useless for output */
	140	picref->perms = perms \| AV_PERM_READ;
	141
	142	pic->refcount = 1;
	143	picref->type = AVMEDIA_TYPE_VIDEO;
	144	pic->format = picref->format = format;
	145
	146	memcpy(pic->data, data, 4*sizeof(data[0]));
	147	memcpy(pic->linesize, linesize, 4*sizeof(linesize[0]));
	148	memcpy(picref->data, pic->data, sizeof(picref->data));
	149	memcpy(picref->linesize, pic->linesize, sizeof(picref->linesize));
	150
	151	pic-> extended_data = pic->data;
	152	picref->extended_data = picref->data;
	153
	154	return picref;
	155
	156	fail:
	157	if (picref && picref->video)
	158	av_free(picref->video);
	159	av_free(picref);
	160	av_free(pic);
	161	return NULL;
	162	}
	163
	164	AVFilterBufferRef avfilter_get_video_buffer(AVFilterLink link, int perms, int w, int h)
	165	{
	166	AVFilterBufferRef *ret = NULL;
	167
	168	av_unused char buf[16];
	169	FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0);
	170	av_dlog(NULL, " perms:%s w:%d h:%d\n", ff_get_ref_perms_string(buf, sizeof(buf), perms), w, h);
	171
	172	if (link->dstpad->get_video_buffer)
	173	ret = link->dstpad->get_video_buffer(link, perms, w, h);
	174
	175	if (!ret)
	176	ret = avfilter_default_get_video_buffer(link, perms, w, h);
	177
	178	if (ret)
	179	ret->type = AVMEDIA_TYPE_VIDEO;
	180
	181	FF_DPRINTF_START(NULL, get_video_buffer); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " returning "); ff_dlog_ref(NULL, ret, 1);
	182
	183	return ret;
	184	}
	185
	186	void avfilter_null_start_frame(AVFilterLink link, AVFilterBufferRef picref)
	187	{
	188	avfilter_start_frame(link->dst->outputs[0], picref);
	189	}
	190
	191	void avfilter_default_start_frame(AVFilterLink inlink, AVFilterBufferRef picref)
	192	{
	193	AVFilterLink *outlink = NULL;
	194
	195	if (inlink->dst->output_count)
	196	outlink = inlink->dst->outputs[0];
	197
	198	if (outlink) {
	199	outlink->out_buf = avfilter_get_video_buffer(outlink, AV_PERM_WRITE, outlink->w, outlink->h);
	200	avfilter_copy_buffer_ref_props(outlink->out_buf, picref);
	201	avfilter_start_frame(outlink, avfilter_ref_buffer(outlink->out_buf, ~0));
	202	}
	203	}
	204
	205	/* XXX: should we do the duplicating of the picture ref here, instead of
	206	* forcing the source filter to do it? */
	207	void avfilter_start_frame(AVFilterLink link, AVFilterBufferRef picref)
	208	{
	209	void (start_frame)(AVFilterLink , AVFilterBufferRef *);
	210	AVFilterPad *dst = link->dstpad;
	211	int perms = picref->perms;
	212	AVFilterCommand *cmd= link->dst->command_queue;
	213
	214	FF_DPRINTF_START(NULL, start_frame); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " "); ff_dlog_ref(NULL, picref, 1);
	215
	216	if (!(start_frame = dst->start_frame))
	217	start_frame = avfilter_default_start_frame;
	218
	219	if (picref->linesize[0] < 0)
	220	perms \|= AV_PERM_NEG_LINESIZES;
	221	/* prepare to copy the picture if it has insufficient permissions */
	222	if ((dst->min_perms & perms) != dst->min_perms \|\| dst->rej_perms & perms) {
	223	av_log(link->dst, AV_LOG_DEBUG,
	224	"frame copy needed (have perms %x, need %x, reject %x)\n",
	225	picref->perms,
	226	link->dstpad->min_perms, link->dstpad->rej_perms);
	227
	228	link->cur_buf = avfilter_get_video_buffer(link, dst->min_perms, link->w, link->h);
	229	link->src_buf = picref;
	230	avfilter_copy_buffer_ref_props(link->cur_buf, link->src_buf);
	231	}
	232	else
	233	link->cur_buf = picref;
	234
	235	while(cmd && cmd->time <= picref->pts * av_q2d(link->time_base)){
	236	av_log(link->dst, AV_LOG_DEBUG,
	237	"Processing command time:%f command:%s arg:%s\n",
	238	cmd->time, cmd->command, cmd->arg);
	239	avfilter_process_command(link->dst, cmd->command, cmd->arg, 0, 0, cmd->flags);
	240	ff_command_queue_pop(link->dst);
	241	cmd= link->dst->command_queue;
	242	}
	243
	244	start_frame(link, link->cur_buf);
	245	ff_update_link_current_pts(link, link->cur_buf->pts);
	246	}
	247
	248	void avfilter_null_end_frame(AVFilterLink *link)
	249	{
	250	avfilter_end_frame(link->dst->outputs[0]);
	251	}
	252
	253	void avfilter_default_end_frame(AVFilterLink *inlink)
	254	{
	255	AVFilterLink *outlink = NULL;
	256
	257	if (inlink->dst->output_count)
	258	outlink = inlink->dst->outputs[0];
	259
	260	avfilter_unref_buffer(inlink->cur_buf);
	261	inlink->cur_buf = NULL;
	262
	263	if (outlink) {
	264	if (outlink->out_buf) {
	265	avfilter_unref_buffer(outlink->out_buf);
	266	outlink->out_buf = NULL;
	267	}
	268	avfilter_end_frame(outlink);
	269	}
	270	}
	271
	272	void avfilter_end_frame(AVFilterLink *link)
	273	{
	274	void (end_frame)(AVFilterLink );
	275
	276	if (!(end_frame = link->dstpad->end_frame))
	277	end_frame = avfilter_default_end_frame;
	278
	279	end_frame(link);
	280
	281	/* unreference the source picture if we're feeding the destination filter
	282	* a copied version dues to permission issues */
	283	if (link->src_buf) {
	284	avfilter_unref_buffer(link->src_buf);
	285	link->src_buf = NULL;
	286	}
	287	}
	288
	289	void avfilter_null_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
	290	{
	291	avfilter_draw_slice(link->dst->outputs[0], y, h, slice_dir);
	292	}
	293
	294	void avfilter_default_draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
	295	{
	296	AVFilterLink *outlink = NULL;
	297
	298	if (inlink->dst->output_count)
	299	outlink = inlink->dst->outputs[0];
	300
	301	if (outlink)
	302	avfilter_draw_slice(outlink, y, h, slice_dir);
	303	}
	304
	305	void avfilter_draw_slice(AVFilterLink *link, int y, int h, int slice_dir)
	306	{
	307	uint8_t src[4], dst[4];
	308	int i, j, vsub;
	309	void (draw_slice)(AVFilterLink , int, int, int);
	310
	311	FF_DPRINTF_START(NULL, draw_slice); ff_dlog_link(NULL, link, 0); av_dlog(NULL, " y:%d h:%d dir:%d\n", y, h, slice_dir);
	312
	313	/* copy the slice if needed for permission reasons */
	314	if (link->src_buf) {
	315	vsub = av_pix_fmt_descriptors[link->format].log2_chroma_h;
	316
	317	for (i = 0; i < 4; i++) {
	318	if (link->src_buf->data[i]) {
	319	src[i] = link->src_buf-> data[i] +
	320	(y >> (i==1 \|\| i==2 ? vsub : 0)) * link->src_buf-> linesize[i];
	321	dst[i] = link->cur_buf->data[i] +
	322	(y >> (i==1 \|\| i==2 ? vsub : 0)) * link->cur_buf->linesize[i];
	323	} else
	324	src[i] = dst[i] = NULL;
	325	}
	326
	327	for (i = 0; i < 4; i++) {
	328	int planew =
	329	av_image_get_linesize(link->format, link->cur_buf->video->w, i);
	330
	331	if (!src[i]) continue;
	332
	333	for (j = 0; j < h >> (i==1 \|\| i==2 ? vsub : 0); j++) {
	334	memcpy(dst[i], src[i], planew);
	335	src[i] += link->src_buf->linesize[i];
	336	dst[i] += link->cur_buf->linesize[i];
	337	}
	338	}
	339	}
	340
	341	if (!(draw_slice = link->dstpad->draw_slice))
	342	draw_slice = avfilter_default_draw_slice;
	343	draw_slice(link, y, h, slice_dir);
	344	}
	345

libavutil/avutil.h+1−1

@@ -153,7 +153,7 @@ · 152 unmodified lines
153	*/	153	*/
154		154
155	#define LIBAVUTIL_VERSION_MAJOR 51	155	#define LIBAVUTIL_VERSION_MAJOR 51
156	#define LIBAVUTIL_VERSION_MINOR 52	156	#define LIBAVUTIL_VERSION_MINOR 53
157	#define LIBAVUTIL_VERSION_MICRO 100	157	#define LIBAVUTIL_VERSION_MICRO 100
158		158
159	#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \	159	#define LIBAVUTIL_VERSION_INT AV_VERSION_INT(LIBAVUTIL_VERSION_MAJOR, \

tests/fate-run.sh+1−3

@@ -61,9 +61,7 @@ stddev(){ · 60 unmodified lines
61	}	61	}
62		62
63	oneline(){	63	oneline(){
64	val=$(cat "$2")	64	printf '%s\n' "$1" \| diff -u -b - "$2"
65	test x"$val" = x"$1" \|\| { r=$?; printf -- '-%s\n+%s\n' "$ref" "$val"; }
66	return ${r:-0}
67	}	65	}
68		66
69	run(){	67	run(){

tests/fate/audio.mak+6−0

 fate-nellymoser-aref-encode: CMP_TARGET = 9617
 fate-nellymoser-aref-encode: SIZE_TOLERANCE = 268
+FATE_AUDIO += fate-sierra-vmd-audio
+fate-sierra-vmd-audio: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -vn
+FATE_AUDIO += fate-smacker-audio
+fate-smacker-audio: CMD = framecrc -i $(SAMPLES)/smacker/wetlogo.smk -vn
 FATE_AUDIO += fate-ws_snd
 fate-ws_snd: CMD = md5 -i $(SAMPLES)/vqa/ws_snd.vqa -f s16le

tests/fate/demux.mak+2−5

 FATE_DEMUX += fate-redcode-demux
 fate-redcode-demux: CMD = framecrc -i $(SAMPLES)/r3d/4MB-sample.r3d -vcodec copy -acodec copy
-FATE_DEMUX += fate-sierra-vmd
-fate-sierra-vmd: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -pix_fmt rgb24
 FATE_DEMUX += fate-siff
 fate-siff: CMD = framecrc -i $(SAMPLES)/SIFF/INTRO_B.VB -t 3 -pix_fmt rgb24
-FATE_DEMUX += fate-smjpeg
+FATE_DEMUX += fate-smjpeg-demux
-fate-smjpeg: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -vcodec copy
+fate-smjpeg-demux: CMD = framecrc -i $(SAMPLES)/smjpeg/scenwin.mjpg -c copy
 FATE_DEMUX += fate-westwood-aud
 fate-westwood-aud: CMD = framecrc -i $(SAMPLES)/westwood-aud/excellent.aud -c copy

tests/fate/video.mak+5−2

 FATE_VIDEO += fate-roqvideo
 fate-roqvideo: CMD = framecrc -i $(SAMPLES)/idroq/idlogo.roq -an
-FATE_VIDEO += fate-smacker
+FATA_VIDEO += fate-sierra-vmd-video
-fate-smacker: CMD = framecrc -i $(SAMPLES)/smacker/wetlogo.smk -pix_fmt rgb24
+fate-sierra-vmd-video: CMD = framecrc -i $(SAMPLES)/vmd/12.vmd -pix_fmt rgb24 -an
+FATA_VIDEO += fate-smacker-video
+fate-smacker-video: CMD = framecrc -i $(SAMPLES)/smacker/wetlogo.smk -pix_fmt rgb24 -an
 FATE_VIDEO += fate-smc
 fate-smc: CMD = framecrc -i $(SAMPLES)/smc/cass_schi.qt -pix_fmt rgb24

tests/ref/fate/sierra-vmd+0−334

@@ -1,334 +0,0 @@
1	#tb 0: 1/10
2	#tb 1: 1/22050
3	0, 0, 0, 1, 230400, 0x0224ab01
4	1, 0, 0, 61740, 123480, 0x3a794c13
5	0, 1, 1, 1, 230400, 0x449e4d81
6	0, 2, 2, 1, 230400, 0x3e15e07a
7	0, 3, 3, 1, 230400, 0xdabe4172
8	0, 4, 4, 1, 230400, 0x0947b7db
9	0, 5, 5, 1, 230400, 0x934e243b
10	0, 6, 6, 1, 230400, 0x6b5c5b6c
11	0, 7, 7, 1, 230400, 0x4bf7bbb5
12	0, 8, 8, 1, 230400, 0x423eec8e
13	0, 9, 9, 1, 230400, 0x63663b5e
14	0, 10, 10, 1, 230400, 0x9c258a67
15	0, 11, 11, 1, 230400, 0x1c92b6e0
16	0, 12, 12, 1, 230400, 0xdd0a0e28
17	0, 13, 13, 1, 230400, 0x51d64af1
18	0, 14, 14, 1, 230400, 0x5776ac12
19	0, 15, 15, 1, 230400, 0x49070132
20	0, 16, 16, 1, 230400, 0xa59635ab
21	0, 17, 17, 1, 230400, 0xb1f99504
22	0, 18, 18, 1, 230400, 0x61fac725
23	0, 19, 19, 1, 230400, 0xc32c28d5
24	0, 20, 20, 1, 230400, 0x2b7a91d6
25	0, 21, 21, 1, 230400, 0x917be717
26	0, 22, 22, 1, 230400, 0xd3c5a2ff
27	0, 23, 23, 1, 230400, 0x0678a707
28	0, 24, 24, 1, 230400, 0x122504e6
29	0, 25, 25, 1, 230400, 0x76aebdae
30	0, 26, 26, 1, 230400, 0x81357545
31	0, 27, 27, 1, 230400, 0x38baeebd
32	0, 28, 28, 1, 230400, 0x1c5c44d4
33	1, 61740, 61740, 2205, 4410, 0x109d04e0
34	0, 29, 29, 1, 230400, 0x60e189cc
35	1, 63945, 63945, 2205, 4410, 0x224d244f
36	0, 30, 30, 1, 230400, 0xb1f4381c
37	1, 66150, 66150, 2205, 4410, 0xbb72413d
38	0, 31, 31, 1, 230400, 0xb5048fed
39	1, 68355, 68355, 2205, 4410, 0xaa5f5b86
40	0, 32, 32, 1, 230400, 0xc947c30e
41	1, 70560, 70560, 2205, 4410, 0x94e7aea7
42	0, 33, 33, 1, 230400, 0xe8e31c07
43	1, 72765, 72765, 2205, 4410, 0xad497ca0
44	0, 34, 34, 1, 230400, 0x6d49dd02
45	1, 74970, 74970, 2205, 4410, 0x1de10c9e
46	0, 35, 35, 1, 230400, 0x293e15d3
47	1, 77175, 77175, 2205, 4410, 0x9f55efa8
48	0, 36, 36, 1, 230400, 0x354d792e
49	1, 79380, 79380, 2205, 4410, 0x220a072a
50	0, 37, 37, 1, 230400, 0x35468780
51	1, 81585, 81585, 2205, 4410, 0xa7dafb29
52	0, 38, 38, 1, 230400, 0x365d3991
53	1, 83790, 83790, 2205, 4410, 0xd5e29c7a
54	0, 39, 39, 1, 230400, 0xc9debef2
55	1, 85995, 85995, 2205, 4410, 0xb8465006
56	0, 40, 40, 1, 230400, 0x4c4634c2
57	1, 88200, 88200, 2205, 4410, 0x518669c7
58	0, 41, 41, 1, 230400, 0x347c2dca
59	1, 90405, 90405, 2205, 4410, 0xb5b5efca
60	0, 42, 42, 1, 230400, 0x1efa0aaa
61	1, 92610, 92610, 2205, 4410, 0x8600015d
62	0, 43, 43, 1, 230400, 0xa79a0b5a
63	1, 94815, 94815, 2205, 4410, 0xe2f68fe9
64	0, 44, 44, 1, 230400, 0xfdb2dcdb
65	1, 97020, 97020, 2205, 4410, 0x8d3458d9
66	0, 45, 45, 1, 230400, 0x42dbea33
67	1, 99225, 99225, 2205, 4410, 0xf1ff4775
68	0, 46, 46, 1, 230400, 0x2a207e43
69	1, 101430, 101430, 2205, 4410, 0x830f67c9
70	0, 47, 47, 1, 230400, 0x86573783
71	1, 103635, 103635, 2205, 4410, 0x110e0bc1
72	0, 48, 48, 1, 230400, 0xc3968473
73	1, 105840, 105840, 2205, 4410, 0x71682f47
74	0, 49, 49, 1, 230400, 0x8f62a7b4
75	1, 108045, 108045, 2205, 4410, 0x38119095
76	0, 50, 50, 1, 230400, 0x5a2e3073
77	1, 110250, 110250, 2205, 4410, 0xd2494db6
78	0, 51, 51, 1, 230400, 0xd24f5e2c
79	1, 112455, 112455, 2205, 4410, 0x8b552509
80	0, 52, 52, 1, 230400, 0x1df3c67d
81	1, 114660, 114660, 2205, 4410, 0x71e52909
82	0, 53, 53, 1, 230400, 0xe4fd884d
83	1, 116865, 116865, 2205, 4410, 0x9f0a6f4d
84	1, 119070, 119070, 2205, 4410, 0x901302f2
85	1, 121275, 121275, 2205, 4410, 0x855d5222
86	1, 123480, 123480, 2205, 4410, 0x324bb2fe
87	0, 57, 57, 1, 230400, 0x9a228555
88	1, 125685, 125685, 2205, 4410, 0xe85f583f
89	0, 58, 58, 1, 230400, 0x9eba8ed5
90	1, 127890, 127890, 2205, 4410, 0x2cbc67c4
91	0, 59, 59, 1, 230400, 0x3d808a3d
92	1, 130095, 130095, 2205, 4410, 0xc82e6aa1
93	0, 60, 60, 1, 230400, 0xf57e866d
94	1, 132300, 132300, 2205, 4410, 0xb9fc423c
95	0, 61, 61, 1, 230400, 0x85f594f5
96	1, 134505, 134505, 2205, 4410, 0x6b9b4ef9
97	0, 62, 62, 1, 230400, 0xb09f99dd
98	1, 136710, 136710, 2205, 4410, 0x39290f10
99	0, 63, 63, 1, 230400, 0x2b368475
100	1, 138915, 138915, 2205, 4410, 0xad718eb4
101	0, 64, 64, 1, 230400, 0xa2417afd
102	1, 141120, 141120, 2205, 4410, 0x82f463ac
103	0, 65, 65, 1, 230400, 0x590b709d
104	1, 143325, 143325, 2205, 4410, 0xfac87cac
105	0, 66, 66, 1, 230400, 0x5d617705
106	1, 145530, 145530, 2205, 4410, 0x9e8bcca7
107	0, 67, 67, 1, 230400, 0xabf981ad
108	1, 147735, 147735, 2205, 4410, 0x52f79c99
109	0, 68, 68, 1, 230400, 0x5a8590cd
110	1, 149940, 149940, 2205, 4410, 0xf2d14de2
111	0, 69, 69, 1, 230400, 0x1bff853d
112	1, 152145, 152145, 2205, 4410, 0x367f95e1
113	0, 70, 70, 1, 230400, 0x71d08055
114	1, 154350, 154350, 2205, 4410, 0x8bfac293
115	0, 71, 71, 1, 230400, 0x2ebd817d
116	1, 156555, 156555, 2205, 4410, 0x01ea5040
117	0, 72, 72, 1, 230400, 0x6e838255
118	1, 158760, 158760, 2205, 4410, 0x8ff5e212
119	0, 73, 73, 1, 230400, 0x043984cd
120	1, 160965, 160965, 2205, 4410, 0x93f32824
121	0, 74, 74, 1, 230400, 0x7ff18495
122	1, 163170, 163170, 2205, 4410, 0x998f90dc
123	0, 75, 75, 1, 230400, 0xa43b8385
124	1, 165375, 165375, 2205, 4410, 0x65231170
125	0, 76, 76, 1, 230400, 0x72b5825d
126	1, 167580, 167580, 2205, 4410, 0xc79039a1
127	0, 77, 77, 1, 230400, 0x3a178085
128	1, 169785, 169785, 2205, 4410, 0x0b0e58bd
129	0, 78, 78, 1, 230400, 0x67748245
130	1, 171990, 171990, 2205, 4410, 0xc24ab4fa
131	0, 79, 79, 1, 230400, 0xeddf81d5
132	1, 174195, 174195, 2205, 4410, 0xd3796a8e
133	0, 80, 80, 1, 230400, 0x8b088665
134	1, 176400, 176400, 2205, 4410, 0xa37f8295
135	0, 81, 81, 1, 230400, 0x6c408e15
136	1, 178605, 178605, 2205, 4410, 0xb760fed7
137	0, 82, 82, 1, 230400, 0x81f196dd
138	1, 180810, 180810, 2205, 4410, 0x05495a34
139	0, 83, 83, 1, 230400, 0xab9f953d
140	1, 183015, 183015, 2205, 4410, 0x6f203437
141	0, 84, 84, 1, 230400, 0xa5f69795
142	1, 185220, 185220, 2205, 4410, 0x71299402
143	0, 85, 85, 1, 230400, 0xa772950d
144	1, 187425, 187425, 2205, 4410, 0x72e7b346
145	0, 86, 86, 1, 230400, 0x6a5596d5
146	1, 189630, 189630, 2205, 4410, 0x879b0dae
147	0, 87, 87, 1, 230400, 0x1355958d
148	1, 191835, 191835, 2205, 4410, 0x041aa1bd
149	0, 88, 88, 1, 230400, 0x4134981d
150	1, 194040, 194040, 2205, 4410, 0x18a962e6
151	0, 89, 89, 1, 230400, 0x8b929515
152	1, 196245, 196245, 2205, 4410, 0x21d20539
153	0, 90, 90, 1, 230400, 0x482f95c5
154	1, 198450, 198450, 2205, 4410, 0x8f449267
155	0, 91, 91, 1, 230400, 0x7a9795d5
156	1, 200655, 200655, 2205, 4410, 0xecdc01d6
157	0, 92, 92, 1, 230400, 0x21c29abd
158	1, 202860, 202860, 2205, 4410, 0x458abd5a
159	0, 93, 93, 1, 230400, 0x9ae6a475
160	1, 205065, 205065, 2205, 4410, 0xa070ea63
161	0, 94, 94, 1, 230400, 0x3734aee5
162	1, 207270, 207270, 2205, 4410, 0xc25b26ce
163	0, 95, 95, 1, 230400, 0xa0a1b365
164	1, 209475, 209475, 2205, 4410, 0x4d9237ca
165	0, 96, 96, 1, 230400, 0x2dcab1c5
166	1, 211680, 211680, 2205, 4410, 0x748e1801
167	0, 97, 97, 1, 230400, 0x9c8b6c44
168	1, 213885, 213885, 2205, 4410, 0xc96b69e6
169	0, 98, 98, 1, 230400, 0x5da75feb
170	1, 216090, 216090, 2205, 4410, 0x6663186c
171	0, 99, 99, 1, 230400, 0x4d02f8e3
172	1, 218295, 218295, 2205, 4410, 0x7f6d3081
173	0, 100, 100, 1, 230400, 0x66824f3a
174	1, 220500, 220500, 2205, 4410, 0x1a0343b5
175	0, 101, 101, 1, 230400, 0x0c9257e2
176	1, 222705, 222705, 2205, 4410, 0xc48e338c
177	0, 102, 102, 1, 230400, 0xb2927092
178	1, 224910, 224910, 2205, 4410, 0x26fc03c8
179	0, 103, 103, 1, 230400, 0xb5dc6e9a
180	1, 227115, 227115, 2205, 4410, 0x69be7e2d
181	0, 104, 104, 1, 230400, 0x6e567bc6
182	1, 229320, 229320, 2205, 4410, 0x69a74da1
183	0, 105, 105, 1, 230400, 0xbf9e0f7a
184	1, 231525, 231525, 2205, 4410, 0x85bd2ab3
185	0, 106, 106, 1, 230400, 0xb16f684a
186	1, 233730, 233730, 2205, 4410, 0xeff05426
187	0, 107, 107, 1, 230400, 0xf9e55e81
188	1, 235935, 235935, 2205, 4410, 0x292829e0
189	0, 108, 108, 1, 230400, 0xd8d0bcba
190	1, 238140, 238140, 2205, 4410, 0x8f741798
191	0, 109, 109, 1, 230400, 0x44720ac0
192	1, 240345, 240345, 2205, 4410, 0x6b9337e9
193	0, 110, 110, 1, 230400, 0x7d4c2058
194	1, 242550, 242550, 2205, 4410, 0xe4e1703f
195	1, 244755, 244755, 2205, 4410, 0x043d6c35
196	1, 246960, 246960, 2205, 4410, 0x3a8988e7
197	0, 113, 113, 1, 230400, 0xb0973eb9
198	1, 249165, 249165, 2205, 4410, 0x1fa7d2a9
199	0, 114, 114, 1, 230400, 0x405a13ce
200	1, 251370, 251370, 2205, 4410, 0xe28799e3
201	0, 115, 115, 1, 230400, 0x6422f00a
202	1, 253575, 253575, 2205, 4410, 0xc2df4470
203	0, 116, 116, 1, 230400, 0x924b6c1e
204	1, 255780, 255780, 2205, 4410, 0x694d0cf5
205	1, 257985, 257985, 2205, 4410, 0x5aac2dcf
206	1, 260190, 260190, 2205, 4410, 0x259fa2db
207	1, 262395, 262395, 2205, 4410, 0xd16d6803
208	1, 264600, 264600, 2205, 4410, 0xa4b3478a
209	1, 266805, 266805, 2205, 4410, 0xdbe0443d
210	1, 269010, 269010, 2205, 4410, 0x26c16119
211	1, 271215, 271215, 2205, 4410, 0x0c06475c
212	1, 273420, 273420, 2205, 4410, 0x6ffaba2d
213	1, 275625, 275625, 2205, 4410, 0x5b287192
214	1, 277830, 277830, 2205, 4410, 0xf2cf2651
215	1, 280035, 280035, 2205, 4410, 0x3857673a
216	1, 282240, 282240, 2205, 4410, 0x5b555feb
217	1, 284445, 284445, 2205, 4410, 0x93f997af
218	1, 286650, 286650, 2205, 4410, 0xb3ba8d35
219	1, 288855, 288855, 2205, 4410, 0x66433944
220	1, 291060, 291060, 2205, 4410, 0xf0005a5f
221	1, 293265, 293265, 2205, 4410, 0xb948541f
222	1, 295470, 295470, 2205, 4410, 0xc8f1b16f
223	1, 297675, 297675, 2205, 4410, 0x7d4b7506
224	1, 299880, 299880, 2205, 4410, 0xac723c55
225	1, 302085, 302085, 2205, 4410, 0x2926fab5
226	1, 304290, 304290, 2205, 4410, 0x31684995
227	1, 306495, 306495, 2205, 4410, 0x35ebfca4
228	1, 308700, 308700, 2205, 4410, 0x9cd42c18
229	1, 310905, 310905, 2205, 4410, 0xd7ecd7b1
230	1, 313110, 313110, 2205, 4410, 0x5e13c602
231	1, 315315, 315315, 2205, 4410, 0xe955b5e3
232	1, 317520, 317520, 2205, 4410, 0xefad19a1
233	0, 145, 145, 1, 230400, 0xcf7809c0
234	1, 319725, 319725, 2205, 4410, 0x435950de
235	0, 146, 146, 1, 230400, 0x883a3863
236	1, 321930, 321930, 2205, 4410, 0x9d624ebe
237	0, 147, 147, 1, 230400, 0x6adc9e03
238	1, 324135, 324135, 2205, 4410, 0x774a9158
239	0, 148, 148, 1, 230400, 0x4f5ab7a8
240	1, 326340, 326340, 2205, 4410, 0x8c41e66a
241	1, 328545, 328545, 2205, 4410, 0x70112740
242	1, 330750, 330750, 2205, 4410, 0x55abc7a2
243	1, 332955, 332955, 2205, 4410, 0x0ec3183c
244	1, 335160, 335160, 2205, 4410, 0x54609c56
245	1, 337365, 337365, 2205, 4410, 0x60d49f92
246	1, 339570, 339570, 2205, 4410, 0x5fb061c8
247	1, 341775, 341775, 2205, 4410, 0x6e119c98
248	1, 343980, 343980, 2205, 4410, 0x3f39fc69
249	1, 346185, 346185, 2205, 4410, 0xef466d0e
250	1, 348390, 348390, 2205, 4410, 0xf4cb6fe1
251	1, 350595, 350595, 2205, 4410, 0xc4434439
252	1, 352800, 352800, 2205, 4410, 0xd02329d2
253	1, 355005, 355005, 2205, 4410, 0x216cffaf
254	1, 357210, 357210, 2205, 4410, 0x7e59e8c1
255	1, 359415, 359415, 2205, 4410, 0xc7c3346d
256	1, 361620, 361620, 2205, 4410, 0x5b3723af
257	1, 363825, 363825, 2205, 4410, 0x76097270
258	1, 366030, 366030, 2205, 4410, 0xae39a233
259	1, 368235, 368235, 2205, 4410, 0x686a471c
260	1, 370440, 370440, 2205, 4410, 0x3af3c5e0
261	1, 372645, 372645, 2205, 4410, 0x11ac711e
262	1, 374850, 374850, 2205, 4410, 0xcd8da8ce
263	1, 377055, 377055, 2205, 4410, 0x21296e3a
264	1, 379260, 379260, 2205, 4410, 0x77168188
265	1, 381465, 381465, 2205, 4410, 0x5fcf59cd
266	1, 383670, 383670, 2205, 4410, 0x390c8717
267	1, 385875, 385875, 2205, 4410, 0x3d5d5b3c
268	1, 388080, 388080, 2205, 4410, 0x3b8f13d3
269	1, 390285, 390285, 2205, 4410, 0x5b002c2f
270	1, 392490, 392490, 2205, 4410, 0x9e1d2b08
271	1, 394695, 394695, 2205, 4410, 0x69454ebd
272	1, 396900, 396900, 2205, 4410, 0x62a54bec
273	1, 399105, 399105, 2205, 4410, 0x4d231fdb
274	1, 401310, 401310, 2205, 4410, 0x65624ff7
275	1, 403515, 403515, 2205, 4410, 0x6fc66932
276	1, 405720, 405720, 2205, 4410, 0x23200cf6
277	1, 407925, 407925, 2205, 4410, 0xf8033122
278	1, 410130, 410130, 2205, 4410, 0x0fce0744
279	1, 412335, 412335, 2205, 4410, 0x9302683e
280	1, 414540, 414540, 2205, 4410, 0xd2380245
281	1, 416745, 416745, 2205, 4410, 0x482e0872
282	1, 418950, 418950, 2205, 4410, 0xe98e6461
283	1, 421155, 421155, 2205, 4410, 0x1db404e3
284	1, 423360, 423360, 2205, 4410, 0x47a26d45
285	1, 425565, 425565, 2205, 4410, 0x449a348a
286	1, 427770, 427770, 2205, 4410, 0xee874f84
287	1, 429975, 429975, 2205, 4410, 0xc4ecf965
288	1, 432180, 432180, 2205, 4410, 0xcc450bc8
289	1, 434385, 434385, 2205, 4410, 0xb18d044b
290	1, 436590, 436590, 2205, 4410, 0x895435e8
291	1, 438795, 438795, 2205, 4410, 0x57e7574e
292	1, 441000, 441000, 2205, 4410, 0x8041ad3d
293	1, 443205, 443205, 2205, 4410, 0x853d1616
294	1, 445410, 445410, 2205, 4410, 0xa11bb32b
295	1, 447615, 447615, 2205, 4410, 0xe10ea0de
296	1, 449820, 449820, 2205, 4410, 0xdf2ee328
297	1, 452025, 452025, 2205, 4410, 0xd5a6dcae
298	1, 454230, 454230, 2205, 4410, 0xd176c00b
299	1, 456435, 456435, 2205, 4410, 0x9cd6bcf3
300	1, 458640, 458640, 2205, 4410, 0x2569690a
301	1, 460845, 460845, 2205, 4410, 0x6824aa1d
302	1, 463050, 463050, 2205, 4410, 0xa9110afa
303	1, 465255, 465255, 2205, 4410, 0x115c25be
304	1, 467460, 467460, 2205, 4410, 0x1100f085
305	1, 469665, 469665, 2205, 4410, 0x00000000
306	0, 214, 214, 1, 230400, 0xdc0aab94
307	1, 471870, 471870, 2205, 4410, 0x00000000
308	1, 474075, 474075, 2205, 4410, 0x00000000
309	1, 476280, 476280, 2205, 4410, 0x00000000
310	1, 478485, 478485, 2205, 4410, 0x00000000
311	1, 480690, 480690, 2205, 4410, 0x00000000
312	1, 482895, 482895, 2205, 4410, 0x00000000
313	1, 485100, 485100, 2205, 4410, 0x00000000
314	1, 487305, 487305, 2205, 4410, 0x00000000
315	1, 489510, 489510, 2205, 4410, 0x00000000
316	1, 491715, 491715, 2205, 4410, 0x00000000
317	1, 493920, 493920, 2205, 4410, 0x00000000
318	1, 496125, 496125, 2205, 4410, 0x00000000
319	1, 498330, 498330, 2205, 4410, 0x00000000
320	1, 500535, 500535, 2205, 4410, 0x00000000
321	1, 502740, 502740, 2205, 4410, 0x00000000
322	1, 504945, 504945, 2205, 4410, 0x00000000
323	1, 507150, 507150, 2205, 4410, 0x00000000
324	1, 509355, 509355, 2205, 4410, 0x00000000
325	1, 511560, 511560, 2205, 4410, 0x00000000
326	1, 513765, 513765, 2205, 4410, 0x00000000
327	1, 515970, 515970, 2205, 4410, 0x00000000
328	1, 518175, 518175, 2205, 4410, 0x00000000
329	1, 520380, 520380, 2205, 4410, 0x00000000
330	1, 522585, 522585, 2205, 4410, 0x00000000
331	1, 524790, 524790, 2205, 4410, 0x00000000
332	1, 526995, 526995, 2205, 4410, 0x00000000
333	1, 529200, 529200, 2205, 4410, 0x00000000
334	1, 531405, 531405, 2205, 4410, 0x00000000

tests/ref/fate/sierra-vmd-audio+216−0

@@ -0,0 +1,216 @@
	1	#tb 0: 1/22050
	2	0, 0, 0, 61740, 123480, 0x3a794c13
	3	0, 61740, 61740, 2205, 4410, 0x109d04e0
	4	0, 63945, 63945, 2205, 4410, 0x224d244f
	5	0, 66150, 66150, 2205, 4410, 0xbb72413d
	6	0, 68355, 68355, 2205, 4410, 0xaa5f5b86
	7	0, 70560, 70560, 2205, 4410, 0x94e7aea7
	8	0, 72765, 72765, 2205, 4410, 0xad497ca0
	9	0, 74970, 74970, 2205, 4410, 0x1de10c9e
	10	0, 77175, 77175, 2205, 4410, 0x9f55efa8
	11	0, 79380, 79380, 2205, 4410, 0x220a072a
	12	0, 81585, 81585, 2205, 4410, 0xa7dafb29
	13	0, 83790, 83790, 2205, 4410, 0xd5e29c7a
	14	0, 85995, 85995, 2205, 4410, 0xb8465006
	15	0, 88200, 88200, 2205, 4410, 0x518669c7
	16	0, 90405, 90405, 2205, 4410, 0xb5b5efca
	17	0, 92610, 92610, 2205, 4410, 0x8600015d
	18	0, 94815, 94815, 2205, 4410, 0xe2f68fe9
	19	0, 97020, 97020, 2205, 4410, 0x8d3458d9
	20	0, 99225, 99225, 2205, 4410, 0xf1ff4775
	21	0, 101430, 101430, 2205, 4410, 0x830f67c9
	22	0, 103635, 103635, 2205, 4410, 0x110e0bc1
	23	0, 105840, 105840, 2205, 4410, 0x71682f47
	24	0, 108045, 108045, 2205, 4410, 0x38119095
	25	0, 110250, 110250, 2205, 4410, 0xd2494db6
	26	0, 112455, 112455, 2205, 4410, 0x8b552509
	27	0, 114660, 114660, 2205, 4410, 0x71e52909
	28	0, 116865, 116865, 2205, 4410, 0x9f0a6f4d
	29	0, 119070, 119070, 2205, 4410, 0x901302f2
	30	0, 121275, 121275, 2205, 4410, 0x855d5222
	31	0, 123480, 123480, 2205, 4410, 0x324bb2fe
	32	0, 125685, 125685, 2205, 4410, 0xe85f583f
	33	0, 127890, 127890, 2205, 4410, 0x2cbc67c4
	34	0, 130095, 130095, 2205, 4410, 0xc82e6aa1
	35	0, 132300, 132300, 2205, 4410, 0xb9fc423c
	36	0, 134505, 134505, 2205, 4410, 0x6b9b4ef9
	37	0, 136710, 136710, 2205, 4410, 0x39290f10
	38	0, 138915, 138915, 2205, 4410, 0xad718eb4
	39	0, 141120, 141120, 2205, 4410, 0x82f463ac
	40	0, 143325, 143325, 2205, 4410, 0xfac87cac
	41	0, 145530, 145530, 2205, 4410, 0x9e8bcca7
	42	0, 147735, 147735, 2205, 4410, 0x52f79c99
	43	0, 149940, 149940, 2205, 4410, 0xf2d14de2
	44	0, 152145, 152145, 2205, 4410, 0x367f95e1
	45	0, 154350, 154350, 2205, 4410, 0x8bfac293
	46	0, 156555, 156555, 2205, 4410, 0x01ea5040
	47	0, 158760, 158760, 2205, 4410, 0x8ff5e212
	48	0, 160965, 160965, 2205, 4410, 0x93f32824
	49	0, 163170, 163170, 2205, 4410, 0x998f90dc
	50	0, 165375, 165375, 2205, 4410, 0x65231170
	51	0, 167580, 167580, 2205, 4410, 0xc79039a1
	52	0, 169785, 169785, 2205, 4410, 0x0b0e58bd
	53	0, 171990, 171990, 2205, 4410, 0xc24ab4fa
	54	0, 174195, 174195, 2205, 4410, 0xd3796a8e
	55	0, 176400, 176400, 2205, 4410, 0xa37f8295
	56	0, 178605, 178605, 2205, 4410, 0xb760fed7
	57	0, 180810, 180810, 2205, 4410, 0x05495a34
	58	0, 183015, 183015, 2205, 4410, 0x6f203437
	59	0, 185220, 185220, 2205, 4410, 0x71299402
	60	0, 187425, 187425, 2205, 4410, 0x72e7b346
	61	0, 189630, 189630, 2205, 4410, 0x879b0dae
	62	0, 191835, 191835, 2205, 4410, 0x041aa1bd
	63	0, 194040, 194040, 2205, 4410, 0x18a962e6
	64	0, 196245, 196245, 2205, 4410, 0x21d20539
	65	0, 198450, 198450, 2205, 4410, 0x8f449267
	66	0, 200655, 200655, 2205, 4410, 0xecdc01d6
	67	0, 202860, 202860, 2205, 4410, 0x458abd5a
	68	0, 205065, 205065, 2205, 4410, 0xa070ea63
	69	0, 207270, 207270, 2205, 4410, 0xc25b26ce
	70	0, 209475, 209475, 2205, 4410, 0x4d9237ca
	71	0, 211680, 211680, 2205, 4410, 0x748e1801
	72	0, 213885, 213885, 2205, 4410, 0xc96b69e6
	73	0, 216090, 216090, 2205, 4410, 0x6663186c
	74	0, 218295, 218295, 2205, 4410, 0x7f6d3081
	75	0, 220500, 220500, 2205, 4410, 0x1a0343b5
	76	0, 222705, 222705, 2205, 4410, 0xc48e338c
	77	0, 224910, 224910, 2205, 4410, 0x26fc03c8
	78	0, 227115, 227115, 2205, 4410, 0x69be7e2d
	79	0, 229320, 229320, 2205, 4410, 0x69a74da1
	80	0, 231525, 231525, 2205, 4410, 0x85bd2ab3
	81	0, 233730, 233730, 2205, 4410, 0xeff05426
	82	0, 235935, 235935, 2205, 4410, 0x292829e0
	83	0, 238140, 238140, 2205, 4410, 0x8f741798
	84	0, 240345, 240345, 2205, 4410, 0x6b9337e9
	85	0, 242550, 242550, 2205, 4410, 0xe4e1703f
	86	0, 244755, 244755, 2205, 4410, 0x043d6c35
	87	0, 246960, 246960, 2205, 4410, 0x3a8988e7
	88	0, 249165, 249165, 2205, 4410, 0x1fa7d2a9
	89	0, 251370, 251370, 2205, 4410, 0xe28799e3
	90	0, 253575, 253575, 2205, 4410, 0xc2df4470
	91	0, 255780, 255780, 2205, 4410, 0x694d0cf5
	92	0, 257985, 257985, 2205, 4410, 0x5aac2dcf
	93	0, 260190, 260190, 2205, 4410, 0x259fa2db
	94	0, 262395, 262395, 2205, 4410, 0xd16d6803
	95	0, 264600, 264600, 2205, 4410, 0xa4b3478a
	96	0, 266805, 266805, 2205, 4410, 0xdbe0443d
	97	0, 269010, 269010, 2205, 4410, 0x26c16119
	98	0, 271215, 271215, 2205, 4410, 0x0c06475c
	99	0, 273420, 273420, 2205, 4410, 0x6ffaba2d
	100	0, 275625, 275625, 2205, 4410, 0x5b287192
	101	0, 277830, 277830, 2205, 4410, 0xf2cf2651
	102	0, 280035, 280035, 2205, 4410, 0x3857673a
	103	0, 282240, 282240, 2205, 4410, 0x5b555feb
	104	0, 284445, 284445, 2205, 4410, 0x93f997af
	105	0, 286650, 286650, 2205, 4410, 0xb3ba8d35
	106	0, 288855, 288855, 2205, 4410, 0x66433944
	107	0, 291060, 291060, 2205, 4410, 0xf0005a5f
	108	0, 293265, 293265, 2205, 4410, 0xb948541f
	109	0, 295470, 295470, 2205, 4410, 0xc8f1b16f
	110	0, 297675, 297675, 2205, 4410, 0x7d4b7506
	111	0, 299880, 299880, 2205, 4410, 0xac723c55
	112	0, 302085, 302085, 2205, 4410, 0x2926fab5
	113	0, 304290, 304290, 2205, 4410, 0x31684995
	114	0, 306495, 306495, 2205, 4410, 0x35ebfca4
	115	0, 308700, 308700, 2205, 4410, 0x9cd42c18
	116	0, 310905, 310905, 2205, 4410, 0xd7ecd7b1
	117	0, 313110, 313110, 2205, 4410, 0x5e13c602
	118	0, 315315, 315315, 2205, 4410, 0xe955b5e3
	119	0, 317520, 317520, 2205, 4410, 0xefad19a1
	120	0, 319725, 319725, 2205, 4410, 0x435950de
	121	0, 321930, 321930, 2205, 4410, 0x9d624ebe
	122	0, 324135, 324135, 2205, 4410, 0x774a9158
	123	0, 326340, 326340, 2205, 4410, 0x8c41e66a
	124	0, 328545, 328545, 2205, 4410, 0x70112740
	125	0, 330750, 330750, 2205, 4410, 0x55abc7a2
	126	0, 332955, 332955, 2205, 4410, 0x0ec3183c
	127	0, 335160, 335160, 2205, 4410, 0x54609c56
	128	0, 337365, 337365, 2205, 4410, 0x60d49f92
	129	0, 339570, 339570, 2205, 4410, 0x5fb061c8
	130	0, 341775, 341775, 2205, 4410, 0x6e119c98
	131	0, 343980, 343980, 2205, 4410, 0x3f39fc69
	132	0, 346185, 346185, 2205, 4410, 0xef466d0e
	133	0, 348390, 348390, 2205, 4410, 0xf4cb6fe1
	134	0, 350595, 350595, 2205, 4410, 0xc4434439
	135	0, 352800, 352800, 2205, 4410, 0xd02329d2
	136	0, 355005, 355005, 2205, 4410, 0x216cffaf
	137	0, 357210, 357210, 2205, 4410, 0x7e59e8c1
	138	0, 359415, 359415, 2205, 4410, 0xc7c3346d
	139	0, 361620, 361620, 2205, 4410, 0x5b3723af
	140	0, 363825, 363825, 2205, 4410, 0x76097270
	141	0, 366030, 366030, 2205, 4410, 0xae39a233
	142	0, 368235, 368235, 2205, 4410, 0x686a471c
	143	0, 370440, 370440, 2205, 4410, 0x3af3c5e0
	144	0, 372645, 372645, 2205, 4410, 0x11ac711e
	145	0, 374850, 374850, 2205, 4410, 0xcd8da8ce
	146	0, 377055, 377055, 2205, 4410, 0x21296e3a
	147	0, 379260, 379260, 2205, 4410, 0x77168188
	148	0, 381465, 381465, 2205, 4410, 0x5fcf59cd
	149	0, 383670, 383670, 2205, 4410, 0x390c8717
	150	0, 385875, 385875, 2205, 4410, 0x3d5d5b3c
	151	0, 388080, 388080, 2205, 4410, 0x3b8f13d3
	152	0, 390285, 390285, 2205, 4410, 0x5b002c2f
	153	0, 392490, 392490, 2205, 4410, 0x9e1d2b08
	154	0, 394695, 394695, 2205, 4410, 0x69454ebd
	155	0, 396900, 396900, 2205, 4410, 0x62a54bec
	156	0, 399105, 399105, 2205, 4410, 0x4d231fdb
	157	0, 401310, 401310, 2205, 4410, 0x65624ff7
	158	0, 403515, 403515, 2205, 4410, 0x6fc66932
	159	0, 405720, 405720, 2205, 4410, 0x23200cf6
	160	0, 407925, 407925, 2205, 4410, 0xf8033122
	161	0, 410130, 410130, 2205, 4410, 0x0fce0744
	162	0, 412335, 412335, 2205, 4410, 0x9302683e
	163	0, 414540, 414540, 2205, 4410, 0xd2380245
	164	0, 416745, 416745, 2205, 4410, 0x482e0872
	165	0, 418950, 418950, 2205, 4410, 0xe98e6461
	166	0, 421155, 421155, 2205, 4410, 0x1db404e3
	167	0, 423360, 423360, 2205, 4410, 0x47a26d45
	168	0, 425565, 425565, 2205, 4410, 0x449a348a
	169	0, 427770, 427770, 2205, 4410, 0xee874f84
	170	0, 429975, 429975, 2205, 4410, 0xc4ecf965
	171	0, 432180, 432180, 2205, 4410, 0xcc450bc8
	172	0, 434385, 434385, 2205, 4410, 0xb18d044b
	173	0, 436590, 436590, 2205, 4410, 0x895435e8
	174	0, 438795, 438795, 2205, 4410, 0x57e7574e
	175	0, 441000, 441000, 2205, 4410, 0x8041ad3d
	176	0, 443205, 443205, 2205, 4410, 0x853d1616
	177	0, 445410, 445410, 2205, 4410, 0xa11bb32b
	178	0, 447615, 447615, 2205, 4410, 0xe10ea0de
	179	0, 449820, 449820, 2205, 4410, 0xdf2ee328
	180	0, 452025, 452025, 2205, 4410, 0xd5a6dcae
	181	0, 454230, 454230, 2205, 4410, 0xd176c00b
	182	0, 456435, 456435, 2205, 4410, 0x9cd6bcf3
	183	0, 458640, 458640, 2205, 4410, 0x2569690a
	184	0, 460845, 460845, 2205, 4410, 0x6824aa1d
	185	0, 463050, 463050, 2205, 4410, 0xa9110afa
	186	0, 465255, 465255, 2205, 4410, 0x115c25be
	187	0, 467460, 467460, 2205, 4410, 0x1100f085
	188	0, 469665, 469665, 2205, 4410, 0x00000000
	189	0, 471870, 471870, 2205, 4410, 0x00000000
	190	0, 474075, 474075, 2205, 4410, 0x00000000
	191	0, 476280, 476280, 2205, 4410, 0x00000000
	192	0, 478485, 478485, 2205, 4410, 0x00000000
	193	0, 480690, 480690, 2205, 4410, 0x00000000
	194	0, 482895, 482895, 2205, 4410, 0x00000000
	195	0, 485100, 485100, 2205, 4410, 0x00000000
	196	0, 487305, 487305, 2205, 4410, 0x00000000
	197	0, 489510, 489510, 2205, 4410, 0x00000000
	198	0, 491715, 491715, 2205, 4410, 0x00000000
	199	0, 493920, 493920, 2205, 4410, 0x00000000
	200	0, 496125, 496125, 2205, 4410, 0x00000000
	201	0, 498330, 498330, 2205, 4410, 0x00000000
	202	0, 500535, 500535, 2205, 4410, 0x00000000
	203	0, 502740, 502740, 2205, 4410, 0x00000000
	204	0, 504945, 504945, 2205, 4410, 0x00000000
	205	0, 507150, 507150, 2205, 4410, 0x00000000
	206	0, 509355, 509355, 2205, 4410, 0x00000000
	207	0, 511560, 511560, 2205, 4410, 0x00000000
	208	0, 513765, 513765, 2205, 4410, 0x00000000
	209	0, 515970, 515970, 2205, 4410, 0x00000000
	210	0, 518175, 518175, 2205, 4410, 0x00000000
	211	0, 520380, 520380, 2205, 4410, 0x00000000
	212	0, 522585, 522585, 2205, 4410, 0x00000000
	213	0, 524790, 524790, 2205, 4410, 0x00000000
	214	0, 526995, 526995, 2205, 4410, 0x00000000
	215	0, 529200, 529200, 2205, 4410, 0x00000000
	216	0, 531405, 531405, 2205, 4410, 0x00000000

tests/ref/fate/sierra-vmd-video+118−0

@@ -0,0 +1,118 @@
	1	#tb 0: 1/10
	2	0, 0, 0, 1, 230400, 0x0224ab01
	3	0, 1, 1, 1, 230400, 0x449e4d81
	4	0, 2, 2, 1, 230400, 0x3e15e07a
	5	0, 3, 3, 1, 230400, 0xdabe4172
	6	0, 4, 4, 1, 230400, 0x0947b7db
	7	0, 5, 5, 1, 230400, 0x934e243b
	8	0, 6, 6, 1, 230400, 0x6b5c5b6c
	9	0, 7, 7, 1, 230400, 0x4bf7bbb5
	10	0, 8, 8, 1, 230400, 0x423eec8e
	11	0, 9, 9, 1, 230400, 0x63663b5e
	12	0, 10, 10, 1, 230400, 0x9c258a67
	13	0, 11, 11, 1, 230400, 0x1c92b6e0
	14	0, 12, 12, 1, 230400, 0xdd0a0e28
	15	0, 13, 13, 1, 230400, 0x51d64af1
	16	0, 14, 14, 1, 230400, 0x5776ac12
	17	0, 15, 15, 1, 230400, 0x49070132
	18	0, 16, 16, 1, 230400, 0xa59635ab
	19	0, 17, 17, 1, 230400, 0xb1f99504
	20	0, 18, 18, 1, 230400, 0x61fac725
	21	0, 19, 19, 1, 230400, 0xc32c28d5
	22	0, 20, 20, 1, 230400, 0x2b7a91d6
	23	0, 21, 21, 1, 230400, 0x917be717
	24	0, 22, 22, 1, 230400, 0xd3c5a2ff
	25	0, 23, 23, 1, 230400, 0x0678a707
	26	0, 24, 24, 1, 230400, 0x122504e6
	27	0, 25, 25, 1, 230400, 0x76aebdae
	28	0, 26, 26, 1, 230400, 0x81357545
	29	0, 27, 27, 1, 230400, 0x38baeebd
	30	0, 28, 28, 1, 230400, 0x1c5c44d4
	31	0, 29, 29, 1, 230400, 0x60e189cc
	32	0, 30, 30, 1, 230400, 0xb1f4381c
	33	0, 31, 31, 1, 230400, 0xb5048fed
	34	0, 32, 32, 1, 230400, 0xc947c30e
	35	0, 33, 33, 1, 230400, 0xe8e31c07
	36	0, 34, 34, 1, 230400, 0x6d49dd02
	37	0, 35, 35, 1, 230400, 0x293e15d3
	38	0, 36, 36, 1, 230400, 0x354d792e
	39	0, 37, 37, 1, 230400, 0x35468780
	40	0, 38, 38, 1, 230400, 0x365d3991
	41	0, 39, 39, 1, 230400, 0xc9debef2
	42	0, 40, 40, 1, 230400, 0x4c4634c2
	43	0, 41, 41, 1, 230400, 0x347c2dca
	44	0, 42, 42, 1, 230400, 0x1efa0aaa
	45	0, 43, 43, 1, 230400, 0xa79a0b5a
	46	0, 44, 44, 1, 230400, 0xfdb2dcdb
	47	0, 45, 45, 1, 230400, 0x42dbea33
	48	0, 46, 46, 1, 230400, 0x2a207e43
	49	0, 47, 47, 1, 230400, 0x86573783
	50	0, 48, 48, 1, 230400, 0xc3968473
	51	0, 49, 49, 1, 230400, 0x8f62a7b4
	52	0, 50, 50, 1, 230400, 0x5a2e3073
	53	0, 51, 51, 1, 230400, 0xd24f5e2c
	54	0, 52, 52, 1, 230400, 0x1df3c67d
	55	0, 53, 53, 1, 230400, 0xe4fd884d
	56	0, 57, 57, 1, 230400, 0x9a228555
	57	0, 58, 58, 1, 230400, 0x9eba8ed5
	58	0, 59, 59, 1, 230400, 0x3d808a3d
	59	0, 60, 60, 1, 230400, 0xf57e866d
	60	0, 61, 61, 1, 230400, 0x85f594f5
	61	0, 62, 62, 1, 230400, 0xb09f99dd
	62	0, 63, 63, 1, 230400, 0x2b368475
	63	0, 64, 64, 1, 230400, 0xa2417afd
	64	0, 65, 65, 1, 230400, 0x590b709d
	65	0, 66, 66, 1, 230400, 0x5d617705
	66	0, 67, 67, 1, 230400, 0xabf981ad
	67	0, 68, 68, 1, 230400, 0x5a8590cd
	68	0, 69, 69, 1, 230400, 0x1bff853d
	69	0, 70, 70, 1, 230400, 0x71d08055
	70	0, 71, 71, 1, 230400, 0x2ebd817d
	71	0, 72, 72, 1, 230400, 0x6e838255
	72	0, 73, 73, 1, 230400, 0x043984cd
	73	0, 74, 74, 1, 230400, 0x7ff18495
	74	0, 75, 75, 1, 230400, 0xa43b8385
	75	0, 76, 76, 1, 230400, 0x72b5825d
	76	0, 77, 77, 1, 230400, 0x3a178085
	77	0, 78, 78, 1, 230400, 0x67748245
	78	0, 79, 79, 1, 230400, 0xeddf81d5
	79	0, 80, 80, 1, 230400, 0x8b088665
	80	0, 81, 81, 1, 230400, 0x6c408e15
	81	0, 82, 82, 1, 230400, 0x81f196dd
	82	0, 83, 83, 1, 230400, 0xab9f953d
	83	0, 84, 84, 1, 230400, 0xa5f69795
	84	0, 85, 85, 1, 230400, 0xa772950d
	85	0, 86, 86, 1, 230400, 0x6a5596d5
	86	0, 87, 87, 1, 230400, 0x1355958d
	87	0, 88, 88, 1, 230400, 0x4134981d
	88	0, 89, 89, 1, 230400, 0x8b929515
	89	0, 90, 90, 1, 230400, 0x482f95c5
	90	0, 91, 91, 1, 230400, 0x7a9795d5
	91	0, 92, 92, 1, 230400, 0x21c29abd
	92	0, 93, 93, 1, 230400, 0x9ae6a475
	93	0, 94, 94, 1, 230400, 0x3734aee5
	94	0, 95, 95, 1, 230400, 0xa0a1b365
	95	0, 96, 96, 1, 230400, 0x2dcab1c5
	96	0, 97, 97, 1, 230400, 0x9c8b6c44
	97	0, 98, 98, 1, 230400, 0x5da75feb
	98	0, 99, 99, 1, 230400, 0x4d02f8e3
	99	0, 100, 100, 1, 230400, 0x66824f3a
	100	0, 101, 101, 1, 230400, 0x0c9257e2
	101	0, 102, 102, 1, 230400, 0xb2927092
	102	0, 103, 103, 1, 230400, 0xb5dc6e9a
	103	0, 104, 104, 1, 230400, 0x6e567bc6
	104	0, 105, 105, 1, 230400, 0xbf9e0f7a
	105	0, 106, 106, 1, 230400, 0xb16f684a
	106	0, 107, 107, 1, 230400, 0xf9e55e81
	107	0, 108, 108, 1, 230400, 0xd8d0bcba
	108	0, 109, 109, 1, 230400, 0x44720ac0
	109	0, 110, 110, 1, 230400, 0x7d4c2058
	110	0, 113, 113, 1, 230400, 0xb0973eb9
	111	0, 114, 114, 1, 230400, 0x405a13ce
	112	0, 115, 115, 1, 230400, 0x6422f00a
	113	0, 116, 116, 1, 230400, 0x924b6c1e
	114	0, 145, 145, 1, 230400, 0xcf7809c0
	115	0, 146, 146, 1, 230400, 0x883a3863
	116	0, 147, 147, 1, 230400, 0x6adc9e03
	117	0, 148, 148, 1, 230400, 0x4f5ab7a8
	118	0, 214, 214, 1, 230400, 0xdc0aab94

tests/ref/fate/smacker-audio+87−0

@@ -0,0 +1,87 @@
	1	#tb 0: 1/22050
	2	0, 0, 0, 23620, 47240, 0x9974897c
	3	0, 23620, 23620, 1564, 3128, 0x7e4064b4
	4	0, 25184, 25184, 1564, 3128, 0x80883301
	5	0, 26748, 26748, 1568, 3136, 0x2ad2d341
	6	0, 28316, 28316, 1564, 3128, 0xda8468e3
	7	0, 29880, 29880, 1568, 3136, 0x9d6f6cdf
	8	0, 31448, 31448, 1564, 3128, 0x1aaa64b5
	9	0, 33012, 33012, 1564, 3128, 0x9182728b
	10	0, 34576, 34576, 1568, 3136, 0xfa8e17b3
	11	0, 36144, 36144, 1564, 3128, 0x0dc3c1cf
	12	0, 37708, 37708, 1568, 3136, 0x0109639d
	13	0, 39276, 39276, 1564, 3128, 0x6d8a12d9
	14	0, 40840, 40840, 1564, 3128, 0x4b9a9597
	15	0, 42404, 42404, 1568, 3136, 0x9112710e
	16	0, 43972, 43972, 1564, 3128, 0x8cccf522
	17	0, 45536, 45536, 1564, 3128, 0x6594bbf3
	18	0, 47100, 47100, 1568, 3136, 0xd878a7d5
	19	0, 48668, 48668, 1564, 3128, 0xaa6e3905
	20	0, 50232, 50232, 1568, 3136, 0x2a062e04
	21	0, 51800, 51800, 1564, 3128, 0x84e4006a
	22	0, 53364, 53364, 1564, 3128, 0x85183633
	23	0, 54928, 54928, 1568, 3136, 0xb62d4b02
	24	0, 56496, 56496, 1564, 3128, 0xe209462a
	25	0, 58060, 58060, 1568, 3136, 0x57c4824b
	26	0, 59628, 59628, 1564, 3128, 0x664a9163
	27	0, 61192, 61192, 1564, 3128, 0xb4287874
	28	0, 62756, 62756, 1568, 3136, 0xde626885
	29	0, 64324, 64324, 1564, 3128, 0x919763c2
	30	0, 65888, 65888, 1564, 3128, 0xa4f664e1
	31	0, 67452, 67452, 1568, 3136, 0xa0bab0d4
	32	0, 69020, 69020, 1564, 3128, 0xe938939c
	33	0, 70584, 70584, 1568, 3136, 0x3679bfc7
	34	0, 72152, 72152, 1564, 3128, 0xc96c55c3
	35	0, 73716, 73716, 1564, 3128, 0x119114d6
	36	0, 75280, 75280, 1568, 3136, 0x42f3800f
	37	0, 76848, 76848, 1564, 3128, 0x4250c4ad
	38	0, 78412, 78412, 1568, 3136, 0x5cdd4925
	39	0, 79980, 79980, 1564, 3128, 0xa4c12360
	40	0, 81544, 81544, 1564, 3128, 0x849f48de
	41	0, 83108, 83108, 1568, 3136, 0x6acd8ff9
	42	0, 84676, 84676, 1564, 3128, 0xb2758556
	43	0, 86240, 86240, 1564, 3128, 0x10f2fcb1
	44	0, 87804, 87804, 1568, 3136, 0xf0f02b23
	45	0, 89372, 89372, 1564, 3128, 0x64f759c6
	46	0, 90936, 90936, 1568, 3136, 0x7ec075e3
	47	0, 92504, 92504, 1564, 3128, 0xf981d51e
	48	0, 94068, 94068, 1564, 3128, 0xc622e8b9
	49	0, 95632, 95632, 1568, 3136, 0xf632e2f8
	50	0, 97200, 97200, 1564, 3128, 0xda561864
	51	0, 98764, 98764, 1568, 3136, 0x14d2e888
	52	0, 100332, 100332, 1564, 3128, 0x015bb869
	53	0, 101896, 101896, 1564, 3128, 0xedb1fb62
	54	0, 103460, 103460, 1568, 3136, 0xe0560c41
	55	0, 105028, 105028, 1564, 3128, 0x14773c9a
	56	0, 106592, 106592, 1568, 3136, 0x850f1c82
	57	0, 108160, 108160, 1564, 3128, 0xb0bd5347
	58	0, 109724, 109724, 1564, 3128, 0x8f82edbf
	59	0, 111288, 111288, 1568, 3136, 0x493abee2
	60	0, 112856, 112856, 1564, 3128, 0xf5daff3f
	61	0, 114420, 114420, 1564, 3128, 0x78ad2690
	62	0, 115984, 115984, 1568, 3136, 0x490ebafc
	63	0, 117552, 117552, 1564, 3128, 0x70333fd2
	64	0, 119116, 119116, 1568, 3136, 0x8cb1c350
	65	0, 120684, 120684, 1564, 3128, 0x8bd057cb
	66	0, 122248, 122248, 1564, 3128, 0x161b3dbc
	67	0, 123812, 123812, 1568, 3136, 0xb47fb88a
	68	0, 125380, 125380, 1564, 3128, 0x474b381e
	69	0, 126944, 126944, 1568, 3136, 0x07c519bb
	70	0, 128512, 128512, 1564, 3128, 0x15b916c8
	71	0, 130076, 130076, 1564, 3128, 0x0ed7f6fb
	72	0, 131640, 131640, 1568, 3136, 0x54d6397b
	73	0, 133208, 133208, 1564, 3128, 0x437242bb
	74	0, 134772, 134772, 1564, 3128, 0x38f05c4d
	75	0, 136336, 136336, 1568, 3136, 0x5d000e59
	76	0, 137904, 137904, 1564, 3128, 0xdeab2d04
	77	0, 139468, 139468, 1568, 3136, 0x77de6880
	78	0, 141036, 141036, 1564, 3128, 0xbc87ef25
	79	0, 142600, 142600, 1564, 3128, 0xc1638ade
	80	0, 144164, 144164, 1568, 3136, 0xcfb64a5f
	81	0, 145732, 145732, 1564, 3128, 0x90b1b826
	82	0, 147296, 147296, 1568, 3136, 0x00000000
	83	0, 148864, 148864, 1564, 3128, 0x00000000
	84	0, 150428, 150428, 1564, 3128, 0x00000000
	85	0, 151992, 151992, 1568, 3136, 0x00000000
	86	0, 153560, 153560, 1564, 3128, 0x00000000
	87	0, 155124, 155124, 1428, 2856, 0x00000000

tests/ref/fate/smacker-videorenamed from tests/ref/fate/smacker+0−87

@@ -1,7 +1,5 @@
1	#tb 0: 71/1000	1	#tb 0: 71/1000
2	#tb 1: 1/22050
3	0, 0, 0, 1, 192000, 0x8926d7fc	2	0, 0, 0, 1, 192000, 0x8926d7fc
4	1, 0, 0, 23620, 47240, 0x9974897c
5	0, 1, 1, 1, 192000, 0x2506d384	3	0, 1, 1, 1, 192000, 0x2506d384
6	0, 2, 2, 1, 192000, 0x9a8dc93a	4	0, 2, 2, 1, 192000, 0x9a8dc93a
7	0, 3, 3, 1, 192000, 0x4badb7f2	5	0, 3, 3, 1, 192000, 0x4badb7f2
@@ -17,172 +15,87 @@ · 9 unmodified lines
17	0, 13, 13, 1, 192000, 0x1a3d7971	15	0, 13, 13, 1, 192000, 0x1a3d7971
18	0, 14, 14, 1, 192000, 0xa1a65bd5	16	0, 14, 14, 1, 192000, 0xa1a65bd5
19	0, 15, 15, 1, 192000, 0x344957b9	17	0, 15, 15, 1, 192000, 0x344957b9
20	1, 23620, 23620, 1564, 3128, 0x7e4064b4
21	0, 16, 16, 1, 192000, 0xe23b5f4e	18	0, 16, 16, 1, 192000, 0xe23b5f4e
22	1, 25184, 25184, 1564, 3128, 0x80883301
23	0, 17, 17, 1, 192000, 0xb5c2710b	19	0, 17, 17, 1, 192000, 0xb5c2710b
24	1, 26748, 26748, 1568, 3136, 0x2ad2d341
25	0, 18, 18, 1, 192000, 0x7a25938f	20	0, 18, 18, 1, 192000, 0x7a25938f
26	1, 28316, 28316, 1564, 3128, 0xda8468e3
27	0, 19, 19, 1, 192000, 0x0a84e4c9	21	0, 19, 19, 1, 192000, 0x0a84e4c9
28	1, 29880, 29880, 1568, 3136, 0x9d6f6cdf
29	0, 20, 20, 1, 192000, 0x94209b0d	22	0, 20, 20, 1, 192000, 0x94209b0d
30	1, 31448, 31448, 1564, 3128, 0x1aaa64b5
31	0, 21, 21, 1, 192000, 0xf940e51f	23	0, 21, 21, 1, 192000, 0xf940e51f
32	1, 33012, 33012, 1564, 3128, 0x9182728b
33	0, 22, 22, 1, 192000, 0xb9fdec42	24	0, 22, 22, 1, 192000, 0xb9fdec42
34	1, 34576, 34576, 1568, 3136, 0xfa8e17b3
35	0, 23, 23, 1, 192000, 0x7b04a376	25	0, 23, 23, 1, 192000, 0x7b04a376
36	1, 36144, 36144, 1564, 3128, 0x0dc3c1cf
37	0, 24, 24, 1, 192000, 0x5fe0026b	26	0, 24, 24, 1, 192000, 0x5fe0026b
38	1, 37708, 37708, 1568, 3136, 0x0109639d
39	0, 25, 25, 1, 192000, 0x775aca39	27	0, 25, 25, 1, 192000, 0x775aca39
40	1, 39276, 39276, 1564, 3128, 0x6d8a12d9
41	0, 26, 26, 1, 192000, 0xae14fb32	28	0, 26, 26, 1, 192000, 0xae14fb32
42	1, 40840, 40840, 1564, 3128, 0x4b9a9597
43	0, 27, 27, 1, 192000, 0x661106e5	29	0, 27, 27, 1, 192000, 0x661106e5
44	1, 42404, 42404, 1568, 3136, 0x9112710e
45	0, 28, 28, 1, 192000, 0xe8658dbf	30	0, 28, 28, 1, 192000, 0xe8658dbf
46	1, 43972, 43972, 1564, 3128, 0x8cccf522
47	0, 29, 29, 1, 192000, 0x5359f0f9	31	0, 29, 29, 1, 192000, 0x5359f0f9
48	1, 45536, 45536, 1564, 3128, 0x6594bbf3
49	0, 30, 30, 1, 192000, 0xc1ec80f4	32	0, 30, 30, 1, 192000, 0xc1ec80f4
50	1, 47100, 47100, 1568, 3136, 0xd878a7d5
51	0, 31, 31, 1, 192000, 0xca53806b	33	0, 31, 31, 1, 192000, 0xca53806b
52	1, 48668, 48668, 1564, 3128, 0xaa6e3905
53	0, 32, 32, 1, 192000, 0xf0766b2e	34	0, 32, 32, 1, 192000, 0xf0766b2e
54	1, 50232, 50232, 1568, 3136, 0x2a062e04
55	0, 33, 33, 1, 192000, 0x39962da8	35	0, 33, 33, 1, 192000, 0x39962da8
56	1, 51800, 51800, 1564, 3128, 0x84e4006a
57	0, 34, 34, 1, 192000, 0x4171c37f	36	0, 34, 34, 1, 192000, 0x4171c37f
58	1, 53364, 53364, 1564, 3128, 0x85183633
59	0, 35, 35, 1, 192000, 0x3abf3b46	37	0, 35, 35, 1, 192000, 0x3abf3b46
60	1, 54928, 54928, 1568, 3136, 0xb62d4b02
61	0, 36, 36, 1, 192000, 0xecc68313	38	0, 36, 36, 1, 192000, 0xecc68313
62	1, 56496, 56496, 1564, 3128, 0xe209462a
63	0, 37, 37, 1, 192000, 0xea339baf	39	0, 37, 37, 1, 192000, 0xea339baf
64	1, 58060, 58060, 1568, 3136, 0x57c4824b
65	0, 38, 38, 1, 192000, 0x616b8f16	40	0, 38, 38, 1, 192000, 0x616b8f16
66	1, 59628, 59628, 1564, 3128, 0x664a9163
67	0, 39, 39, 1, 192000, 0xf77a8581	41	0, 39, 39, 1, 192000, 0xf77a8581
68	1, 61192, 61192, 1564, 3128, 0xb4287874
69	0, 40, 40, 1, 192000, 0xb315678b	42	0, 40, 40, 1, 192000, 0xb315678b
70	1, 62756, 62756, 1568, 3136, 0xde626885
71	0, 41, 41, 1, 192000, 0x0a4a5218	43	0, 41, 41, 1, 192000, 0x0a4a5218
72	1, 64324, 64324, 1564, 3128, 0x919763c2
73	0, 42, 42, 1, 192000, 0x98802be4	44	0, 42, 42, 1, 192000, 0x98802be4
74	1, 65888, 65888, 1564, 3128, 0xa4f664e1
75	0, 43, 43, 1, 192000, 0xa2f0fd94	45	0, 43, 43, 1, 192000, 0xa2f0fd94
76	1, 67452, 67452, 1568, 3136, 0xa0bab0d4
77	0, 44, 44, 1, 192000, 0x6671c84f	46	0, 44, 44, 1, 192000, 0x6671c84f
78	1, 69020, 69020, 1564, 3128, 0xe938939c
79	0, 45, 45, 1, 192000, 0x38327e31	47	0, 45, 45, 1, 192000, 0x38327e31
80	1, 70584, 70584, 1568, 3136, 0x3679bfc7
81	0, 46, 46, 1, 192000, 0xb85d3e08	48	0, 46, 46, 1, 192000, 0xb85d3e08
82	1, 72152, 72152, 1564, 3128, 0xc96c55c3
83	0, 47, 47, 1, 192000, 0xdc69eba9	49	0, 47, 47, 1, 192000, 0xdc69eba9
84	1, 73716, 73716, 1564, 3128, 0x119114d6
85	0, 48, 48, 1, 192000, 0x8955a0b3	50	0, 48, 48, 1, 192000, 0x8955a0b3
86	1, 75280, 75280, 1568, 3136, 0x42f3800f
87	0, 49, 49, 1, 192000, 0x714a548b	51	0, 49, 49, 1, 192000, 0x714a548b
88	1, 76848, 76848, 1564, 3128, 0x4250c4ad
89	0, 50, 50, 1, 192000, 0xc0471de9	52	0, 50, 50, 1, 192000, 0xc0471de9
90	1, 78412, 78412, 1568, 3136, 0x5cdd4925
91	0, 51, 51, 1, 192000, 0x2e16e039	53	0, 51, 51, 1, 192000, 0x2e16e039
92	1, 79980, 79980, 1564, 3128, 0xa4c12360
93	0, 52, 52, 1, 192000, 0x9fa4b033	54	0, 52, 52, 1, 192000, 0x9fa4b033
94	1, 81544, 81544, 1564, 3128, 0x849f48de
95	0, 53, 53, 1, 192000, 0x4a0f9402	55	0, 53, 53, 1, 192000, 0x4a0f9402
96	1, 83108, 83108, 1568, 3136, 0x6acd8ff9
97	0, 54, 54, 1, 192000, 0x1f3e6843	56	0, 54, 54, 1, 192000, 0x1f3e6843
98	1, 84676, 84676, 1564, 3128, 0xb2758556
99	0, 55, 55, 1, 192000, 0x31774850	57	0, 55, 55, 1, 192000, 0x31774850
100	1, 86240, 86240, 1564, 3128, 0x10f2fcb1
101	0, 56, 56, 1, 192000, 0x9d5336a2	58	0, 56, 56, 1, 192000, 0x9d5336a2
102	1, 87804, 87804, 1568, 3136, 0xf0f02b23
103	0, 57, 57, 1, 192000, 0xf7de27a2	59	0, 57, 57, 1, 192000, 0xf7de27a2
104	1, 89372, 89372, 1564, 3128, 0x64f759c6
105	0, 58, 58, 1, 192000, 0x98c717ce	60	0, 58, 58, 1, 192000, 0x98c717ce
106	1, 90936, 90936, 1568, 3136, 0x7ec075e3
107	0, 59, 59, 1, 192000, 0x615b10b8	61	0, 59, 59, 1, 192000, 0x615b10b8
108	1, 92504, 92504, 1564, 3128, 0xf981d51e
109	0, 60, 60, 1, 192000, 0xd5bc0e7e	62	0, 60, 60, 1, 192000, 0xd5bc0e7e
110	1, 94068, 94068, 1564, 3128, 0xc622e8b9
111	0, 61, 61, 1, 192000, 0xd5bc0e7e	63	0, 61, 61, 1, 192000, 0xd5bc0e7e
112	1, 95632, 95632, 1568, 3136, 0xf632e2f8
113	0, 62, 62, 1, 192000, 0xd5bc0e7e	64	0, 62, 62, 1, 192000, 0xd5bc0e7e
114	1, 97200, 97200, 1564, 3128, 0xda561864
115	0, 63, 63, 1, 192000, 0xd5bc0e7e	65	0, 63, 63, 1, 192000, 0xd5bc0e7e
116	1, 98764, 98764, 1568, 3136, 0x14d2e888
117	0, 64, 64, 1, 192000, 0xd5bc0e7e	66	0, 64, 64, 1, 192000, 0xd5bc0e7e
118	1, 100332, 100332, 1564, 3128, 0x015bb869
119	0, 65, 65, 1, 192000, 0xd5bc0e7e	67	0, 65, 65, 1, 192000, 0xd5bc0e7e
120	1, 101896, 101896, 1564, 3128, 0xedb1fb62
121	0, 66, 66, 1, 192000, 0xd5bc0e7e	68	0, 66, 66, 1, 192000, 0xd5bc0e7e
122	1, 103460, 103460, 1568, 3136, 0xe0560c41
123	0, 67, 67, 1, 192000, 0xd5bc0e7e	69	0, 67, 67, 1, 192000, 0xd5bc0e7e
124	1, 105028, 105028, 1564, 3128, 0x14773c9a
125	0, 68, 68, 1, 192000, 0xd5bc0e7e	70	0, 68, 68, 1, 192000, 0xd5bc0e7e
126	1, 106592, 106592, 1568, 3136, 0x850f1c82
127	0, 69, 69, 1, 192000, 0xd5bc0e7e	71	0, 69, 69, 1, 192000, 0xd5bc0e7e
128	1, 108160, 108160, 1564, 3128, 0xb0bd5347
129	0, 70, 70, 1, 192000, 0xd5bc0e7e	72	0, 70, 70, 1, 192000, 0xd5bc0e7e
130	1, 109724, 109724, 1564, 3128, 0x8f82edbf
131	0, 71, 71, 1, 192000, 0xd5bc0e7e	73	0, 71, 71, 1, 192000, 0xd5bc0e7e
132	1, 111288, 111288, 1568, 3136, 0x493abee2
133	0, 72, 72, 1, 192000, 0xd5bc0e7e	74	0, 72, 72, 1, 192000, 0xd5bc0e7e
134	1, 112856, 112856, 1564, 3128, 0xf5daff3f
135	0, 73, 73, 1, 192000, 0xd5bc0e7e	75	0, 73, 73, 1, 192000, 0xd5bc0e7e
136	1, 114420, 114420, 1564, 3128, 0x78ad2690
137	0, 74, 74, 1, 192000, 0xd5bc0e7e	76	0, 74, 74, 1, 192000, 0xd5bc0e7e
138	1, 115984, 115984, 1568, 3136, 0x490ebafc
139	0, 75, 75, 1, 192000, 0xd5bc0e7e	77	0, 75, 75, 1, 192000, 0xd5bc0e7e
140	1, 117552, 117552, 1564, 3128, 0x70333fd2
141	0, 76, 76, 1, 192000, 0xd5bc0e7e	78	0, 76, 76, 1, 192000, 0xd5bc0e7e
142	1, 119116, 119116, 1568, 3136, 0x8cb1c350
143	0, 77, 77, 1, 192000, 0xd5bc0e7e	79	0, 77, 77, 1, 192000, 0xd5bc0e7e
144	1, 120684, 120684, 1564, 3128, 0x8bd057cb
145	0, 78, 78, 1, 192000, 0xd5bc0e7e	80	0, 78, 78, 1, 192000, 0xd5bc0e7e
146	1, 122248, 122248, 1564, 3128, 0x161b3dbc
147	0, 79, 79, 1, 192000, 0xd5bc0e7e	81	0, 79, 79, 1, 192000, 0xd5bc0e7e
148	1, 123812, 123812, 1568, 3136, 0xb47fb88a
149	0, 80, 80, 1, 192000, 0xd5bc0e7e	82	0, 80, 80, 1, 192000, 0xd5bc0e7e
150	1, 125380, 125380, 1564, 3128, 0x474b381e
151	0, 81, 81, 1, 192000, 0xd5bc0e7e	83	0, 81, 81, 1, 192000, 0xd5bc0e7e
152	1, 126944, 126944, 1568, 3136, 0x07c519bb
153	0, 82, 82, 1, 192000, 0xd5bc0e7e	84	0, 82, 82, 1, 192000, 0xd5bc0e7e
154	1, 128512, 128512, 1564, 3128, 0x15b916c8
155	0, 83, 83, 1, 192000, 0xd5bc0e7e	85	0, 83, 83, 1, 192000, 0xd5bc0e7e
156	1, 130076, 130076, 1564, 3128, 0x0ed7f6fb
157	0, 84, 84, 1, 192000, 0xd5bc0e7e	86	0, 84, 84, 1, 192000, 0xd5bc0e7e
158	1, 131640, 131640, 1568, 3136, 0x54d6397b
159	0, 85, 85, 1, 192000, 0xd5bc0e7e	87	0, 85, 85, 1, 192000, 0xd5bc0e7e
160	1, 133208, 133208, 1564, 3128, 0x437242bb
161	0, 86, 86, 1, 192000, 0xd5bc0e7e	88	0, 86, 86, 1, 192000, 0xd5bc0e7e
162	1, 134772, 134772, 1564, 3128, 0x38f05c4d
163	0, 87, 87, 1, 192000, 0xd5bc0e7e	89	0, 87, 87, 1, 192000, 0xd5bc0e7e
164	1, 136336, 136336, 1568, 3136, 0x5d000e59
165	0, 88, 88, 1, 192000, 0xd5bc0e7e	90	0, 88, 88, 1, 192000, 0xd5bc0e7e
166	1, 137904, 137904, 1564, 3128, 0xdeab2d04
167	0, 89, 89, 1, 192000, 0xd5bc0e7e	91	0, 89, 89, 1, 192000, 0xd5bc0e7e
168	1, 139468, 139468, 1568, 3136, 0x77de6880
169	0, 90, 90, 1, 192000, 0xd5bc0e7e	92	0, 90, 90, 1, 192000, 0xd5bc0e7e
170	1, 141036, 141036, 1564, 3128, 0xbc87ef25
171	0, 91, 91, 1, 192000, 0xd5bc0e7e	93	0, 91, 91, 1, 192000, 0xd5bc0e7e
172	1, 142600, 142600, 1564, 3128, 0xc1638ade
173	0, 92, 92, 1, 192000, 0xd5bc0e7e	94	0, 92, 92, 1, 192000, 0xd5bc0e7e
174	1, 144164, 144164, 1568, 3136, 0xcfb64a5f
175	0, 93, 93, 1, 192000, 0xd5bc0e7e	95	0, 93, 93, 1, 192000, 0xd5bc0e7e
176	1, 145732, 145732, 1564, 3128, 0x90b1b826
177	0, 94, 94, 1, 192000, 0xd5bc0e7e	96	0, 94, 94, 1, 192000, 0xd5bc0e7e
178	1, 147296, 147296, 1568, 3136, 0x00000000
179	0, 95, 95, 1, 192000, 0xd5bc0e7e	97	0, 95, 95, 1, 192000, 0xd5bc0e7e
180	1, 148864, 148864, 1564, 3128, 0x00000000
181	0, 96, 96, 1, 192000, 0xd5bc0e7e	98	0, 96, 96, 1, 192000, 0xd5bc0e7e
182	1, 150428, 150428, 1564, 3128, 0x00000000
183	0, 97, 97, 1, 192000, 0xd5bc0e7e	99	0, 97, 97, 1, 192000, 0xd5bc0e7e
184	1, 151992, 151992, 1568, 3136, 0x00000000
185	0, 98, 98, 1, 192000, 0xd5bc0e7e	100	0, 98, 98, 1, 192000, 0xd5bc0e7e
186	1, 153560, 153560, 1564, 3128, 0x00000000
187	0, 99, 99, 1, 192000, 0xd5bc0e7e	101	0, 99, 99, 1, 192000, 0xd5bc0e7e
188	1, 155124, 155124, 1428, 2856, 0x00000000

tests/ref/fate/smjpeg+0−425

@@ -1,425 +0,0 @@
1	#tb 0: 1/1000
2	#tb 1: 1/22050
3	0, 0, 0, 0, 734, 0x5a042c2c
4	1, 0, 0, 512, 1024, 0x00000000
5	1, 507, 507, 512, 1024, 0x00000000
6	1, 1014, 1014, 512, 1024, 0xd89a448e
7	1, 1521, 1521, 512, 1024, 0x695b369c
8	1, 2029, 2029, 512, 1024, 0xc8ba5707
9	0, 111, 111, 0, 763, 0xb5893f2f
10	1, 2558, 2558, 512, 1024, 0xdf241fc6
11	1, 3065, 3065, 512, 1024, 0x61cf4166
12	1, 3572, 3572, 512, 1024, 0x97cbc386
13	1, 4079, 4079, 512, 1024, 0x44899d04
14	1, 4586, 4586, 512, 1024, 0xa7cbaa62
15	0, 222, 222, 0, 3023, 0x0f3907d3
16	1, 5116, 5116, 512, 1024, 0xa7aea60c
17	1, 5623, 5623, 512, 1024, 0xd7b18a89
18	1, 6130, 6130, 512, 1024, 0x268e81f6
19	1, 6637, 6637, 512, 1024, 0x9cf83a2f
20	1, 7166, 7166, 512, 1024, 0x5559b508
21	0, 333, 333, 0, 4800, 0x22e6e18a
22	1, 7673, 7673, 512, 1024, 0xe1b9e71c
23	1, 8181, 8181, 512, 1024, 0xdcee733e
24	1, 8688, 8688, 512, 1024, 0xe5918f60
25	1, 9195, 9195, 512, 1024, 0x29dbd209
26	1, 9724, 9724, 512, 1024, 0x9bcbcf16
27	0, 444, 444, 0, 6417, 0x427adde5
28	1, 10231, 10231, 512, 1024, 0x86f5f458
29	1, 10738, 10738, 512, 1024, 0xabcbda86
30	1, 11246, 11246, 512, 1024, 0xc51f77b9
31	1, 11775, 11775, 512, 1024, 0xf6b3a504
32	0, 555, 555, 0, 6776, 0x7a74c6ad
33	1, 12282, 12282, 512, 1024, 0x1af3e40e
34	1, 12789, 12789, 512, 1024, 0x3866b03b
35	1, 13296, 13296, 512, 1024, 0xbc005403
36	1, 13803, 13803, 512, 1024, 0xe9dfcc51
37	1, 14332, 14332, 512, 1024, 0x83c837cb
38	0, 666, 666, 0, 6808, 0x1f6eb7c3
39	1, 14840, 14840, 512, 1024, 0xfa649580
40	1, 15347, 15347, 512, 1024, 0x519452ea
41	1, 15854, 15854, 512, 1024, 0xd4978774
42	1, 16383, 16383, 512, 1024, 0xe2a3b1cd
43	1, 16890, 16890, 512, 1024, 0x9a9472ad
44	0, 777, 777, 0, 6726, 0x452087e6
45	1, 17397, 17397, 512, 1024, 0xa12d4060
46	1, 17905, 17905, 512, 1024, 0x31fb0646
47	1, 18412, 18412, 512, 1024, 0xfc44343f
48	1, 18941, 18941, 512, 1024, 0x0847751a
49	1, 19448, 19448, 512, 1024, 0x227968a2
50	0, 888, 888, 0, 6829, 0xee82b109
51	1, 19955, 19955, 512, 1024, 0x7cce9f1c
52	1, 20462, 20462, 512, 1024, 0xb8356713
53	1, 20992, 20992, 512, 1024, 0xb29f6e6f
54	1, 21499, 21499, 512, 1024, 0x9e1430ab
55	1, 22006, 22006, 512, 1024, 0x26d85423
56	0, 999, 999, 0, 7055, 0xf41f1108
57	1, 22513, 22513, 512, 1024, 0x6496547d
58	1, 23020, 23020, 512, 1024, 0x316b1a86
59	1, 23549, 23549, 512, 1024, 0x3cd83afc
60	1, 24057, 24057, 512, 1024, 0x993ff633
61	0, 1111, 1111, 0, 6977, 0xf8fe1ede
62	1, 24564, 24564, 512, 1024, 0x0708d1a2
63	1, 25071, 25071, 512, 1024, 0xd7230db9
64	1, 25578, 25578, 512, 1024, 0xbb0779ca
65	1, 26107, 26107, 512, 1024, 0xc6094e1b
66	1, 26614, 26614, 512, 1024, 0x15a8b039
67	0, 1222, 1222, 0, 6942, 0x9ad105c6
68	1, 27122, 27122, 512, 1024, 0xd6dbe88c
69	1, 27629, 27629, 512, 1024, 0x7e8d1140
70	1, 28158, 28158, 512, 1024, 0xef88e525
71	1, 28665, 28665, 512, 1024, 0x44e21149
72	1, 29172, 29172, 512, 1024, 0x65b0f5f4
73	0, 1333, 1333, 0, 6926, 0xe239dad6
74	1, 29679, 29679, 512, 1024, 0xb955f687
75	1, 30186, 30186, 512, 1024, 0xc85fba9c
76	1, 30716, 30716, 512, 1024, 0xf59655ad
77	1, 31223, 31223, 512, 1024, 0x6de80bf1
78	1, 31730, 31730, 512, 1024, 0x2dcf6e41
79	0, 1444, 1444, 0, 6966, 0x81dcfab1
80	1, 32237, 32237, 512, 1024, 0xd0ddcf8a
81	1, 32766, 32766, 512, 1024, 0x00135c2d
82	1, 33273, 33273, 512, 1024, 0x697f8efd
83	1, 33781, 33781, 512, 1024, 0x7a9bada5
84	0, 1555, 1555, 0, 6896, 0x31e6cc02
85	1, 34288, 34288, 512, 1024, 0x0d22783c
86	1, 34795, 34795, 512, 1024, 0x7726d07d
87	1, 35324, 35324, 512, 1024, 0xa2f14f67
88	1, 35831, 35831, 512, 1024, 0x7f51060d
89	1, 36338, 36338, 512, 1024, 0xc4ec6aea
90	0, 1666, 1666, 0, 6889, 0x1cc1006e
91	1, 36846, 36846, 512, 1024, 0x9bb37ca4
92	1, 37375, 37375, 512, 1024, 0x9b085577
93	1, 37882, 37882, 512, 1024, 0x8812f8af
94	1, 38389, 38389, 512, 1024, 0x788f5221
95	1, 38896, 38896, 512, 1024, 0x3a2ce642
96	0, 1777, 1777, 0, 6933, 0xc303f87f
97	1, 39403, 39403, 512, 1024, 0x72415692
98	1, 39933, 39933, 512, 1024, 0xe3dcc105
99	1, 40440, 40440, 512, 1024, 0xb26c0599
100	1, 40947, 40947, 512, 1024, 0x5c9e55eb
101	1, 41454, 41454, 512, 1024, 0x8fe88707
102	0, 1888, 1888, 0, 7034, 0xb4970a20
103	1, 41983, 41983, 512, 1024, 0xc5d7beb6
104	1, 42490, 42490, 512, 1024, 0xe1d3a3b4
105	1, 42998, 42998, 512, 1024, 0x012da0c6
106	1, 43505, 43505, 512, 1024, 0x8d010922
107	1, 44012, 44012, 512, 1024, 0x3366eb0d
108	0, 1999, 1999, 0, 6961, 0xf064095d
109	1, 44541, 44541, 512, 1024, 0xc9381a27
110	1, 45048, 45048, 512, 1024, 0x0774f685
111	1, 45555, 45555, 512, 1024, 0xc5cae0a5
112	1, 46062, 46062, 512, 1024, 0xa6f4737c
113	0, 2111, 2111, 0, 7089, 0x5ba350f9
114	1, 46592, 46592, 512, 1024, 0x8fb6d0d1
115	1, 47099, 47099, 512, 1024, 0x05f579c2
116	1, 47606, 47606, 512, 1024, 0x56905d99
117	1, 48113, 48113, 512, 1024, 0x002ee18d
118	1, 48620, 48620, 512, 1024, 0xeb37ef51
119	0, 2222, 2222, 0, 7078, 0xa83f3e88
120	1, 49149, 49149, 512, 1024, 0x38025635
121	1, 49657, 49657, 512, 1024, 0x4fe643c8
122	1, 50164, 50164, 512, 1024, 0x11d66ab1
123	1, 50671, 50671, 512, 1024, 0xcc3051e9
124	1, 51178, 51178, 512, 1024, 0xcd93e854
125	0, 2333, 2333, 0, 7147, 0xcda66cfc
126	1, 51707, 51707, 512, 1024, 0x38f1196d
127	1, 52214, 52214, 512, 1024, 0x657a15fc
128	1, 52722, 52722, 512, 1024, 0x669ce2a9
129	1, 53229, 53229, 512, 1024, 0x95862dda
130	1, 53758, 53758, 512, 1024, 0x1726a7b2
131	0, 2444, 2444, 0, 7173, 0xb7455859
132	1, 54265, 54265, 512, 1024, 0xd6ece2a1
133	1, 54772, 54772, 512, 1024, 0x33ab9553
134	1, 55279, 55279, 512, 1024, 0xd50c73a6
135	1, 55786, 55786, 512, 1024, 0xfe25b63a
136	1, 56316, 56316, 512, 1024, 0x7e2959e3
137	0, 2555, 2555, 0, 7213, 0x97b89994
138	1, 56823, 56823, 512, 1024, 0xa4c07b34
139	1, 57330, 57330, 512, 1024, 0xd6d8f15c
140	1, 57837, 57837, 512, 1024, 0x1eccddd7
141	1, 58366, 58366, 512, 1024, 0x2b69f9cb
142	0, 2666, 2666, 0, 7170, 0xca8b2948
143	1, 58874, 58874, 512, 1024, 0x667b775f
144	1, 59381, 59381, 512, 1024, 0xad3b84e9
145	1, 59888, 59888, 512, 1024, 0x4f29fc67
146	1, 60395, 60395, 512, 1024, 0x8d611ab7
147	1, 60924, 60924, 512, 1024, 0x278966ea
148	0, 2777, 2777, 0, 7174, 0xc7cc6bbb
149	1, 61431, 61431, 512, 1024, 0xaf33812b
150	1, 61938, 61938, 512, 1024, 0xa55f4265
151	1, 62446, 62446, 512, 1024, 0x023cb51c
152	1, 62975, 62975, 512, 1024, 0x1d1f1005
153	1, 63482, 63482, 512, 1024, 0x874cccf7
154	0, 2888, 2888, 0, 7235, 0xc2e68d2b
155	1, 63989, 63989, 512, 1024, 0xda705428
156	1, 64496, 64496, 512, 1024, 0x48d9b440
157	1, 65003, 65003, 512, 1024, 0xa14e0712
158	1, 65533, 65533, 512, 1024, 0x7efbad1f
159	1, 66040, 66040, 512, 1024, 0xdb82c17f
160	0, 3000, 3000, 0, 7261, 0x8204a423
161	1, 66547, 66547, 512, 1024, 0xcbe87613
162	1, 67054, 67054, 512, 1024, 0x3a63df1d
163	1, 67583, 67583, 512, 1024, 0xd5636bba
164	1, 68090, 68090, 512, 1024, 0x9397af23
165	0, 3111, 3111, 0, 7353, 0xacc7e7c0
166	1, 68598, 68598, 512, 1024, 0x32a07c98
167	1, 69105, 69105, 512, 1024, 0x202ca667
168	1, 69612, 69612, 512, 1024, 0xdf969011
169	1, 70141, 70141, 512, 1024, 0xc434d238
170	1, 70648, 70648, 512, 1024, 0xe9ad7562
171	0, 3222, 3222, 0, 7065, 0x45035c5c
172	1, 71155, 71155, 512, 1024, 0xb51b6b50
173	1, 71662, 71662, 512, 1024, 0xe70aecd3
174	1, 72192, 72192, 512, 1024, 0x03c816b2
175	1, 72699, 72699, 512, 1024, 0x869fdf25
176	1, 73206, 73206, 512, 1024, 0xd40a0a62
177	0, 3333, 3333, 0, 7269, 0x72edbb76
178	1, 73713, 73713, 512, 1024, 0x5af7dd35
179	1, 74220, 74220, 512, 1024, 0x891ffc72
180	1, 74750, 74750, 512, 1024, 0x1ff68a08
181	1, 75257, 75257, 512, 1024, 0x5a7517a9
182	1, 75764, 75764, 512, 1024, 0x0f959f74
183	0, 3444, 3444, 0, 7220, 0xb926772f
184	1, 76271, 76271, 512, 1024, 0xe92a12a2
185	1, 76778, 76778, 512, 1024, 0x38000e55
186	1, 77307, 77307, 512, 1024, 0x39fbdd70
187	1, 77814, 77814, 512, 1024, 0xca3d9184
188	1, 78322, 78322, 512, 1024, 0x66c8995b
189	0, 3555, 3555, 0, 7326, 0x0a66c632
190	1, 78829, 78829, 512, 1024, 0xac25acea
191	1, 79358, 79358, 512, 1024, 0x3cd1046c
192	1, 79865, 79865, 512, 1024, 0x6a1df31c
193	1, 80372, 80372, 512, 1024, 0x21ca10a1
194	0, 3666, 3666, 0, 7225, 0xe39076ab
195	1, 80879, 80879, 512, 1024, 0x1aeccedc
196	1, 81387, 81387, 512, 1024, 0xddea1335
197	1, 81916, 81916, 512, 1024, 0x19f5ca9f
198	1, 82423, 82423, 512, 1024, 0x88e95e43
199	1, 82930, 82930, 512, 1024, 0x726284fe
200	0, 3777, 3777, 0, 7265, 0xe0209036
201	1, 83437, 83437, 512, 1024, 0x6b85b40e
202	1, 83966, 83966, 512, 1024, 0x111fee2a
203	1, 84474, 84474, 512, 1024, 0x3656b588
204	1, 84981, 84981, 512, 1024, 0xa5a2b552
205	1, 85488, 85488, 512, 1024, 0x38fb2467
206	0, 3888, 3888, 0, 7337, 0x7a5dc093
207	1, 85995, 85995, 512, 1024, 0xaa919ccc
208	1, 86524, 86524, 512, 1024, 0x15993dbc
209	1, 87031, 87031, 512, 1024, 0xbe01a7b9
210	1, 87538, 87538, 512, 1024, 0xefe93c09
211	1, 88046, 88046, 512, 1024, 0x1bb566e5
212	0, 4000, 4000, 0, 7246, 0x519a7a3c
213	1, 88575, 88575, 512, 1024, 0x15ce6237
214	1, 89082, 89082, 512, 1024, 0xa8552e66
215	1, 89589, 89589, 512, 1024, 0x9d80187e
216	1, 90096, 90096, 512, 1024, 0x5df3fc30
217	1, 90603, 90603, 512, 1024, 0x1a312aa5
218	0, 4111, 4111, 0, 7266, 0x352c8078
219	1, 91133, 91133, 512, 1024, 0x6bb8e302
220	1, 91640, 91640, 512, 1024, 0xbd9684bb
221	1, 92147, 92147, 512, 1024, 0x78b0b166
222	1, 92654, 92654, 512, 1024, 0xd9af5eae
223	0, 4222, 4222, 0, 7323, 0xcaf69d7c
224	1, 93183, 93183, 512, 1024, 0xdb90fe82
225	1, 93690, 93690, 512, 1024, 0x327614e9
226	1, 94198, 94198, 512, 1024, 0x1f19b7fe
227	1, 94705, 94705, 512, 1024, 0x46c53f96
228	1, 95212, 95212, 512, 1024, 0x921b2189
229	0, 4333, 4333, 0, 7309, 0x98c1e6f7
230	1, 95741, 95741, 512, 1024, 0xa8fbc85a
231	1, 96248, 96248, 512, 1024, 0xabfdaaae
232	1, 96755, 96755, 512, 1024, 0x6acc7387
233	1, 97263, 97263, 512, 1024, 0x0d9c27b5
234	1, 97792, 97792, 512, 1024, 0xba4dd809
235	0, 4444, 4444, 0, 7121, 0x913d5bd6
236	1, 98299, 98299, 512, 1024, 0x2a2ad521
237	1, 98806, 98806, 512, 1024, 0x892de38a
238	1, 99313, 99313, 512, 1024, 0xdc97a2eb
239	1, 99820, 99820, 512, 1024, 0x4f614ca4
240	1, 100350, 100350, 512, 1024, 0x9c8a77ea
241	0, 4555, 4555, 111, 7088, 0x56302362
242	1, 100857, 100857, 512, 1024, 0x2d30e646
243	1, 101364, 101364, 512, 1024, 0x74e800a7
244	1, 101871, 101871, 512, 1024, 0x1e01fb02
245	1, 102378, 102378, 512, 1024, 0x4ed2c1d8
246	0, 4666, 4666, 111, 7104, 0xc0d14f78
247	1, 102907, 102907, 512, 1024, 0xf2fdbe63
248	1, 103414, 103414, 512, 1024, 0x8d6f63a1
249	1, 103922, 103922, 512, 1024, 0xded468d9
250	1, 104429, 104429, 512, 1024, 0xccad839e
251	1, 104958, 104958, 512, 1024, 0xdde7c082
252	0, 4777, 4777, 111, 7169, 0xd03c825b
253	1, 105465, 105465, 512, 1024, 0x548613c5
254	1, 105972, 105972, 512, 1024, 0x383909bd
255	1, 106479, 106479, 512, 1024, 0xfd37627b
256	1, 106987, 106987, 512, 1024, 0x6d95a481
257	1, 107516, 107516, 512, 1024, 0x56aa87fa
258	0, 4888, 4888, 111, 7038, 0x1ecc201d
259	1, 108023, 108023, 512, 1024, 0x7b67258c
260	1, 108530, 108530, 512, 1024, 0x7dd99a92
261	1, 109037, 109037, 512, 1024, 0x4a66d102
262	1, 109566, 109566, 512, 1024, 0x7b3fce51
263	1, 110074, 110074, 512, 1024, 0xbbd968aa
264	0, 5000, 5000, 111, 7015, 0x83c94454
265	1, 110581, 110581, 512, 1024, 0x8283ec36
266	1, 111088, 111088, 512, 1024, 0x3c96493d
267	1, 111595, 111595, 512, 1024, 0xfa4f8cf8
268	1, 112124, 112124, 512, 1024, 0xe2cf872d
269	1, 112631, 112631, 512, 1024, 0x0a9e7aa6
270	0, 5111, 5111, 111, 6983, 0x9e51f54d
271	1, 113139, 113139, 512, 1024, 0x6e7a0550
272	1, 113646, 113646, 512, 1024, 0x3acfea2f
273	1, 114175, 114175, 512, 1024, 0x7111d0fa
274	1, 114682, 114682, 512, 1024, 0xe9a1eca9
275	0, 5222, 5222, 111, 7088, 0x70d33de1
276	1, 115189, 115189, 512, 1024, 0x24da6c46
277	1, 115696, 115696, 512, 1024, 0x117cff37
278	1, 116204, 116204, 512, 1024, 0x0f27cab6
279	1, 116733, 116733, 512, 1024, 0x69b6b4e6
280	1, 117240, 117240, 512, 1024, 0x1e6cc841
281	0, 5333, 5333, 111, 7096, 0x4d0f81b5
282	1, 117747, 117747, 512, 1024, 0xb01e2365
283	1, 118254, 118254, 512, 1024, 0x14e200d3
284	1, 118783, 118783, 512, 1024, 0xd1184c98
285	1, 119290, 119290, 512, 1024, 0xef9140e9
286	1, 119798, 119798, 512, 1024, 0x4cbb645e
287	0, 5444, 5444, 111, 7106, 0xd1a83ddc
288	1, 120305, 120305, 512, 1024, 0xe7fe2f06
289	1, 120812, 120812, 512, 1024, 0xf8c45028
290	1, 121341, 121341, 512, 1024, 0x561358f4
291	1, 121848, 121848, 512, 1024, 0xd0129b77
292	1, 122355, 122355, 512, 1024, 0xcc636e88
293	0, 5555, 5555, 111, 7219, 0x20f47fe4
294	1, 122863, 122863, 512, 1024, 0xe9406321
295	1, 123392, 123392, 512, 1024, 0x9f16a041
296	1, 123899, 123899, 512, 1024, 0x468bf409
297	1, 124406, 124406, 512, 1024, 0x3df70f7b
298	1, 124913, 124913, 512, 1024, 0xa880b11b
299	0, 5666, 5666, 111, 7184, 0x45dc6a0e
300	1, 125420, 125420, 512, 1024, 0x3286c489
301	1, 125950, 125950, 512, 1024, 0x39fe9ebc
302	1, 126457, 126457, 512, 1024, 0xc533d83b
303	1, 126964, 126964, 512, 1024, 0x153b195d
304	0, 5777, 5777, 111, 7222, 0x488c6499
305	1, 127471, 127471, 512, 1024, 0xd84786a1
306	1, 127978, 127978, 512, 1024, 0xdc295aaa
307	1, 128507, 128507, 512, 1024, 0xfb764d8c
308	1, 129015, 129015, 512, 1024, 0xeebc9db9
309	1, 129522, 129522, 512, 1024, 0x7ba9403e
310	0, 5888, 5888, 111, 7254, 0xbd097ba7
311	1, 130029, 130029, 512, 1024, 0x4e5571ec
312	1, 130558, 130558, 512, 1024, 0xd965fad4
313	1, 131065, 131065, 512, 1024, 0x87e259f2
314	1, 131572, 131572, 512, 1024, 0xae7e533b
315	1, 132080, 132080, 512, 1024, 0x313cf4d6
316	0, 6000, 6000, 111, 7189, 0x46e06d43
317	1, 132587, 132587, 512, 1024, 0xe1844c90
318	1, 133116, 133116, 512, 1024, 0xbb057b44
319	1, 133623, 133623, 512, 1024, 0xa5099687
320	1, 134130, 134130, 512, 1024, 0xbff10707
321	1, 134637, 134637, 512, 1024, 0x37c4ffc0
322	0, 6111, 6111, 111, 7283, 0x19dd7319
323	1, 135166, 135166, 512, 1024, 0xf9fb6caa
324	1, 135674, 135674, 512, 1024, 0x3b6a3a1f
325	1, 136181, 136181, 512, 1024, 0x83431edb
326	1, 136688, 136688, 512, 1024, 0x1eb713cf
327	1, 137195, 137195, 512, 1024, 0xd7b07a6d
328	0, 6222, 6222, 111, 7161, 0x23171d02
329	1, 137724, 137724, 512, 1024, 0x81ae3391
330	1, 138231, 138231, 512, 1024, 0xf150130a
331	1, 138739, 138739, 512, 1024, 0x09678eaa
332	1, 139246, 139246, 512, 1024, 0xb94e06f1
333	0, 6333, 6333, 111, 6976, 0xcc610c26
334	1, 139775, 139775, 512, 1024, 0x67b1dbc9
335	1, 140282, 140282, 512, 1024, 0xd6edc235
336	1, 140789, 140789, 512, 1024, 0x34e4c499
337	1, 141296, 141296, 512, 1024, 0xeefd89c0
338	1, 141804, 141804, 512, 1024, 0x38afdaf1
339	0, 6444, 6444, 111, 7056, 0x6cd917b0
340	1, 142333, 142333, 512, 1024, 0x29a60d76
341	1, 142840, 142840, 512, 1024, 0xe28a4372
342	1, 143347, 143347, 512, 1024, 0x7089454d
343	1, 143854, 143854, 512, 1024, 0x0c01bb7b
344	1, 144383, 144383, 512, 1024, 0xbd776a72
345	0, 6555, 6555, 111, 6736, 0x02b78951
346	1, 144891, 144891, 512, 1024, 0x86776fd0
347	1, 145398, 145398, 512, 1024, 0xb37c88f7
348	1, 145905, 145905, 512, 1024, 0x5f90aaf8
349	1, 146412, 146412, 512, 1024, 0x203d4222
350	1, 146941, 146941, 512, 1024, 0x382692a6
351	0, 6666, 6666, 111, 6540, 0x767e0854
352	1, 147448, 147448, 512, 1024, 0xf37c95fd
353	1, 147956, 147956, 512, 1024, 0x6c0b8877
354	1, 148463, 148463, 512, 1024, 0x2e54a8b6
355	1, 148992, 148992, 512, 1024, 0x7f266488
356	0, 6777, 6777, 111, 6170, 0xc84962fb
357	1, 149499, 149499, 512, 1024, 0xfbf20f9a
358	1, 150006, 150006, 512, 1024, 0xf2985cc0
359	1, 150513, 150513, 512, 1024, 0xc7075340
360	1, 151020, 151020, 512, 1024, 0xe4585695
361	1, 151550, 151550, 512, 1024, 0xbdffa380
362	0, 6888, 6888, 111, 6169, 0x27e06c03
363	1, 152057, 152057, 512, 1024, 0x2422a8a9
364	1, 152564, 152564, 512, 1024, 0x59cbd75f
365	1, 153071, 153071, 512, 1024, 0x04ad1a8c
366	1, 153578, 153578, 512, 1024, 0x33c09191
367	1, 154107, 154107, 512, 1024, 0x55efa6fd
368	0, 7000, 7000, 111, 5864, 0xd14db83f
369	1, 154615, 154615, 512, 1024, 0xf73d0e5d
370	1, 155122, 155122, 512, 1024, 0x6141ebae
371	1, 155629, 155629, 512, 1024, 0x7db17a68
372	1, 156158, 156158, 512, 1024, 0xa6c690b6
373	1, 156665, 156665, 512, 1024, 0xa6fd6725
374	0, 7111, 7111, 111, 5375, 0x4a21055d
375	1, 157172, 157172, 512, 1024, 0x50a90b9b
376	1, 157680, 157680, 512, 1024, 0xef990dc8
377	1, 158187, 158187, 512, 1024, 0x75adf6b5
378	1, 158716, 158716, 512, 1024, 0x61eac43e
379	1, 159223, 159223, 512, 1024, 0x67797a19
380	0, 7222, 7222, 111, 5206, 0x95ead3cb
381	1, 159730, 159730, 512, 1024, 0xf325277a
382	1, 160237, 160237, 512, 1024, 0x18bf254a
383	1, 160767, 160767, 512, 1024, 0x2ce6bee3
384	1, 161274, 161274, 512, 1024, 0x8d320860
385	0, 7333, 7333, 111, 5220, 0xcfdcc37e
386	1, 161781, 161781, 512, 1024, 0xc979b6e8
387	1, 162288, 162288, 512, 1024, 0xdb644b41
388	1, 162795, 162795, 512, 1024, 0xe1b368ba
389	1, 163324, 163324, 512, 1024, 0xacc53d15
390	1, 163832, 163832, 512, 1024, 0x42ea8c18
391	0, 7444, 7444, 111, 4946, 0x2d864a77
392	1, 164339, 164339, 512, 1024, 0xe52c99a4
393	1, 164846, 164846, 512, 1024, 0xd7db54a6
394	1, 165375, 165375, 512, 1024, 0x7f27a7e3
395	1, 165882, 165882, 512, 1024, 0xf7ffeaa9
396	1, 166389, 166389, 512, 1024, 0x792b6088
397	0, 7555, 7555, 111, 4390, 0x2ab9f462
398	1, 166896, 166896, 512, 1024, 0x61d99724
399	1, 167404, 167404, 512, 1024, 0x5213720e
400	1, 167933, 167933, 512, 1024, 0xac09dd30
401	1, 168440, 168440, 512, 1024, 0x960bf6bb
402	1, 168947, 168947, 512, 1024, 0xc90168e1
403	0, 7666, 7666, 111, 4051, 0x1d09592e
404	1, 169454, 169454, 512, 1024, 0x43b45768
405	1, 169983, 169983, 512, 1024, 0x935d60a1
406	1, 170491, 170491, 512, 1024, 0x9a342ef2
407	1, 170998, 170998, 512, 1024, 0xc894709f
408	0, 7777, 7777, 111, 3680, 0x39bd6a12
409	1, 171505, 171505, 512, 1024, 0x59b43b07
410	1, 172012, 172012, 512, 1024, 0x36a1a98d
411	1, 172541, 172541, 512, 1024, 0x9e1a121c
412	1, 173048, 173048, 512, 1024, 0x02208b78
413	1, 173556, 173556, 512, 1024, 0xd1d7b274
414	0, 7888, 7888, 111, 2910, 0x6337ece9
415	1, 174063, 174063, 512, 1024, 0xdacd5096
416	1, 174592, 174592, 512, 1024, 0x51b71ead
417	1, 175099, 175099, 512, 1024, 0xd009a7ca
418	1, 175606, 175606, 512, 1024, 0xb6d5a938
419	1, 176113, 176113, 512, 1024, 0xf3d45e47
420	0, 8000, 8000, 111, 2153, 0xf4e3bc17
421	1, 176620, 176620, 512, 1024, 0xea8e04fc
422	1, 177150, 177150, 512, 1024, 0x0b928bd8
423	1, 177657, 177657, 512, 1024, 0x0f02caec
424	1, 178164, 178164, 512, 1024, 0xe2b137a8
425	1, 178671, 178671, 512, 1024, 0xd5f94892

tests/ref/fate/smjpeg-demux+425−0

@@ -0,0 +1,425 @@
	1	#tb 0: 1/1000
	2	#tb 1: 1/1000
	3	0, 0, 0, 0, 734, 0x5a042c2c
	4	1, 0, 0, 23, 260, 0x00000000
	5	1, 23, 23, 23, 260, 0x00000000
	6	1, 46, 46, 23, 260, 0xac9e0a9b
	7	1, 69, 69, 23, 260, 0x89256f5b
	8	1, 92, 92, 23, 260, 0x8e646e36
	9	0, 111, 111, 0, 763, 0xb5893f2f
	10	1, 116, 116, 23, 260, 0x3ab972fc
	11	1, 139, 139, 23, 260, 0xaea86bb2
	12	1, 162, 162, 23, 260, 0x2366447a
	13	1, 185, 185, 23, 260, 0x82c14f9c
	14	1, 208, 208, 23, 260, 0xcdcf6fa8
	15	0, 222, 222, 0, 3023, 0x0f3907d3
	16	1, 232, 232, 23, 260, 0xb3ed64bd
	17	1, 255, 255, 23, 260, 0xac304b92
	18	1, 278, 278, 23, 260, 0xc8bc553b
	19	1, 301, 301, 23, 260, 0xd35572b4
	20	1, 325, 325, 23, 260, 0x182f6190
	21	0, 333, 333, 0, 4800, 0x22e6e18a
	22	1, 348, 348, 23, 260, 0xbf9145c0
	23	1, 371, 371, 23, 260, 0x0ec85a7e
	24	1, 394, 394, 23, 260, 0x3684720e
	25	1, 417, 417, 23, 260, 0xe985616a
	26	1, 441, 441, 23, 260, 0x12b147dc
	27	0, 444, 444, 0, 6417, 0x427adde5
	28	1, 464, 464, 23, 260, 0xb8b55dd9
	29	1, 487, 487, 23, 260, 0xfd4a7007
	30	1, 510, 510, 23, 260, 0xfcc05c9a
	31	1, 534, 534, 23, 260, 0x20f74aea
	32	0, 555, 555, 0, 6776, 0x7a74c6ad
	33	1, 557, 557, 23, 260, 0x025359ca
	34	1, 580, 580, 23, 260, 0xace44ba1
	35	1, 603, 603, 23, 260, 0x03506929
	36	1, 626, 626, 23, 260, 0x8a926f17
	37	1, 650, 650, 23, 260, 0x4a7061e7
	38	0, 666, 666, 0, 6808, 0x1f6eb7c3
	39	1, 673, 673, 23, 260, 0xf8b66cc9
	40	1, 696, 696, 23, 260, 0xe8c96dec
	41	1, 719, 719, 23, 260, 0x672a54a6
	42	1, 743, 743, 23, 260, 0xe97b5698
	43	1, 766, 766, 23, 260, 0x377f684d
	44	0, 777, 777, 0, 6726, 0x452087e6
	45	1, 789, 789, 23, 260, 0xe9a66786
	46	1, 812, 812, 23, 260, 0xf8e17080
	47	1, 835, 835, 23, 260, 0x65eb662a
	48	1, 859, 859, 23, 260, 0xd8d361e9
	49	1, 882, 882, 23, 260, 0xb8115a0b
	50	0, 888, 888, 0, 6829, 0xee82b109
	51	1, 905, 905, 23, 260, 0xa5a85461
	52	1, 928, 928, 23, 260, 0xf401663b
	53	1, 952, 952, 23, 260, 0x042f714e
	54	1, 975, 975, 23, 260, 0xdf195820
	55	1, 998, 998, 23, 260, 0x0a67653c
	56	0, 999, 999, 0, 7055, 0xf41f1108
	57	1, 1021, 1021, 23, 260, 0xe9b44d02
	58	1, 1044, 1044, 23, 260, 0xbd4747b9
	59	1, 1068, 1068, 23, 260, 0x3ef66738
	60	1, 1091, 1091, 23, 260, 0x0f4a6e44
	61	0, 1111, 1111, 0, 6977, 0xf8fe1ede
	62	1, 1114, 1114, 23, 260, 0xaa3d6eb6
	63	1, 1137, 1137, 23, 260, 0xb9a46c4a
	64	1, 1160, 1160, 23, 260, 0x4f974c2e
	65	1, 1184, 1184, 23, 260, 0x9e714a00
	66	1, 1207, 1207, 23, 260, 0x601a7152
	67	0, 1222, 1222, 0, 6942, 0x9ad105c6
	68	1, 1230, 1230, 23, 260, 0xaf317064
	69	1, 1253, 1253, 23, 260, 0x163d4829
	70	1, 1277, 1277, 23, 260, 0xc56b4f1a
	71	1, 1300, 1300, 23, 260, 0x7623729c
	72	1, 1323, 1323, 23, 260, 0xa514694f
	73	0, 1333, 1333, 0, 6926, 0xe239dad6
	74	1, 1346, 1346, 23, 260, 0x93ee4ad8
	75	1, 1369, 1369, 23, 260, 0x6d8e573f
	76	1, 1393, 1393, 23, 260, 0x13256d68
	77	1, 1416, 1416, 23, 260, 0x187761a2
	78	1, 1439, 1439, 23, 260, 0x426045e7
	79	0, 1444, 1444, 0, 6966, 0x81dcfab1
	80	1, 1462, 1462, 23, 260, 0x7e7e5891
	81	1, 1486, 1486, 23, 260, 0xd6926dcc
	82	1, 1509, 1509, 23, 260, 0xf0196061
	83	1, 1532, 1532, 23, 260, 0x7cac49a3
	84	0, 1555, 1555, 0, 6896, 0x31e6cc02
	85	1, 1555, 1555, 23, 260, 0x24f4549a
	86	1, 1578, 1578, 23, 260, 0x937f551d
	87	1, 1602, 1602, 23, 260, 0x9bf462c5
	88	1, 1625, 1625, 23, 260, 0xd1e07436
	89	1, 1648, 1648, 23, 260, 0xdab36215
	90	0, 1666, 1666, 0, 6889, 0x1cc1006e
	91	1, 1671, 1671, 23, 260, 0xabc5662b
	92	1, 1695, 1695, 23, 260, 0xa24f6bf1
	93	1, 1718, 1718, 23, 260, 0x39e664b2
	94	1, 1741, 1741, 23, 260, 0xf5dc54ca
	95	1, 1764, 1764, 23, 260, 0xc3b16974
	96	0, 1777, 1777, 0, 6933, 0xc303f87f
	97	1, 1787, 1787, 23, 260, 0x6cf46bca
	98	1, 1811, 1811, 23, 260, 0x7a6b69b9
	99	1, 1834, 1834, 23, 260, 0xc02f69b9
	100	1, 1857, 1857, 23, 260, 0x7fc764a9
	101	1, 1880, 1880, 23, 260, 0xd9705b09
	102	0, 1888, 1888, 0, 7034, 0xb4970a20
	103	1, 1904, 1904, 23, 260, 0x17b05f49
	104	1, 1927, 1927, 23, 260, 0x10ad647c
	105	1, 1950, 1950, 23, 260, 0xf9636d69
	106	1, 1973, 1973, 23, 260, 0x622b5ad9
	107	1, 1996, 1996, 23, 260, 0x175b646d
	108	0, 1999, 1999, 0, 6961, 0xf064095d
	109	1, 2020, 2020, 23, 260, 0x722b5827
	110	1, 2043, 2043, 23, 260, 0x83614974
	111	1, 2066, 2066, 23, 260, 0x80366587
	112	1, 2089, 2089, 23, 260, 0x050f6bf9
	113	0, 2111, 2111, 0, 7089, 0x5ba350f9
	114	1, 2113, 2113, 23, 260, 0x949d6735
	115	1, 2136, 2136, 23, 260, 0x62cd7184
	116	1, 2159, 2159, 23, 260, 0x21e45713
	117	1, 2182, 2182, 23, 260, 0x56314509
	118	1, 2205, 2205, 23, 260, 0x7a1570d3
	119	0, 2222, 2222, 0, 7078, 0xa83f3e88
	120	1, 2229, 2229, 23, 260, 0x205a6ffb
	121	1, 2252, 2252, 23, 260, 0xead94483
	122	1, 2275, 2275, 23, 260, 0x93c84f10
	123	1, 2298, 2298, 23, 260, 0xdf45726f
	124	1, 2321, 2321, 23, 260, 0x35016f1e
	125	0, 2333, 2333, 0, 7147, 0xcda66cfc
	126	1, 2345, 2345, 23, 260, 0xa8114bcd
	127	1, 2368, 2368, 23, 260, 0x14c45130
	128	1, 2391, 2391, 23, 260, 0x97b07052
	129	1, 2414, 2414, 23, 260, 0x039b6c77
	130	1, 2438, 2438, 23, 260, 0x46f74635
	131	0, 2444, 2444, 0, 7173, 0xb7455859
	132	1, 2461, 2461, 23, 260, 0x4116540d
	133	1, 2484, 2484, 23, 260, 0x26747067
	134	1, 2507, 2507, 23, 260, 0x37f16485
	135	1, 2530, 2530, 23, 260, 0x631d4a33
	136	1, 2554, 2554, 23, 260, 0x14ed598d
	137	0, 2555, 2555, 0, 7213, 0x97b89994
	138	1, 2577, 2577, 23, 260, 0x3f9349e7
	139	1, 2600, 2600, 23, 260, 0x91295757
	140	1, 2623, 2623, 23, 260, 0x95de72bc
	141	1, 2647, 2647, 23, 260, 0xc7ee5ddb
	142	0, 2666, 2666, 0, 7170, 0xca8b2948
	143	1, 2670, 2670, 23, 260, 0x38e965cd
	144	1, 2693, 2693, 23, 260, 0xfae169e9
	145	1, 2716, 2716, 23, 260, 0x9c226143
	146	1, 2739, 2739, 23, 260, 0x1a804dbe
	147	1, 2763, 2763, 23, 260, 0x4aeb633c
	148	0, 2777, 2777, 0, 7174, 0xc7cc6bbb
	149	1, 2786, 2786, 23, 260, 0xa66e6bbb
	150	1, 2809, 2809, 23, 260, 0x51d17109
	151	1, 2832, 2832, 23, 260, 0x2bc86b9b
	152	1, 2856, 2856, 23, 260, 0xe56e6378
	153	1, 2879, 2879, 23, 260, 0x95665b47
	154	0, 2888, 2888, 0, 7235, 0xc2e68d2b
	155	1, 2902, 2902, 23, 260, 0x1c255fdb
	156	1, 2925, 2925, 23, 260, 0x3a2456cb
	157	1, 2948, 2948, 23, 260, 0xe18e7270
	158	1, 2972, 2972, 23, 260, 0x55b65c60
	159	1, 2995, 2995, 23, 260, 0x62be6515
	160	0, 3000, 3000, 0, 7261, 0x8204a423
	161	1, 3018, 3018, 23, 260, 0xdba25d09
	162	1, 3041, 3041, 23, 260, 0xd7cc4e40
	163	1, 3065, 3065, 23, 260, 0x335661be
	164	1, 3088, 3088, 23, 260, 0xc3286de3
	165	0, 3111, 3111, 0, 7353, 0xacc7e7c0
	166	1, 3111, 3111, 23, 260, 0x47e76e35
	167	1, 3134, 3134, 23, 260, 0x4b716f77
	168	1, 3157, 3157, 23, 260, 0x0716519e
	169	1, 3181, 3181, 23, 260, 0x032b4490
	170	1, 3204, 3204, 23, 260, 0x15f067e8
	171	0, 3222, 3222, 0, 7065, 0x45035c5c
	172	1, 3227, 3227, 23, 260, 0x16766ffa
	173	1, 3250, 3250, 23, 260, 0xc94154ac
	174	1, 3274, 3274, 23, 260, 0x74764bcd
	175	1, 3297, 3297, 23, 260, 0x3fad6f8f
	176	1, 3320, 3320, 23, 260, 0x5fa972a9
	177	0, 3333, 3333, 0, 7269, 0x72edbb76
	178	1, 3343, 3343, 23, 260, 0xde2a4b7b
	179	1, 3366, 3366, 23, 260, 0xd8494408
	180	1, 3390, 3390, 23, 260, 0x843d71a6
	181	1, 3413, 3413, 23, 260, 0x87fd6b60
	182	1, 3436, 3436, 23, 260, 0x1cc04a39
	183	0, 3444, 3444, 0, 7220, 0xb926772f
	184	1, 3459, 3459, 23, 260, 0x9ca24d94
	185	1, 3482, 3482, 23, 260, 0x820a7087
	186	1, 3506, 3506, 23, 260, 0x631166b2
	187	1, 3529, 3529, 23, 260, 0x2f20492a
	188	1, 3552, 3552, 23, 260, 0x932156d0
	189	0, 3555, 3555, 0, 7326, 0x0a66c632
	190	1, 3575, 3575, 23, 260, 0xdad54c90
	191	1, 3599, 3599, 23, 260, 0xcce84fc9
	192	1, 3622, 3622, 23, 260, 0xba317486
	193	1, 3645, 3645, 23, 260, 0xf5a4626a
	194	0, 3666, 3666, 0, 7225, 0xe39076ab
	195	1, 3668, 3668, 23, 260, 0x324669fd
	196	1, 3691, 3691, 23, 260, 0xc7d37113
	197	1, 3715, 3715, 23, 260, 0xc6e0644f
	198	1, 3738, 3738, 23, 260, 0x1b91522e
	199	1, 3761, 3761, 23, 260, 0x9b84667d
	200	0, 3777, 3777, 0, 7265, 0xe0209036
	201	1, 3784, 3784, 23, 260, 0xed7e66eb
	202	1, 3808, 3808, 23, 260, 0xaf806d1f
	203	1, 3831, 3831, 23, 260, 0x13a66941
	204	1, 3854, 3854, 23, 260, 0x13095a41
	205	1, 3877, 3877, 23, 260, 0x5ba05491
	206	0, 3888, 3888, 0, 7337, 0x7a5dc093
	207	1, 3900, 3900, 23, 260, 0xbf785887
	208	1, 3924, 3924, 23, 260, 0x21965973
	209	1, 3947, 3947, 23, 260, 0xd9aa7134
	210	1, 3970, 3970, 23, 260, 0x3add62bc
	211	1, 3993, 3993, 23, 260, 0xb9626260
	212	0, 4000, 4000, 0, 7246, 0x519a7a3c
	213	1, 4017, 4017, 23, 260, 0x5b08629f
	214	1, 4040, 4040, 23, 260, 0x43a34659
	215	1, 4063, 4063, 23, 260, 0x68575bda
	216	1, 4086, 4086, 23, 260, 0xd98b715a
	217	1, 4109, 4109, 23, 260, 0x7d816a77
	218	0, 4111, 4111, 0, 7266, 0x352c8078
	219	1, 4133, 4133, 23, 260, 0x16af6ff1
	220	1, 4156, 4156, 23, 260, 0x6d4557a7
	221	1, 4179, 4179, 23, 260, 0x0743401a
	222	1, 4202, 4202, 23, 260, 0x410563d8
	223	0, 4222, 4222, 0, 7323, 0xcaf69d7c
	224	1, 4226, 4226, 23, 260, 0x561371d1
	225	1, 4249, 4249, 23, 260, 0x3ef15872
	226	1, 4272, 4272, 23, 260, 0x1dd04972
	227	1, 4295, 4295, 23, 260, 0xed226c62
	228	1, 4318, 4318, 23, 260, 0x20857046
	229	0, 4333, 4333, 0, 7309, 0x98c1e6f7
	230	1, 4342, 4342, 23, 260, 0xed7f4724
	231	1, 4365, 4365, 23, 260, 0x7a7445cf
	232	1, 4388, 4388, 23, 260, 0x06ad6a93
	233	1, 4411, 4411, 23, 260, 0xdd1b6c91
	234	1, 4435, 4435, 23, 260, 0x05b94d27
	235	0, 4444, 4444, 0, 7121, 0x913d5bd6
	236	1, 4458, 4458, 23, 260, 0x12cc5062
	237	1, 4481, 4481, 23, 260, 0x44526d0f
	238	1, 4504, 4504, 23, 260, 0xf2ac6d95
	239	1, 4527, 4527, 23, 260, 0x27174b0f
	240	1, 4551, 4551, 23, 260, 0xcf125efe
	241	0, 4555, 4555, 111, 7088, 0x56302362
	242	1, 4574, 4574, 23, 260, 0xb8ce45a1
	243	1, 4597, 4597, 23, 260, 0x91895627
	244	1, 4620, 4620, 23, 260, 0x6edb706a
	245	1, 4643, 4643, 23, 260, 0x4e16674b
	246	0, 4666, 4666, 111, 7104, 0xc0d14f78
	247	1, 4667, 4667, 23, 260, 0xa9d66370
	248	1, 4690, 4690, 23, 260, 0x8f007043
	249	1, 4713, 4713, 23, 260, 0xdc1a5583
	250	1, 4736, 4736, 23, 260, 0x2f025511
	251	1, 4760, 4760, 23, 260, 0x2a4d6ddb
	252	0, 4777, 4777, 111, 7169, 0xd03c825b
	253	1, 4783, 4783, 23, 260, 0x54806f14
	254	1, 4806, 4806, 23, 260, 0xe0ac6d80
	255	1, 4829, 4829, 23, 260, 0xd9cf6c97
	256	1, 4852, 4852, 23, 260, 0xba705b6d
	257	1, 4876, 4876, 23, 260, 0x0be158e0
	258	0, 4888, 4888, 111, 7038, 0x1ecc201d
	259	1, 4899, 4899, 23, 260, 0x32b3645d
	260	1, 4922, 4922, 23, 260, 0x4a0a55b4
	261	1, 4945, 4945, 23, 260, 0x078b6fd8
	262	1, 4969, 4969, 23, 260, 0xc2816368
	263	1, 4992, 4992, 23, 260, 0xbdee5e4d
	264	0, 5000, 5000, 111, 7015, 0x83c94454
	265	1, 5015, 5015, 23, 260, 0x475366aa
	266	1, 5038, 5038, 23, 260, 0x2f9a44b9
	267	1, 5061, 5061, 23, 260, 0x91745ee5
	268	1, 5085, 5085, 23, 260, 0xc29b6e16
	269	1, 5108, 5108, 23, 260, 0x6ebb6b0e
	270	0, 5111, 5111, 111, 6983, 0x9e51f54d
	271	1, 5131, 5131, 23, 260, 0x4e7d7043
	272	1, 5154, 5154, 23, 260, 0x10b45caf
	273	1, 5178, 5178, 23, 260, 0x1b1e4e54
	274	1, 5201, 5201, 23, 260, 0xcc7b6443
	275	0, 5222, 5222, 111, 7088, 0x70d33de1
	276	1, 5224, 5224, 23, 260, 0x29936fdd
	277	1, 5247, 5247, 23, 260, 0x395256e3
	278	1, 5270, 5270, 23, 260, 0x50fb459f
	279	1, 5294, 5294, 23, 260, 0x0bef64ec
	280	1, 5317, 5317, 23, 260, 0xadd372dd
	281	0, 5333, 5333, 111, 7096, 0x4d0f81b5
	282	1, 5340, 5340, 23, 260, 0xc49e56dc
	283	1, 5363, 5363, 23, 260, 0x44e749c1
	284	1, 5387, 5387, 23, 260, 0x030e6c8a
	285	1, 5410, 5410, 23, 260, 0x82a47261
	286	1, 5433, 5433, 23, 260, 0xa3764fcc
	287	0, 5444, 5444, 111, 7106, 0xd1a83ddc
	288	1, 5456, 5456, 23, 260, 0xb1a1498a
	289	1, 5479, 5479, 23, 260, 0xbf9c7184
	290	1, 5503, 5503, 23, 260, 0xa45f6da8
	291	1, 5526, 5526, 23, 260, 0x9a2e4d51
	292	1, 5549, 5549, 23, 260, 0xa15c56ed
	293	0, 5555, 5555, 111, 7219, 0x20f47fe4
	294	1, 5572, 5572, 23, 260, 0x7029496c
	295	1, 5596, 5596, 23, 260, 0xf3595213
	296	1, 5619, 5619, 23, 260, 0x0dab6c5a
	297	1, 5642, 5642, 23, 260, 0x0e2367da
	298	1, 5665, 5665, 23, 260, 0xbb56610a
	299	0, 5666, 5666, 111, 7184, 0x45dc6a0e
	300	1, 5688, 5688, 23, 260, 0xcc916c92
	301	1, 5712, 5712, 23, 260, 0x886c5ba9
	302	1, 5735, 5735, 23, 260, 0x1b255a69
	303	1, 5758, 5758, 23, 260, 0xb7a66792
	304	0, 5777, 5777, 111, 7222, 0x488c6499
	305	1, 5781, 5781, 23, 260, 0x7d946b0e
	306	1, 5804, 5804, 23, 260, 0x07d16714
	307	1, 5828, 5828, 23, 260, 0x77ef6755
	308	1, 5851, 5851, 23, 260, 0xb2fe6849
	309	1, 5874, 5874, 23, 260, 0x601b5325
	310	0, 5888, 5888, 111, 7254, 0xbd097ba7
	311	1, 5897, 5897, 23, 260, 0x309c68d0
	312	1, 5921, 5921, 23, 260, 0x7bbe5d49
	313	1, 5944, 5944, 23, 260, 0x77bc6e47
	314	1, 5967, 5967, 23, 260, 0x3e0a6b0b
	315	1, 5990, 5990, 23, 260, 0x2ae458c4
	316	0, 6000, 6000, 111, 7189, 0x46e06d43
	317	1, 6013, 6013, 23, 260, 0x17576d4f
	318	1, 6037, 6037, 23, 260, 0x496c4bbd
	319	1, 6060, 6060, 23, 260, 0x972758a0
	320	1, 6083, 6083, 23, 260, 0xa9897452
	321	1, 6106, 6106, 23, 260, 0xf58c6b92
	322	0, 6111, 6111, 111, 7283, 0x19dd7319
	323	1, 6130, 6130, 23, 260, 0x8368709a
	324	1, 6153, 6153, 23, 260, 0x3890643f
	325	1, 6176, 6176, 23, 260, 0xdcc1472c
	326	1, 6199, 6199, 23, 260, 0xb601605c
	327	0, 6222, 6222, 111, 7161, 0x23171d02
	328	1, 6222, 6222, 23, 260, 0xfafd6e13
	329	1, 6246, 6246, 23, 260, 0x20a55dbf
	330	1, 6269, 6269, 23, 260, 0x84a147e6
	331	1, 6292, 6292, 23, 260, 0xe2c75bfd
	332	1, 6315, 6315, 23, 260, 0x52f672c4
	333	0, 6333, 6333, 111, 6976, 0xcc610c26
	334	1, 6339, 6339, 23, 260, 0x98af579a
	335	1, 6362, 6362, 23, 260, 0xf2034f37
	336	1, 6385, 6385, 23, 260, 0x75576856
	337	1, 6408, 6408, 23, 260, 0x4a796f1b
	338	1, 6431, 6431, 23, 260, 0x3a7a5612
	339	0, 6444, 6444, 111, 7056, 0x6cd917b0
	340	1, 6455, 6455, 23, 260, 0x1c0646bd
	341	1, 6478, 6478, 23, 260, 0xfccd6e2c
	342	1, 6501, 6501, 23, 260, 0x2bdd7139
	343	1, 6524, 6524, 23, 260, 0xadb4519a
	344	1, 6548, 6548, 23, 260, 0x8ef655b5
	345	0, 6555, 6555, 111, 6736, 0x02b78951
	346	1, 6571, 6571, 23, 260, 0x157852f6
	347	1, 6594, 6594, 23, 260, 0xec3a4aa8
	348	1, 6617, 6617, 23, 260, 0x5fa77041
	349	1, 6640, 6640, 23, 260, 0xe862690f
	350	1, 6664, 6664, 23, 260, 0xad1759ce
	351	0, 6666, 6666, 111, 6540, 0x767e0854
	352	1, 6687, 6687, 23, 260, 0x856f6d2e
	353	1, 6710, 6710, 23, 260, 0x19496938
	354	1, 6733, 6733, 23, 260, 0xf3135c06
	355	1, 6757, 6757, 23, 260, 0xbec861ab
	356	0, 6777, 6777, 111, 6170, 0xc84962fb
	357	1, 6780, 6780, 23, 260, 0x97486f09
	358	1, 6803, 6803, 23, 260, 0x2dcb64ed
	359	1, 6826, 6826, 23, 260, 0xac196fe8
	360	1, 6849, 6849, 23, 260, 0xa7d460f8
	361	1, 6873, 6873, 23, 260, 0x02e55631
	362	0, 6888, 6888, 111, 6169, 0x27e06c03
	363	1, 6896, 6896, 23, 260, 0x92556737
	364	1, 6919, 6919, 23, 260, 0x9ab25599
	365	1, 6942, 6942, 23, 260, 0x48017498
	366	1, 6965, 6965, 23, 260, 0x3f376d65
	367	1, 6989, 6989, 23, 260, 0x553750e2
	368	0, 7000, 7000, 111, 5864, 0xd14db83f
	369	1, 7012, 7012, 23, 260, 0x430a6cb9
	370	1, 7035, 7035, 23, 260, 0x0d4f3b7e
	371	1, 7058, 7058, 23, 260, 0xc5ee5733
	372	1, 7082, 7082, 23, 260, 0xec33744f
	373	1, 7105, 7105, 23, 260, 0xb7ca6c50
	374	0, 7111, 7111, 111, 5375, 0x4a21055d
	375	1, 7128, 7128, 23, 260, 0xca8e6e09
	376	1, 7151, 7151, 23, 260, 0xde7b67d9
	377	1, 7174, 7174, 23, 260, 0x1eeb47c6
	378	1, 7198, 7198, 23, 260, 0x97e355f6
	379	1, 7221, 7221, 23, 260, 0x4cb871da
	380	0, 7222, 7222, 111, 5206, 0x95ead3cb
	381	1, 7244, 7244, 23, 260, 0xf9d65f42
	382	1, 7267, 7267, 23, 260, 0x4df447f9
	383	1, 7291, 7291, 23, 260, 0x6da55c39
	384	1, 7314, 7314, 23, 260, 0xf8487192
	385	0, 7333, 7333, 111, 5220, 0xcfdcc37e
	386	1, 7337, 7337, 23, 260, 0xa5ef5e84
	387	1, 7360, 7360, 23, 260, 0xc750404d
	388	1, 7383, 7383, 23, 260, 0xe62d5ba7
	389	1, 7407, 7407, 23, 260, 0xa362739c
	390	1, 7430, 7430, 23, 260, 0x784c57f9
	391	0, 7444, 7444, 111, 4946, 0x2d864a77
	392	1, 7453, 7453, 23, 260, 0xac224b6f
	393	1, 7476, 7476, 23, 260, 0x34506907
	394	1, 7500, 7500, 23, 260, 0x94207121
	395	1, 7523, 7523, 23, 260, 0x018754e6
	396	1, 7546, 7546, 23, 260, 0xa5355133
	397	0, 7555, 7555, 111, 4390, 0x2ab9f462
	398	1, 7569, 7569, 23, 260, 0x93724dac
	399	1, 7592, 7592, 23, 260, 0x41e24c4c
	400	1, 7616, 7616, 23, 260, 0x1b2a7301
	401	1, 7639, 7639, 23, 260, 0xcce36e61
	402	1, 7662, 7662, 23, 260, 0xb323585a
	403	0, 7666, 7666, 111, 4051, 0x1d09592e
	404	1, 7685, 7685, 23, 260, 0x6f7c624d
	405	1, 7709, 7709, 23, 260, 0x87b96a4a
	406	1, 7732, 7732, 23, 260, 0xf567622a
	407	1, 7755, 7755, 23, 260, 0x52ce5d35
	408	0, 7777, 7777, 111, 3680, 0x39bd6a12
	409	1, 7778, 7778, 23, 260, 0x58a46c28
	410	1, 7801, 7801, 23, 260, 0x8e3e6d9a
	411	1, 7825, 7825, 23, 260, 0x5ef66906
	412	1, 7848, 7848, 23, 260, 0x351b5f9f
	413	1, 7871, 7871, 23, 260, 0x90b9588a
	414	0, 7888, 7888, 111, 2910, 0x6337ece9
	415	1, 7894, 7894, 23, 260, 0x34e8615f
	416	1, 7918, 7918, 23, 260, 0xcef75ab9
	417	1, 7941, 7941, 23, 260, 0x471f6bc8
	418	1, 7964, 7964, 23, 260, 0xd4756c62
	419	1, 7987, 7987, 23, 260, 0x7c554702
	420	0, 8000, 8000, 111, 2153, 0xf4e3bc17
	421	1, 8010, 8010, 23, 260, 0x185272f1
	422	1, 8034, 8034, 23, 260, 0x0c364348
	423	1, 8057, 8057, 23, 260, 0x24354467
	424	1, 8080, 8080, 23, 260, 0x837d5472
	425	1, 8103, 8103, 23, 260, 0xece2344f

tools/lavfi-showfiltfmts.c+1−1

@@ -46,7 +46,7 @@ static void print_formats(AVFilterContext *filter_ctx) · 45 unmodified lines
46	i, filter_ctx->filter->inout##puts[i].name, \	46	i, filter_ctx->filter->inout##puts[i].name, \
47	av_get_sample_fmt_name(fmts->formats[j])); \	47	av_get_sample_fmt_name(fmts->formats[j])); \
48	\	48	\
49	fmts = filter_ctx->inout##puts[i]->outin##_chlayouts; \	49	fmts = filter_ctx->inout##puts[i]->outin##_channel_layouts; \
50	for (j = 0; j < fmts->format_count; j++) { \	50	for (j = 0; j < fmts->format_count; j++) { \
51	char buf[256]; \	51	char buf[256]; \
52	av_get_channel_layout_string(buf, sizeof(buf), -1, \	52	av_get_channel_layout_string(buf, sizeof(buf), -1, \

Merge remote-tracking branch 'qatar/master'

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code