path: root/ffmpeg_opt.c (plain)
blob: e73a61059f6d7935e711ec4435da2e59b84ac3cd

1	/*
2	* ffmpeg option parsing
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	#include <stdint.h>
22
23	#include "ffmpeg.h"
24	#include "cmdutils.h"
25
26	#include "libavformat/avformat.h"
27
28	#include "libavcodec/avcodec.h"
29
30	#include "libavfilter/avfilter.h"
31
32	#include "libavutil/avassert.h"
33	#include "libavutil/avstring.h"
34	#include "libavutil/avutil.h"
35	#include "libavutil/channel_layout.h"
36	#include "libavutil/intreadwrite.h"
37	#include "libavutil/fifo.h"
38	#include "libavutil/mathematics.h"
39	#include "libavutil/opt.h"
40	#include "libavutil/parseutils.h"
41	#include "libavutil/pixdesc.h"
42	#include "libavutil/pixfmt.h"
43
44	#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
45
46	#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
47	{\
48	int i, ret;\
49	for (i = 0; i < o->nb_ ## name; i++) {\
50	char *spec = o->name[i].specifier;\
51	if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
52	outvar = o->name[i].u.type;\
53	else if (ret < 0)\
54	exit_program(1);\
55	}\
56	}
57
58	#define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
59	{\
60	int i;\
61	for (i = 0; i < o->nb_ ## name; i++) {\
62	char *spec = o->name[i].specifier;\
63	if (!strcmp(spec, mediatype))\
64	outvar = o->name[i].u.type;\
65	}\
66	}
67
68	const HWAccel hwaccels[] = {
69	#if HAVE_VDPAU_X11
70	{ "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
71	#endif
72	#if HAVE_DXVA2_LIB
73	{ "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
74	#endif
75	#if CONFIG_VDA
76	{ "vda", videotoolbox_init, HWACCEL_VDA, AV_PIX_FMT_VDA },
77	#endif
78	#if CONFIG_VIDEOTOOLBOX
79	{ "videotoolbox", videotoolbox_init, HWACCEL_VIDEOTOOLBOX, AV_PIX_FMT_VIDEOTOOLBOX },
80	#endif
81	#if CONFIG_LIBMFX
82	{ "qsv", qsv_init, HWACCEL_QSV, AV_PIX_FMT_QSV },
83	#endif
84	#if CONFIG_VAAPI
85	{ "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
86	#endif
87	#if CONFIG_CUVID
88	{ "cuvid", cuvid_init, HWACCEL_CUVID, AV_PIX_FMT_CUDA },
89	#endif
90	{ 0 },
91	};
92	int hwaccel_lax_profile_check = 0;
93	AVBufferRef *hw_device_ctx;
94
95	char *vstats_filename;
96	char *sdp_filename;
97
98	float audio_drift_threshold = 0.1;
99	float dts_delta_threshold = 10;
100	float dts_error_threshold = 3600*30;
101
102	int audio_volume = 256;
103	int audio_sync_method = 0;
104	int video_sync_method = VSYNC_AUTO;
105	float frame_drop_threshold = 0;
106	int do_deinterlace = 0;
107	int do_benchmark = 0;
108	int do_benchmark_all = 0;
109	int do_hex_dump = 0;
110	int do_pkt_dump = 0;
111	int copy_ts = 0;
112	int start_at_zero = 0;
113	int copy_tb = -1;
114	int debug_ts = 0;
115	int exit_on_error = 0;
116	int abort_on_flags = 0;
117	int print_stats = -1;
118	int qp_hist = 0;
119	int stdin_interaction = 1;
120	int frame_bits_per_raw_sample = 0;
121	float max_error_rate = 2.0/3;
122	int filter_nbthreads = 0;
123	int filter_complex_nbthreads = 0;
124	int vstats_version = 2;
125
126
127	static int intra_only = 0;
128	static int file_overwrite = 0;
129	static int no_file_overwrite = 0;
130	static int do_psnr = 0;
131	static int input_sync;
132	static int override_ffserver = 0;
133	static int input_stream_potentially_available = 0;
134	static int ignore_unknown_streams = 0;
135	static int copy_unknown_streams = 0;
136
137	static void uninit_options(OptionsContext *o)
138	{
139	const OptionDef *po = options;
140	int i;
141
142	/* all OPT_SPEC and OPT_STRING can be freed in generic way */
143	while (po->name) {
144	void *dst = (uint8_t*)o + po->u.off;
145
146	if (po->flags & OPT_SPEC) {
147	SpecifierOpt **so = dst;
148	int i, *count = (int*)(so + 1);
149	for (i = 0; i < *count; i++) {
150	av_freep(&(*so)[i].specifier);
151	if (po->flags & OPT_STRING)
152	av_freep(&(*so)[i].u.str);
153	}
154	av_freep(so);
155	*count = 0;
156	} else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
157	av_freep(dst);
158	po++;
159	}
160
161	for (i = 0; i < o->nb_stream_maps; i++)
162	av_freep(&o->stream_maps[i].linklabel);
163	av_freep(&o->stream_maps);
164	av_freep(&o->audio_channel_maps);
165	av_freep(&o->streamid_map);
166	av_freep(&o->attachments);
167	}
168
169	static void init_options(OptionsContext *o)
170	{
171	memset(o, 0, sizeof(*o));
172
173	o->stop_time = INT64_MAX;
174	o->mux_max_delay = 0.7;
175	o->start_time = AV_NOPTS_VALUE;
176	o->start_time_eof = AV_NOPTS_VALUE;
177	o->recording_time = INT64_MAX;
178	o->limit_filesize = UINT64_MAX;
179	o->chapters_input_file = INT_MAX;
180	o->accurate_seek = 1;
181	}
182
183	static int show_hwaccels(void *optctx, const char *opt, const char *arg)
184	{
185	int i;
186
187	printf("Hardware acceleration methods:\n");
188	for (i = 0; hwaccels[i].name; i++) {
189	printf("%s\n", hwaccels[i].name);
190	}
191	printf("\n");
192	return 0;
193	}
194
195	/* return a copy of the input with the stream specifiers removed from the keys */
196	static AVDictionary *strip_specifiers(AVDictionary *dict)
197	{
198	AVDictionaryEntry *e = NULL;
199	AVDictionary *ret = NULL;
200
201	while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
202	char *p = strchr(e->key, ':');
203
204	if (p)
205	*p = 0;
206	av_dict_set(&ret, e->key, e->value, 0);
207	if (p)
208	*p = ':';
209	}
210	return ret;
211	}
212
213	static int opt_abort_on(void *optctx, const char *opt, const char *arg)
214	{
215	static const AVOption opts[] = {
216	{ "abort_on" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
217	{ "empty_output" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = ABORT_ON_FLAG_EMPTY_OUTPUT }, .unit = "flags" },
218	{ NULL },
219	};
220	static const AVClass class = {
221	.class_name = "",
222	.item_name = av_default_item_name,
223	.option = opts,
224	.version = LIBAVUTIL_VERSION_INT,
225	};
226	const AVClass *pclass = &class;
227
228	return av_opt_eval_flags(&pclass, &opts[0], arg, &abort_on_flags);
229	}
230
231	static int opt_sameq(void *optctx, const char *opt, const char *arg)
232	{
233	av_log(NULL, AV_LOG_ERROR, "Option '%s' was removed. "
234	"If you are looking for an option to preserve the quality (which is not "
235	"what -%s was for), use -qscale 0 or an equivalent quality factor option.\n",
236	opt, opt);
237	return AVERROR(EINVAL);
238	}
239
240	static int opt_video_channel(void *optctx, const char *opt, const char *arg)
241	{
242	av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
243	return opt_default(optctx, "channel", arg);
244	}
245
246	static int opt_video_standard(void *optctx, const char *opt, const char *arg)
247	{
248	av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
249	return opt_default(optctx, "standard", arg);
250	}
251
252	static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
253	{
254	OptionsContext *o = optctx;
255	return parse_option(o, "codec:a", arg, options);
256	}
257
258	static int opt_video_codec(void *optctx, const char *opt, const char *arg)
259	{
260	OptionsContext *o = optctx;
261	return parse_option(o, "codec:v", arg, options);
262	}
263
264	static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
265	{
266	OptionsContext *o = optctx;
267	return parse_option(o, "codec:s", arg, options);
268	}
269
270	static int opt_data_codec(void *optctx, const char *opt, const char *arg)
271	{
272	OptionsContext *o = optctx;
273	return parse_option(o, "codec:d", arg, options);
274	}
275
276	static int opt_map(void *optctx, const char *opt, const char *arg)
277	{
278	OptionsContext *o = optctx;
279	StreamMap *m = NULL;
280	int i, negative = 0, file_idx;
281	int sync_file_idx = -1, sync_stream_idx = 0;
282	char *p, *sync;
283	char *map;
284	char *allow_unused;
285
286	if (*arg == '-') {
287	negative = 1;
288	arg++;
289	}
290	map = av_strdup(arg);
291	if (!map)
292	return AVERROR(ENOMEM);
293
294	/* parse sync stream first, just pick first matching stream */
295	if (sync = strchr(map, ',')) {
296	*sync = 0;
297	sync_file_idx = strtol(sync + 1, &sync, 0);
298	if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
299	av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
300	exit_program(1);
301	}
302	if (*sync)
303	sync++;
304	for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
305	if (check_stream_specifier(input_files[sync_file_idx]->ctx,
306	input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
307	sync_stream_idx = i;
308	break;
309	}
310	if (i == input_files[sync_file_idx]->nb_streams) {
311	av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
312	"match any streams.\n", arg);
313	exit_program(1);
314	}
315	}
316
317
318	if (map[0] == '[') {
319	/* this mapping refers to lavfi output */
320	const char *c = map + 1;
321	GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
322	m = &o->stream_maps[o->nb_stream_maps - 1];
323	m->linklabel = av_get_token(&c, "]");
324	if (!m->linklabel) {
325	av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
326	exit_program(1);
327	}
328	} else {
329	if (allow_unused = strchr(map, '?'))
330	*allow_unused = 0;
331	file_idx = strtol(map, &p, 0);
332	if (file_idx >= nb_input_files || file_idx < 0) {
333	av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
334	exit_program(1);
335	}
336	if (negative)
337	/* disable some already defined maps */
338	for (i = 0; i < o->nb_stream_maps; i++) {
339	m = &o->stream_maps[i];
340	if (file_idx == m->file_index &&
341	check_stream_specifier(input_files[m->file_index]->ctx,
342	input_files[m->file_index]->ctx->streams[m->stream_index],
343	*p == ':' ? p + 1 : p) > 0)
344	m->disabled = 1;
345	}
346	else
347	for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
348	if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
349	*p == ':' ? p + 1 : p) <= 0)
350	continue;
351	GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
352	m = &o->stream_maps[o->nb_stream_maps - 1];
353
354	m->file_index = file_idx;
355	m->stream_index = i;
356
357	if (sync_file_idx >= 0) {
358	m->sync_file_index = sync_file_idx;
359	m->sync_stream_index = sync_stream_idx;
360	} else {
361	m->sync_file_index = file_idx;
362	m->sync_stream_index = i;
363	}
364	}
365	}
366
367	if (!m) {
368	if (allow_unused) {
369	av_log(NULL, AV_LOG_VERBOSE, "Stream map '%s' matches no streams; ignoring.\n", arg);
370	} else {
371	av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n"
372	"To ignore this, add a trailing '?' to the map.\n", arg);
373	exit_program(1);
374	}
375	}
376
377	av_freep(&map);
378	return 0;
379	}
380
381	static int opt_attach(void *optctx, const char *opt, const char *arg)
382	{
383	OptionsContext *o = optctx;
384	GROW_ARRAY(o->attachments, o->nb_attachments);
385	o->attachments[o->nb_attachments - 1] = arg;
386	return 0;
387	}
388
389	static int opt_map_channel(void *optctx, const char *opt, const char *arg)
390	{
391	OptionsContext *o = optctx;
392	int n;
393	AVStream *st;
394	AudioChannelMap *m;
395
396	GROW_ARRAY(o->audio_channel_maps, o->nb_audio_channel_maps);
397	m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
398
399	/* muted channel syntax */
400	n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
401	if ((n == 1 || n == 3) && m->channel_idx == -1) {
402	m->file_idx = m->stream_idx = -1;
403	if (n == 1)
404	m->ofile_idx = m->ostream_idx = -1;
405	return 0;
406	}
407
408	/* normal syntax */
409	n = sscanf(arg, "%d.%d.%d:%d.%d",
410	&m->file_idx, &m->stream_idx, &m->channel_idx,
411	&m->ofile_idx, &m->ostream_idx);
412
413	if (n != 3 && n != 5) {
414	av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
415	"[file.stream.channel|-1][:syncfile:syncstream]\n");
416	exit_program(1);
417	}
418
419	if (n != 5) // only file.stream.channel specified
420	m->ofile_idx = m->ostream_idx = -1;
421
422	/* check input */
423	if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
424	av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
425	m->file_idx);
426	exit_program(1);
427	}
428	if (m->stream_idx < 0 ||
429	m->stream_idx >= input_files[m->file_idx]->nb_streams) {
430	av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
431	m->file_idx, m->stream_idx);
432	exit_program(1);
433	}
434	st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
435	if (st->codecpar->codec_type != AVMEDIA_TYPE_AUDIO) {
436	av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
437	m->file_idx, m->stream_idx);
438	exit_program(1);
439	}
440	if (m->channel_idx < 0 || m->channel_idx >= st->codecpar->channels) {
441	av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
442	m->file_idx, m->stream_idx, m->channel_idx);
443	exit_program(1);
444	}
445	return 0;
446	}
447
448	static int opt_sdp_file(void *optctx, const char *opt, const char *arg)
449	{
450	av_free(sdp_filename);
451	sdp_filename = av_strdup(arg);
452	return 0;
453	}
454
455	#if CONFIG_VAAPI
456	static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
457	{
458	int err;
459	err = vaapi_device_init(arg);
460	if (err < 0)
461	exit_program(1);
462	return 0;
463	}
464	#endif
465
466	/**
467	* Parse a metadata specifier passed as 'arg' parameter.
468	* @param arg metadata string to parse
469	* @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
470	* @param index for type c/p, chapter/program index is written here
471	* @param stream_spec for type s, the stream specifier is written here
472	*/
473	static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
474	{
475	if (*arg) {
476	*type = *arg;
477	switch (*arg) {
478	case 'g':
479	break;
480	case 's':
481	if (*(++arg) && *arg != ':') {
482	av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
483	exit_program(1);
484	}
485	*stream_spec = *arg == ':' ? arg + 1 : "";
486	break;
487	case 'c':
488	case 'p':
489	if (*(++arg) == ':')
490	*index = strtol(++arg, NULL, 0);
491	break;
492	default:
493	av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
494	exit_program(1);
495	}
496	} else
497	*type = 'g';
498	}
499
500	static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
501	{
502	AVDictionary **meta_in = NULL;
503	AVDictionary **meta_out = NULL;
504	int i, ret = 0;
505	char type_in, type_out;
506	const char *istream_spec = NULL, *ostream_spec = NULL;
507	int idx_in = 0, idx_out = 0;
508
509	parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
510	parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
511
512	if (!ic) {
513	if (type_out == 'g' || !*outspec)
514	o->metadata_global_manual = 1;
515	if (type_out == 's' || !*outspec)
516	o->metadata_streams_manual = 1;
517	if (type_out == 'c' || !*outspec)
518	o->metadata_chapters_manual = 1;
519	return 0;
520	}
521
522	if (type_in == 'g' || type_out == 'g')
523	o->metadata_global_manual = 1;
524	if (type_in == 's' || type_out == 's')
525	o->metadata_streams_manual = 1;
526	if (type_in == 'c' || type_out == 'c')
527	o->metadata_chapters_manual = 1;
528
529	/* ic is NULL when just disabling automatic mappings */
530	if (!ic)
531	return 0;
532
533	#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
534	if ((index) < 0 || (index) >= (nb_elems)) {\
535	av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
536	(desc), (index));\
537	exit_program(1);\
538	}
539
540	#define SET_DICT(type, meta, context, index)\
541	switch (type) {\
542	case 'g':\
543	meta = &context->metadata;\
544	break;\
545	case 'c':\
546	METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
547	meta = &context->chapters[index]->metadata;\
548	break;\
549	case 'p':\
550	METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
551	meta = &context->programs[index]->metadata;\
552	break;\
553	case 's':\
554	break; /* handled separately below */ \
555	default: av_assert0(0);\
556	}\
557
558	SET_DICT(type_in, meta_in, ic, idx_in);
559	SET_DICT(type_out, meta_out, oc, idx_out);
560
561	/* for input streams choose first matching stream */
562	if (type_in == 's') {
563	for (i = 0; i < ic->nb_streams; i++) {
564	if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
565	meta_in = &ic->streams[i]->metadata;
566	break;
567	} else if (ret < 0)
568	exit_program(1);
569	}
570	if (!meta_in) {
571	av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
572	exit_program(1);
573	}
574	}
575
576	if (type_out == 's') {
577	for (i = 0; i < oc->nb_streams; i++) {
578	if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
579	meta_out = &oc->streams[i]->metadata;
580	av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
581	} else if (ret < 0)
582	exit_program(1);
583	}
584	} else
585	av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
586
587	return 0;
588	}
589
590	static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
591	{
592	OptionsContext *o = optctx;
593	char buf[128];
594	int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
595	struct tm time = *gmtime((time_t*)&recording_timestamp);
596	if (!strftime(buf, sizeof(buf), "creation_time=%Y-%m-%dT%H:%M:%S%z", &time))
597	return -1;
598	parse_option(o, "metadata", buf, options);
599
600	av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
601	"tag instead.\n", opt);
602	return 0;
603	}
604
605	static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
606	{
607	const AVCodecDescriptor *desc;
608	const char *codec_string = encoder ? "encoder" : "decoder";
609	AVCodec *codec;
610
611	codec = encoder ?
612	avcodec_find_encoder_by_name(name) :
613	avcodec_find_decoder_by_name(name);
614
615	if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
616	codec = encoder ? avcodec_find_encoder(desc->id) :
617	avcodec_find_decoder(desc->id);
618	if (codec)
619	av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
620	codec_string, codec->name, desc->name);
621	}
622
623	if (!codec) {
624	av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
625	exit_program(1);
626	}
627	if (codec->type != type) {
628	av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
629	exit_program(1);
630	}
631	return codec;
632	}
633
634	static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
635	{
636	char *codec_name = NULL;
637
638	MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
639	if (codec_name) {
640	AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
641	st->codecpar->codec_id = codec->id;
642	return codec;
643	} else
644	return avcodec_find_decoder(st->codecpar->codec_id);
645	}
646
647	/* Add all the streams from the given input file to the global
648	* list of input streams. */
649	static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
650	{
651	int i, ret;
652
653	for (i = 0; i < ic->nb_streams; i++) {
654	AVStream *st = ic->streams[i];
655	AVCodecParameters *par = st->codecpar;
656	InputStream *ist = av_mallocz(sizeof(*ist));
657	char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
658	char *hwaccel_output_format = NULL;
659	char *codec_tag = NULL;
660	char *next;
661	char *discard_str = NULL;
662	const AVClass *cc = avcodec_get_class();
663	const AVOption *discard_opt = av_opt_find(&cc, "skip_frame", NULL, 0, 0);
664
665	if (!ist)
666	exit_program(1);
667
668	GROW_ARRAY(input_streams, nb_input_streams);
669	input_streams[nb_input_streams - 1] = ist;
670
671	ist->st = st;
672	ist->file_index = nb_input_files;
673	ist->discard = 1;
674	st->discard = AVDISCARD_ALL;
675	ist->nb_samples = 0;
676	ist->min_pts = INT64_MAX;
677	ist->max_pts = INT64_MIN;
678
679	ist->ts_scale = 1.0;
680	MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
681
682	ist->autorotate = 1;
683	MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
684
685	MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
686	if (codec_tag) {
687	uint32_t tag = strtol(codec_tag, &next, 0);
688	if (*next)
689	tag = AV_RL32(codec_tag);
690	st->codecpar->codec_tag = tag;
691	}
692
693	ist->dec = choose_decoder(o, ic, st);
694	ist->decoder_opts = filter_codec_opts(o->g->codec_opts, ist->st->codecpar->codec_id, ic, st, ist->dec);
695
696	ist->reinit_filters = -1;
697	MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
698
699	MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
700	ist->user_set_discard = AVDISCARD_NONE;
701	if (discard_str && av_opt_eval_int(&cc, discard_opt, discard_str, &ist->user_set_discard) < 0) {
702	av_log(NULL, AV_LOG_ERROR, "Error parsing discard %s.\n",
703	discard_str);
704	exit_program(1);
705	}
706
707	ist->filter_in_rescale_delta_last = AV_NOPTS_VALUE;
708
709	ist->dec_ctx = avcodec_alloc_context3(ist->dec);
710	if (!ist->dec_ctx) {
711	av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
712	exit_program(1);
713	}
714
715	ret = avcodec_parameters_to_context(ist->dec_ctx, par);
716	if (ret < 0) {
717	av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
718	exit_program(1);
719	}
720
721	switch (par->codec_type) {
722	case AVMEDIA_TYPE_VIDEO:
723	if(!ist->dec)
724	ist->dec = avcodec_find_decoder(par->codec_id);
725	#if FF_API_EMU_EDGE
726	if (av_codec_get_lowres(st->codec)) {
727	av_codec_set_lowres(ist->dec_ctx, av_codec_get_lowres(st->codec));
728	ist->dec_ctx->width = st->codec->width;
729	ist->dec_ctx->height = st->codec->height;
730	ist->dec_ctx->coded_width = st->codec->coded_width;
731	ist->dec_ctx->coded_height = st->codec->coded_height;
732	ist->dec_ctx->flags |= CODEC_FLAG_EMU_EDGE;
733	}
734	#endif
735
736	// avformat_find_stream_info() doesn't set this for us anymore.
737	ist->dec_ctx->framerate = st->avg_frame_rate;
738
739	MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
740	if (framerate && av_parse_video_rate(&ist->framerate,
741	framerate) < 0) {
742	av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
743	framerate);
744	exit_program(1);
745	}
746
747	ist->top_field_first = -1;
748	MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
749
750	MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
751	if (hwaccel) {
752	if (!strcmp(hwaccel, "none"))
753	ist->hwaccel_id = HWACCEL_NONE;
754	else if (!strcmp(hwaccel, "auto"))
755	ist->hwaccel_id = HWACCEL_AUTO;
756	else {
757	int i;
758	for (i = 0; hwaccels[i].name; i++) {
759	if (!strcmp(hwaccels[i].name, hwaccel)) {
760	ist->hwaccel_id = hwaccels[i].id;
761	break;
762	}
763	}
764
765	if (!ist->hwaccel_id) {
766	av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
767	hwaccel);
768	av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
769	for (i = 0; hwaccels[i].name; i++)
770	av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
771	av_log(NULL, AV_LOG_FATAL, "\n");
772	exit_program(1);
773	}
774	}
775	}
776
777	MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
778	if (hwaccel_device) {
779	ist->hwaccel_device = av_strdup(hwaccel_device);
780	if (!ist->hwaccel_device)
781	exit_program(1);
782	}
783
784	MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
785	hwaccel_output_format, ic, st);
786	if (hwaccel_output_format) {
787	ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
788	if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
789	av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
790	"format: %s", hwaccel_output_format);
791	}
792	} else {
793	ist->hwaccel_output_format = AV_PIX_FMT_NONE;
794	}
795
796	ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
797
798	break;
799	case AVMEDIA_TYPE_AUDIO:
800	ist->guess_layout_max = INT_MAX;
801	MATCH_PER_STREAM_OPT(guess_layout_max, i, ist->guess_layout_max, ic, st);
802	guess_input_channel_layout(ist);
803	break;
804	case AVMEDIA_TYPE_DATA:
805	case AVMEDIA_TYPE_SUBTITLE: {
806	char *canvas_size = NULL;
807	if(!ist->dec)
808	ist->dec = avcodec_find_decoder(par->codec_id);
809	MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
810	MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
811	if (canvas_size &&
812	av_parse_video_size(&ist->dec_ctx->width, &ist->dec_ctx->height, canvas_size) < 0) {
813	av_log(NULL, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
814	exit_program(1);
815	}
816	break;
817	}
818	case AVMEDIA_TYPE_ATTACHMENT:
819	case AVMEDIA_TYPE_UNKNOWN:
820	break;
821	default:
822	abort();
823	}
824
825	ret = avcodec_parameters_from_context(par, ist->dec_ctx);
826	if (ret < 0) {
827	av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
828	exit_program(1);
829	}
830	}
831	}
832
833	static void assert_file_overwrite(const char *filename)
834	{
835	if (file_overwrite && no_file_overwrite) {
836	fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
837	exit_program(1);
838	}
839
840	if (!file_overwrite) {
841	const char *proto_name = avio_find_protocol_name(filename);
842	if (proto_name && !strcmp(proto_name, "file") && avio_check(filename, 0) == 0) {
843	if (stdin_interaction && !no_file_overwrite) {
844	fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
845	fflush(stderr);
846	term_exit();
847	signal(SIGINT, SIG_DFL);
848	if (!read_yesno()) {
849	av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
850	exit_program(1);
851	}
852	term_init();
853	}
854	else {
855	av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
856	exit_program(1);
857	}
858	}
859	}
860	}
861
862	static void dump_attachment(AVStream *st, const char *filename)
863	{
864	int ret;
865	AVIOContext *out = NULL;
866	AVDictionaryEntry *e;
867
868	if (!st->codecpar->extradata_size) {
869	av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
870	nb_input_files - 1, st->index);
871	return;
872	}
873	if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
874	filename = e->value;
875	if (!*filename) {
876	av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
877	"in stream #%d:%d.\n", nb_input_files - 1, st->index);
878	exit_program(1);
879	}
880
881	assert_file_overwrite(filename);
882
883	if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
884	av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
885	filename);
886	exit_program(1);
887	}
888
889	avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
890	avio_flush(out);
891	avio_close(out);
892	}
893
894	static int open_input_file(OptionsContext *o, const char *filename)
895	{
896	InputFile *f;
897	AVFormatContext *ic;
898	AVInputFormat *file_iformat = NULL;
899	int err, i, ret;
900	int64_t timestamp;
901	AVDictionary **opts;
902	AVDictionary *unused_opts = NULL;
903	AVDictionaryEntry *e = NULL;
904	int orig_nb_streams; // number of streams before avformat_find_stream_info
905	char * video_codec_name = NULL;
906	char * audio_codec_name = NULL;
907	char *subtitle_codec_name = NULL;
908	char * data_codec_name = NULL;
909	int scan_all_pmts_set = 0;
910
911	if (o->format) {
912	if (!(file_iformat = av_find_input_format(o->format))) {
913	av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
914	exit_program(1);
915	}
916	}
917
918	if (!strcmp(filename, "-"))
919	filename = "pipe:";
920
921	stdin_interaction &= strncmp(filename, "pipe:", 5) &&
922	strcmp(filename, "/dev/stdin");
923
924	/* get default parameters from command line */
925	ic = avformat_alloc_context();
926	if (!ic) {
927	print_error(filename, AVERROR(ENOMEM));
928	exit_program(1);
929	}
930	ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
931	if (o->nb_audio_sample_rate) {
932	av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i, 0);
933	}
934	if (o->nb_audio_channels) {
935	/* because we set audio_channels based on both the "ac" and
936	* "channel_layout" options, we need to check that the specified
937	* demuxer actually has the "channels" option before setting it */
938	if (file_iformat && file_iformat->priv_class &&
939	av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
940	AV_OPT_SEARCH_FAKE_OBJ)) {
941	av_dict_set_int(&o->g->format_opts, "channels", o->audio_channels[o->nb_audio_channels - 1].u.i, 0);
942	}
943	}
944	if (o->nb_frame_rates) {
945	/* set the format-level framerate option;
946	* this is important for video grabbers, e.g. x11 */
947	if (file_iformat && file_iformat->priv_class &&
948	av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
949	AV_OPT_SEARCH_FAKE_OBJ)) {
950	av_dict_set(&o->g->format_opts, "framerate",
951	o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
952	}
953	}
954	if (o->nb_frame_sizes) {
955	av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
956	}
957	if (o->nb_frame_pix_fmts)
958	av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
959
960	MATCH_PER_TYPE_OPT(codec_names, str, video_codec_name, ic, "v");
961	MATCH_PER_TYPE_OPT(codec_names, str, audio_codec_name, ic, "a");
962	MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
963	MATCH_PER_TYPE_OPT(codec_names, str, data_codec_name, ic, "d");
964
965	ic->video_codec_id = video_codec_name ?
966	find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : AV_CODEC_ID_NONE;
967	ic->audio_codec_id = audio_codec_name ?
968	find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : AV_CODEC_ID_NONE;
969	ic->subtitle_codec_id= subtitle_codec_name ?
970	find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
971	ic->data_codec_id = data_codec_name ?
972	find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0)->id : AV_CODEC_ID_NONE;
973
974	if (video_codec_name)
975	av_format_set_video_codec (ic, find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0));
976	if (audio_codec_name)
977	av_format_set_audio_codec (ic, find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0));
978	if (subtitle_codec_name)
979	av_format_set_subtitle_codec(ic, find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0));
980	if (data_codec_name)
981	av_format_set_data_codec(ic, find_codec_or_die(data_codec_name, AVMEDIA_TYPE_DATA, 0));
982
983	ic->flags |= AVFMT_FLAG_NONBLOCK;
984	ic->interrupt_callback = int_cb;
985
986	if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
987	av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
988	scan_all_pmts_set = 1;
989	}
990	/* open the input file with generic avformat function */
991	err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
992	if (err < 0) {
993	print_error(filename, err);
994	if (err == AVERROR_PROTOCOL_NOT_FOUND)
995	av_log(NULL, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
996	exit_program(1);
997	}
998	if (scan_all_pmts_set)
999	av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1000	remove_avoptions(&o->g->format_opts, o->g->codec_opts);
1001	assert_avoptions(o->g->format_opts);
1002
1003	/* apply forced codec ids */
1004	for (i = 0; i < ic->nb_streams; i++)
1005	choose_decoder(o, ic, ic->streams[i]);
1006
1007	/* Set AVCodecContext options for avformat_find_stream_info */
1008	opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
1009	orig_nb_streams = ic->nb_streams;
1010
1011	/* If not enough info to get the stream parameters, we decode the
1012	first frames to get it. (used in mpeg case for example) */
1013	ret = avformat_find_stream_info(ic, opts);
1014	if (ret < 0) {
1015	av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
1016	if (ic->nb_streams == 0) {
1017	avformat_close_input(&ic);
1018	exit_program(1);
1019	}
1020	}
1021
1022	if (o->start_time_eof != AV_NOPTS_VALUE) {
1023	if (ic->duration>0) {
1024	o->start_time = o->start_time_eof + ic->duration;
1025	} else
1026	av_log(NULL, AV_LOG_WARNING, "Cannot use -sseof, duration of %s not known\n", filename);
1027	}
1028	timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
1029	/* add the stream start time */
1030	if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1031	timestamp += ic->start_time;
1032
1033	/* if seeking requested, we execute it */
1034	if (o->start_time != AV_NOPTS_VALUE) {
1035	int64_t seek_timestamp = timestamp;
1036
1037	if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1038	int dts_heuristic = 0;
1039	for (i=0; i<ic->nb_streams; i++) {
1040	const AVCodecParameters *par = ic->streams[i]->codecpar;
1041	if (par->video_delay)
1042	dts_heuristic = 1;
1043	}
1044	if (dts_heuristic) {
1045	seek_timestamp -= 3*AV_TIME_BASE / 23;
1046	}
1047	}
1048	ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1049	if (ret < 0) {
1050	av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
1051	filename, (double)timestamp / AV_TIME_BASE);
1052	}
1053	}
1054
1055	/* update the current parameters so that they match the one of the input stream */
1056	add_input_streams(o, ic);
1057
1058	/* dump the file content */
1059	av_dump_format(ic, nb_input_files, filename, 0);
1060
1061	GROW_ARRAY(input_files, nb_input_files);
1062	f = av_mallocz(sizeof(*f));
1063	if (!f)
1064	exit_program(1);
1065	input_files[nb_input_files - 1] = f;
1066
1067	f->ctx = ic;
1068	f->ist_index = nb_input_streams - ic->nb_streams;
1069	f->start_time = o->start_time;
1070	f->recording_time = o->recording_time;
1071	f->input_ts_offset = o->input_ts_offset;
1072	f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1073	f->nb_streams = ic->nb_streams;
1074	f->rate_emu = o->rate_emu;
1075	f->accurate_seek = o->accurate_seek;
1076	f->loop = o->loop;
1077	f->duration = 0;
1078	f->time_base = (AVRational){ 1, 1 };
1079	#if HAVE_PTHREADS
1080	f->thread_queue_size = o->thread_queue_size > 0 ? o->thread_queue_size : 8;
1081	#endif
1082
1083	/* check if all codec options have been used */
1084	unused_opts = strip_specifiers(o->g->codec_opts);
1085	for (i = f->ist_index; i < nb_input_streams; i++) {
1086	e = NULL;
1087	while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
1088	AV_DICT_IGNORE_SUFFIX)))
1089	av_dict_set(&unused_opts, e->key, NULL, 0);
1090	}
1091
1092	e = NULL;
1093	while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1094	const AVClass *class = avcodec_get_class();
1095	const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1096	AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1097	const AVClass *fclass = avformat_get_class();
1098	const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1099	AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1100	if (!option || foption)
1101	continue;
1102
1103
1104	if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1105	av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1106	"input file #%d (%s) is not a decoding option.\n", e->key,
1107	option->help ? option->help : "", nb_input_files - 1,
1108	filename);
1109	exit_program(1);
1110	}
1111
1112	av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1113	"input file #%d (%s) has not been used for any stream. The most "
1114	"likely reason is either wrong type (e.g. a video option with "
1115	"no video streams) or that it is a private option of some decoder "
1116	"which was not actually used for any stream.\n", e->key,
1117	option->help ? option->help : "", nb_input_files - 1, filename);
1118	}
1119	av_dict_free(&unused_opts);
1120
1121	for (i = 0; i < o->nb_dump_attachment; i++) {
1122	int j;
1123
1124	for (j = 0; j < ic->nb_streams; j++) {
1125	AVStream *st = ic->streams[j];
1126
1127	if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
1128	dump_attachment(st, o->dump_attachment[i].u.str);
1129	}
1130	}
1131
1132	for (i = 0; i < orig_nb_streams; i++)
1133	av_dict_free(&opts[i]);
1134	av_freep(&opts);
1135
1136	input_stream_potentially_available = 1;
1137
1138	return 0;
1139	}
1140
1141	static uint8_t *get_line(AVIOContext *s)
1142	{
1143	AVIOContext *line;
1144	uint8_t *buf;
1145	char c;
1146
1147	if (avio_open_dyn_buf(&line) < 0) {
1148	av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
1149	exit_program(1);
1150	}
1151
1152	while ((c = avio_r8(s)) && c != '\n')
1153	avio_w8(line, c);
1154	avio_w8(line, 0);
1155	avio_close_dyn_buf(line, &buf);
1156
1157	return buf;
1158	}
1159
1160	static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
1161	{
1162	int i, ret = -1;
1163	char filename[1000];
1164	const char *base[3] = { getenv("AVCONV_DATADIR"),
1165	getenv("HOME"),
1166	AVCONV_DATADIR,
1167	};
1168
1169	for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
1170	if (!base[i])
1171	continue;
1172	if (codec_name) {
1173	snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
1174	i != 1 ? "" : "/.avconv", codec_name, preset_name);
1175	ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1176	}
1177	if (ret < 0) {
1178	snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
1179	i != 1 ? "" : "/.avconv", preset_name);
1180	ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
1181	}
1182	}
1183	return ret;
1184	}
1185
1186	static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
1187	{
1188	enum AVMediaType type = ost->st->codecpar->codec_type;
1189	char *codec_name = NULL;
1190
1191	if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
1192	MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
1193	if (!codec_name) {
1194	ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
1195	NULL, ost->st->codecpar->codec_type);
1196	ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
1197	if (!ost->enc) {
1198	av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
1199	"output stream #%d:%d. Default encoder for format %s (codec %s) is "
1200	"probably disabled. Please choose an encoder manually.\n",
1201	ost->file_index, ost->index, s->oformat->name,
1202	avcodec_get_name(ost->st->codecpar->codec_id));
1203	return AVERROR_ENCODER_NOT_FOUND;
1204	}
1205	} else if (!strcmp(codec_name, "copy"))
1206	ost->stream_copy = 1;
1207	else {
1208	ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
1209	ost->st->codecpar->codec_id = ost->enc->id;
1210	}
1211	ost->encoding_needed = !ost->stream_copy;
1212	} else {
1213	/* no encoding supported for other media types */
1214	ost->stream_copy = 1;
1215	ost->encoding_needed = 0;
1216	}
1217
1218	return 0;
1219	}
1220
1221	static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
1222	{
1223	OutputStream *ost;
1224	AVStream *st = avformat_new_stream(oc, NULL);
1225	int idx = oc->nb_streams - 1, ret = 0;
1226	const char *bsfs = NULL, *time_base = NULL;
1227	char *next, *codec_tag = NULL;
1228	double qscale = -1;
1229	int i;
1230
1231	if (!st) {
1232	av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
1233	exit_program(1);
1234	}
1235
1236	if (oc->nb_streams - 1 < o->nb_streamid_map)
1237	st->id = o->streamid_map[oc->nb_streams - 1];
1238
1239	GROW_ARRAY(output_streams, nb_output_streams);
1240	if (!(ost = av_mallocz(sizeof(*ost))))
1241	exit_program(1);
1242	output_streams[nb_output_streams - 1] = ost;
1243
1244	ost->file_index = nb_output_files - 1;
1245	ost->index = idx;
1246	ost->st = st;
1247	st->codecpar->codec_type = type;
1248
1249	ret = choose_encoder(o, oc, ost);
1250	if (ret < 0) {
1251	av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
1252	"%d:%d\n", ost->file_index, ost->index);
1253	exit_program(1);
1254	}
1255
1256	ost->enc_ctx = avcodec_alloc_context3(ost->enc);
1257	if (!ost->enc_ctx) {
1258	av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
1259	exit_program(1);
1260	}
1261	ost->enc_ctx->codec_type = type;
1262
1263	ost->ref_par = avcodec_parameters_alloc();
1264	if (!ost->ref_par) {
1265	av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding parameters.\n");
1266	exit_program(1);
1267	}
1268
1269	if (ost->enc) {
1270	AVIOContext *s = NULL;
1271	char *buf = NULL, *arg = NULL, *preset = NULL;
1272
1273	ost->encoder_opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
1274
1275	MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
1276	if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
1277	do {
1278	buf = get_line(s);
1279	if (!buf[0] || buf[0] == '#') {
1280	av_free(buf);
1281	continue;
1282	}
1283	if (!(arg = strchr(buf, '='))) {
1284	av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1285	exit_program(1);
1286	}
1287	*arg++ = 0;
1288	av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1289	av_free(buf);
1290	} while (!s->eof_reached);
1291	avio_closep(&s);
1292	}
1293	if (ret) {
1294	av_log(NULL, AV_LOG_FATAL,
1295	"Preset %s specified for stream %d:%d, but could not be opened.\n",
1296	preset, ost->file_index, ost->index);
1297	exit_program(1);
1298	}
1299	} else {
1300	ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1301	}
1302
1303	MATCH_PER_STREAM_OPT(time_bases, str, time_base, oc, st);
1304	if (time_base) {
1305	AVRational q;
1306	if (av_parse_ratio(&q, time_base, INT_MAX, 0, NULL) < 0 ||
1307	q.num <= 0 || q.den <= 0) {
1308	av_log(NULL, AV_LOG_FATAL, "Invalid time base: %s\n", time_base);
1309	exit_program(1);
1310	}
1311	st->time_base = q;
1312	}
1313
1314	ost->max_frames = INT64_MAX;
1315	MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1316	for (i = 0; i<o->nb_max_frames; i++) {
1317	char *p = o->max_frames[i].specifier;
1318	if (!*p && type != AVMEDIA_TYPE_VIDEO) {
1319	av_log(NULL, AV_LOG_WARNING, "Applying unspecific -frames to non video streams, maybe you meant -vframes ?\n");
1320	break;
1321	}
1322	}
1323
1324	ost->copy_prior_start = -1;
1325	MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
1326
1327	MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1328	while (bsfs && *bsfs) {
1329	const AVBitStreamFilter *filter;
1330	char *bsf, *bsf_options_str, *bsf_name;
1331
1332	bsf = av_get_token(&bsfs, ",");
1333	if (!bsf)
1334	exit_program(1);
1335	bsf_name = av_strtok(bsf, "=", &bsf_options_str);
1336	if (!bsf_name)
1337	exit_program(1);
1338
1339	filter = av_bsf_get_by_name(bsf_name);
1340	if (!filter) {
1341	av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1342	exit_program(1);
1343	}
1344
1345	ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1346	ost->nb_bitstream_filters + 1,
1347	sizeof(*ost->bsf_ctx));
1348	if (!ost->bsf_ctx)
1349	exit_program(1);
1350
1351	ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1352	if (ret < 0) {
1353	av_log(NULL, AV_LOG_ERROR, "Error allocating a bitstream filter context\n");
1354	exit_program(1);
1355	}
1356
1357	ost->nb_bitstream_filters++;
1358
1359	if (bsf_options_str && filter->priv_class) {
1360	const AVOption *opt = av_opt_next(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, NULL);
1361	const char * shorthand[2] = {NULL};
1362
1363	if (opt)
1364	shorthand[0] = opt->name;
1365
1366	ret = av_opt_set_from_string(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, bsf_options_str, shorthand, "=", ":");
1367	if (ret < 0) {
1368	av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1369	exit_program(1);
1370	}
1371	}
1372	av_freep(&bsf);
1373
1374	if (*bsfs)
1375	bsfs++;
1376	}
1377	if (ost->nb_bitstream_filters) {
1378	ost->bsf_extradata_updated = av_mallocz_array(ost->nb_bitstream_filters, sizeof(*ost->bsf_extradata_updated));
1379	if (!ost->bsf_extradata_updated) {
1380	av_log(NULL, AV_LOG_FATAL, "Bitstream filter memory allocation failed\n");
1381	exit_program(1);
1382	}
1383	}
1384
1385	MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1386	if (codec_tag) {
1387	uint32_t tag = strtol(codec_tag, &next, 0);
1388	if (*next)
1389	tag = AV_RL32(codec_tag);
1390	ost->st->codecpar->codec_tag =
1391	ost->enc_ctx->codec_tag = tag;
1392	}
1393
1394	MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1395	if (qscale >= 0) {
1396	ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1397	ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1398	}
1399
1400	MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1401	ost->disposition = av_strdup(ost->disposition);
1402
1403	ost->max_muxing_queue_size = 128;
1404	MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1405	ost->max_muxing_queue_size *= sizeof(AVPacket);
1406
1407	if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1408	ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1409
1410	av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1411
1412	av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1413	if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1414	av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1415
1416	av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1417
1418	ost->source_index = source_index;
1419	if (source_index >= 0) {
1420	ost->sync_ist = input_streams[source_index];
1421	input_streams[source_index]->discard = 0;
1422	input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1423	}
1424	ost->last_mux_dts = AV_NOPTS_VALUE;
1425
1426	ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1427	if (!ost->muxing_queue)
1428	exit_program(1);
1429
1430	return ost;
1431	}
1432
1433	static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1434	{
1435	int i;
1436	const char *p = str;
1437	for (i = 0;; i++) {
1438	dest[i] = atoi(p);
1439	if (i == 63)
1440	break;
1441	p = strchr(p, ',');
1442	if (!p) {
1443	av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1444	exit_program(1);
1445	}
1446	p++;
1447	}
1448	}
1449
1450	/* read file contents into a string */
1451	static uint8_t *read_file(const char *filename)
1452	{
1453	AVIOContext *pb = NULL;
1454	AVIOContext *dyn_buf = NULL;
1455	int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1456	uint8_t buf[1024], *str;
1457
1458	if (ret < 0) {
1459	av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1460	return NULL;
1461	}
1462
1463	ret = avio_open_dyn_buf(&dyn_buf);
1464	if (ret < 0) {
1465	avio_closep(&pb);
1466	return NULL;
1467	}
1468	while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1469	avio_write(dyn_buf, buf, ret);
1470	avio_w8(dyn_buf, 0);
1471	avio_closep(&pb);
1472
1473	ret = avio_close_dyn_buf(dyn_buf, &str);
1474	if (ret < 0)
1475	return NULL;
1476	return str;
1477	}
1478
1479	static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1480	OutputStream *ost)
1481	{
1482	AVStream *st = ost->st;
1483
1484	if (ost->filters_script && ost->filters) {
1485	av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1486	"output stream #%d:%d.\n", nb_output_files, st->index);
1487	exit_program(1);
1488	}
1489
1490	if (ost->filters_script)
1491	return read_file(ost->filters_script);
1492	else if (ost->filters)
1493	return av_strdup(ost->filters);
1494
1495	return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1496	"null" : "anull");
1497	}
1498
1499	static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1500	const OutputStream *ost, enum AVMediaType type)
1501	{
1502	if (ost->filters_script || ost->filters) {
1503	av_log(NULL, AV_LOG_ERROR,
1504	"%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1505	"Filtering and streamcopy cannot be used together.\n",
1506	ost->filters ? "Filtergraph" : "Filtergraph script",
1507	ost->filters ? ost->filters : ost->filters_script,
1508	av_get_media_type_string(type), ost->file_index, ost->index);
1509	exit_program(1);
1510	}
1511	}
1512
1513	static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1514	{
1515	AVStream *st;
1516	OutputStream *ost;
1517	AVCodecContext *video_enc;
1518	char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1519
1520	ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1521	st = ost->st;
1522	video_enc = ost->enc_ctx;
1523
1524	MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1525	if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1526	av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1527	exit_program(1);
1528	}
1529	if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1530	av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1531
1532	MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1533	if (frame_aspect_ratio) {
1534	AVRational q;
1535	if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1536	q.num <= 0 || q.den <= 0) {
1537	av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1538	exit_program(1);
1539	}
1540	ost->frame_aspect_ratio = q;
1541	}
1542
1543	MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1544	MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1545
1546	if (!ost->stream_copy) {
1547	const char *p = NULL;
1548	char *frame_size = NULL;
1549	char *frame_pix_fmt = NULL;
1550	char *intra_matrix = NULL, *inter_matrix = NULL;
1551	char *chroma_intra_matrix = NULL;
1552	int do_pass = 0;
1553	int i;
1554
1555	MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1556	if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1557	av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1558	exit_program(1);
1559	}
1560
1561	video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1562	MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1563	if (frame_pix_fmt && *frame_pix_fmt == '+') {
1564	ost->keep_pix_fmt = 1;
1565	if (!*++frame_pix_fmt)
1566	frame_pix_fmt = NULL;
1567	}
1568	if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1569	av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1570	exit_program(1);
1571	}
1572	st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1573
1574	if (intra_only)
1575	video_enc->gop_size = 0;
1576	MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1577	if (intra_matrix) {
1578	if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1579	av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1580	exit_program(1);
1581	}
1582	parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1583	}
1584	MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1585	if (chroma_intra_matrix) {
1586	uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1587	if (!p) {
1588	av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1589	exit_program(1);
1590	}
1591	av_codec_set_chroma_intra_matrix(video_enc, p);
1592	parse_matrix_coeffs(p, chroma_intra_matrix);
1593	}
1594	MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1595	if (inter_matrix) {
1596	if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1597	av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1598	exit_program(1);
1599	}
1600	parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1601	}
1602
1603	MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1604	for (i = 0; p; i++) {
1605	int start, end, q;
1606	int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1607	if (e != 3) {
1608	av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1609	exit_program(1);
1610	}
1611	video_enc->rc_override =
1612	av_realloc_array(video_enc->rc_override,
1613	i + 1, sizeof(RcOverride));
1614	if (!video_enc->rc_override) {
1615	av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1616	exit_program(1);
1617	}
1618	video_enc->rc_override[i].start_frame = start;
1619	video_enc->rc_override[i].end_frame = end;
1620	if (q > 0) {
1621	video_enc->rc_override[i].qscale = q;
1622	video_enc->rc_override[i].quality_factor = 1.0;
1623	}
1624	else {
1625	video_enc->rc_override[i].qscale = 0;
1626	video_enc->rc_override[i].quality_factor = -q/100.0;
1627	}
1628	p = strchr(p, '/');
1629	if (p) p++;
1630	}
1631	video_enc->rc_override_count = i;
1632
1633	if (do_psnr)
1634	video_enc->flags|= AV_CODEC_FLAG_PSNR;
1635
1636	/* two pass mode */
1637	MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1638	if (do_pass) {
1639	if (do_pass & 1) {
1640	video_enc->flags |= AV_CODEC_FLAG_PASS1;
1641	av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1642	}
1643	if (do_pass & 2) {
1644	video_enc->flags |= AV_CODEC_FLAG_PASS2;
1645	av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1646	}
1647	}
1648
1649	MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1650	if (ost->logfile_prefix &&
1651	!(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1652	exit_program(1);
1653
1654	if (do_pass) {
1655	char logfilename[1024];
1656	FILE *f;
1657
1658	snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1659	ost->logfile_prefix ? ost->logfile_prefix :
1660	DEFAULT_PASS_LOGFILENAME_PREFIX,
1661	i);
1662	if (!strcmp(ost->enc->name, "libx264")) {
1663	av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1664	} else {
1665	if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1666	char *logbuffer = read_file(logfilename);
1667
1668	if (!logbuffer) {
1669	av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1670	logfilename);
1671	exit_program(1);
1672	}
1673	video_enc->stats_in = logbuffer;
1674	}
1675	if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1676	f = av_fopen_utf8(logfilename, "wb");
1677	if (!f) {
1678	av_log(NULL, AV_LOG_FATAL,
1679	"Cannot write log file '%s' for pass-1 encoding: %s\n",
1680	logfilename, strerror(errno));
1681	exit_program(1);
1682	}
1683	ost->logfile = f;
1684	}
1685	}
1686	}
1687
1688	MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1689	if (ost->forced_keyframes)
1690	ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1691
1692	MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1693
1694	ost->top_field_first = -1;
1695	MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1696
1697
1698	ost->avfilter = get_ost_filters(o, oc, ost);
1699	if (!ost->avfilter)
1700	exit_program(1);
1701	} else {
1702	MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1703	}
1704
1705	if (ost->stream_copy)
1706	check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1707
1708	return ost;
1709	}
1710
1711	static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1712	{
1713	int n;
1714	AVStream *st;
1715	OutputStream *ost;
1716	AVCodecContext *audio_enc;
1717
1718	ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1719	st = ost->st;
1720
1721	audio_enc = ost->enc_ctx;
1722	audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1723
1724	MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1725	MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st);
1726
1727	if (!ost->stream_copy) {
1728	char *sample_fmt = NULL;
1729
1730	MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1731
1732	MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1733	if (sample_fmt &&
1734	(audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1735	av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1736	exit_program(1);
1737	}
1738
1739	MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1740
1741	MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1742	ost->apad = av_strdup(ost->apad);
1743
1744	ost->avfilter = get_ost_filters(o, oc, ost);
1745	if (!ost->avfilter)
1746	exit_program(1);
1747
1748	/* check for channel mapping for this audio stream */
1749	for (n = 0; n < o->nb_audio_channel_maps; n++) {
1750	AudioChannelMap *map = &o->audio_channel_maps[n];
1751	if ((map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
1752	(map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
1753	InputStream *ist;
1754
1755	if (map->channel_idx == -1) {
1756	ist = NULL;
1757	} else if (ost->source_index < 0) {
1758	av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1759	ost->file_index, ost->st->index);
1760	continue;
1761	} else {
1762	ist = input_streams[ost->source_index];
1763	}
1764
1765	if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1766	if (av_reallocp_array(&ost->audio_channels_map,
1767	ost->audio_channels_mapped + 1,
1768	sizeof(*ost->audio_channels_map)
1769	) < 0 )
1770	exit_program(1);
1771
1772	ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1773	}
1774	}
1775	}
1776	}
1777
1778	if (ost->stream_copy)
1779	check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1780
1781	return ost;
1782	}
1783
1784	static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1785	{
1786	OutputStream *ost;
1787
1788	ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1789	if (!ost->stream_copy) {
1790	av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1791	exit_program(1);
1792	}
1793
1794	return ost;
1795	}
1796
1797	static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1798	{
1799	OutputStream *ost;
1800
1801	ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1802	if (!ost->stream_copy) {
1803	av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1804	exit_program(1);
1805	}
1806
1807	return ost;
1808	}
1809
1810	static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1811	{
1812	OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1813	ost->stream_copy = 1;
1814	ost->finished = 1;
1815	return ost;
1816	}
1817
1818	static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1819	{
1820	AVStream *st;
1821	OutputStream *ost;
1822	AVCodecContext *subtitle_enc;
1823
1824	ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1825	st = ost->st;
1826	subtitle_enc = ost->enc_ctx;
1827
1828	subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1829
1830	MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1831
1832	if (!ost->stream_copy) {
1833	char *frame_size = NULL;
1834
1835	MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1836	if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1837	av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1838	exit_program(1);
1839	}
1840	}
1841
1842	return ost;
1843	}
1844
1845	/* arg format is "output-stream-index:streamid-value". */
1846	static int opt_streamid(void *optctx, const char *opt, const char *arg)
1847	{
1848	OptionsContext *o = optctx;
1849	int idx;
1850	char *p;
1851	char idx_str[16];
1852
1853	av_strlcpy(idx_str, arg, sizeof(idx_str));
1854	p = strchr(idx_str, ':');
1855	if (!p) {
1856	av_log(NULL, AV_LOG_FATAL,
1857	"Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1858	arg, opt);
1859	exit_program(1);
1860	}
1861	*p++ = '\0';
1862	idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1863	o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1864	o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1865	return 0;
1866	}
1867
1868	static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1869	{
1870	AVFormatContext *is = ifile->ctx;
1871	AVFormatContext *os = ofile->ctx;
1872	AVChapter **tmp;
1873	int i;
1874
1875	tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1876	if (!tmp)
1877	return AVERROR(ENOMEM);
1878	os->chapters = tmp;
1879
1880	for (i = 0; i < is->nb_chapters; i++) {
1881	AVChapter *in_ch = is->chapters[i], *out_ch;
1882	int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1883	int64_t ts_off = av_rescale_q(start_time - ifile->ts_offset,
1884	AV_TIME_BASE_Q, in_ch->time_base);
1885	int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1886	av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1887
1888
1889	if (in_ch->end < ts_off)
1890	continue;
1891	if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1892	break;
1893
1894	out_ch = av_mallocz(sizeof(AVChapter));
1895	if (!out_ch)
1896	return AVERROR(ENOMEM);
1897
1898	out_ch->id = in_ch->id;
1899	out_ch->time_base = in_ch->time_base;
1900	out_ch->start = FFMAX(0, in_ch->start - ts_off);
1901	out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1902
1903	if (copy_metadata)
1904	av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1905
1906	os->chapters[os->nb_chapters++] = out_ch;
1907	}
1908	return 0;
1909	}
1910
1911	static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1912	{
1913	int i, err;
1914	AVFormatContext *ic = avformat_alloc_context();
1915
1916	ic->flags |= AVFMT_FLAG_KEEP_SIDE_DATA;
1917	ic->interrupt_callback = int_cb;
1918	err = avformat_open_input(&ic, filename, NULL, NULL);
1919	if (err < 0)
1920	return err;
1921	/* copy stream format */
1922	for(i=0;i<ic->nb_streams;i++) {
1923	AVStream *st;
1924	OutputStream *ost;
1925	AVCodec *codec;
1926	const char *enc_config;
1927
1928	codec = avcodec_find_encoder(ic->streams[i]->codecpar->codec_id);
1929	if (!codec) {
1930	av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codecpar->codec_id);
1931	return AVERROR(EINVAL);
1932	}
1933	if (codec->type == AVMEDIA_TYPE_AUDIO)
1934	opt_audio_codec(o, "c:a", codec->name);
1935	else if (codec->type == AVMEDIA_TYPE_VIDEO)
1936	opt_video_codec(o, "c:v", codec->name);
1937	ost = new_output_stream(o, s, codec->type, -1);
1938	st = ost->st;
1939
1940	avcodec_get_context_defaults3(st->codec, codec);
1941	enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1942	if (enc_config) {
1943	AVDictionary *opts = NULL;
1944	av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1945	av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1946	av_dict_free(&opts);
1947	}
1948
1949	if (st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1950	choose_sample_fmt(st, codec);
1951	else if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1952	choose_pixel_fmt(st, st->codec, codec, st->codecpar->format);
1953	avcodec_copy_context(ost->enc_ctx, st->codec);
1954	if (enc_config)
1955	av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1956	}
1957
1958	avformat_close_input(&ic);
1959	return err;
1960	}
1961
1962	static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1963	AVFormatContext *oc)
1964	{
1965	OutputStream *ost;
1966
1967	switch (ofilter->type) {
1968	case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1969	case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1970	default:
1971	av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1972	"currently.\n");
1973	exit_program(1);
1974	}
1975
1976	ost->source_index = -1;
1977	ost->filter = ofilter;
1978
1979	ofilter->ost = ost;
1980	ofilter->format = -1;
1981
1982	if (ost->stream_copy) {
1983	av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1984	"which is fed from a complex filtergraph. Filtering and streamcopy "
1985	"cannot be used together.\n", ost->file_index, ost->index);
1986	exit_program(1);
1987	}
1988
1989	if (ost->avfilter && (ost->filters || ost->filters_script)) {
1990	const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1991	av_log(NULL, AV_LOG_ERROR,
1992	"%s '%s' was specified through the %s option "
1993	"for output stream %d:%d, which is fed from a complex filtergraph.\n"
1994	"%s and -filter_complex cannot be used together for the same stream.\n",
1995	ost->filters ? "Filtergraph" : "Filtergraph script",
1996	ost->filters ? ost->filters : ost->filters_script,
1997	opt, ost->file_index, ost->index, opt);
1998	exit_program(1);
1999	}
2000
2001	avfilter_inout_free(&ofilter->out_tmp);
2002	}
2003
2004	static int init_complex_filters(void)
2005	{
2006	int i, ret = 0;
2007
2008	for (i = 0; i < nb_filtergraphs; i++) {
2009	ret = init_complex_filtergraph(filtergraphs[i]);
2010	if (ret < 0)
2011	return ret;
2012	}
2013	return 0;
2014	}
2015
2016	static int open_output_file(OptionsContext *o, const char *filename)
2017	{
2018	AVFormatContext *oc;
2019	int i, j, err;
2020	AVOutputFormat *file_oformat;
2021	OutputFile *of;
2022	OutputStream *ost;
2023	InputStream *ist;
2024	AVDictionary *unused_opts = NULL;
2025	AVDictionaryEntry *e = NULL;
2026	int format_flags = 0;
2027
2028	if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
2029	o->stop_time = INT64_MAX;
2030	av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
2031	}
2032
2033	if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
2034	int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
2035	if (o->stop_time <= start_time) {
2036	av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
2037	exit_program(1);
2038	} else {
2039	o->recording_time = o->stop_time - start_time;
2040	}
2041	}
2042
2043	GROW_ARRAY(output_files, nb_output_files);
2044	of = av_mallocz(sizeof(*of));
2045	if (!of)
2046	exit_program(1);
2047	output_files[nb_output_files - 1] = of;
2048
2049	of->ost_index = nb_output_streams;
2050	of->recording_time = o->recording_time;
2051	of->start_time = o->start_time;
2052	of->limit_filesize = o->limit_filesize;
2053	of->shortest = o->shortest;
2054	av_dict_copy(&of->opts, o->g->format_opts, 0);
2055
2056	if (!strcmp(filename, "-"))
2057	filename = "pipe:";
2058
2059	err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
2060	if (!oc) {
2061	print_error(filename, err);
2062	exit_program(1);
2063	}
2064
2065	of->ctx = oc;
2066	if (o->recording_time != INT64_MAX)
2067	oc->duration = o->recording_time;
2068
2069	file_oformat= oc->oformat;
2070	oc->interrupt_callback = int_cb;
2071
2072	e = av_dict_get(o->g->format_opts, "fflags", NULL, 0);
2073	if (e) {
2074	const AVOption *o = av_opt_find(oc, "fflags", NULL, 0, 0);
2075	av_opt_eval_flags(oc, o, e->value, &format_flags);
2076	}
2077
2078	/* create streams for all unlabeled output pads */
2079	for (i = 0; i < nb_filtergraphs; i++) {
2080	FilterGraph *fg = filtergraphs[i];
2081	for (j = 0; j < fg->nb_outputs; j++) {
2082	OutputFilter *ofilter = fg->outputs[j];
2083
2084	if (!ofilter->out_tmp || ofilter->out_tmp->name)
2085	continue;
2086
2087	switch (ofilter->type) {
2088	case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
2089	case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
2090	case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
2091	}
2092	init_output_filter(ofilter, o, oc);
2093	}
2094	}
2095
2096	/* ffserver seeking with date=... needs a date reference */
2097	if (!strcmp(file_oformat->name, "ffm") &&
2098	!(format_flags & AVFMT_FLAG_BITEXACT) &&
2099	av_strstart(filename, "http:", NULL)) {
2100	int err = parse_option(o, "metadata", "creation_time=now", options);
2101	if (err < 0) {
2102	print_error(filename, err);
2103	exit_program(1);
2104	}
2105	}
2106
2107	if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
2108	av_strstart(filename, "http:", NULL)) {
2109	int j;
2110	/* special case for files sent to ffserver: we get the stream
2111	parameters from ffserver */
2112	int err = read_ffserver_streams(o, oc, filename);
2113	if (err < 0) {
2114	print_error(filename, err);
2115	exit_program(1);
2116	}
2117	for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
2118	ost = output_streams[j];
2119	for (i = 0; i < nb_input_streams; i++) {
2120	ist = input_streams[i];
2121	if(ist->st->codecpar->codec_type == ost->st->codecpar->codec_type){
2122	ost->sync_ist= ist;
2123	ost->source_index= i;
2124	if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
2125	if(ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
2126	ist->discard = 0;
2127	ist->st->discard = ist->user_set_discard;
2128	break;
2129	}
2130	}
2131	if(!ost->sync_ist){
2132	av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codecpar->codec_type));
2133	exit_program(1);
2134	}
2135	}
2136	} else if (!o->nb_stream_maps) {
2137	char *subtitle_codec_name = NULL;
2138	/* pick the "best" stream of each type */
2139
2140	/* video: highest resolution */
2141	if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2142	int area = 0, idx = -1;
2143	int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2144	for (i = 0; i < nb_input_streams; i++) {
2145	int new_area;
2146	ist = input_streams[i];
2147	new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames;
2148	if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2149	new_area = 1;
2150	if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2151	new_area > area) {
2152	if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2153	continue;
2154	area = new_area;
2155	idx = i;
2156	}
2157	}
2158	if (idx >= 0)
2159	new_video_stream(o, oc, idx);
2160	}
2161
2162	/* audio: most channels */
2163	if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2164	int best_score = 0, idx = -1;
2165	for (i = 0; i < nb_input_streams; i++) {
2166	int score;
2167	ist = input_streams[i];
2168	score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames;
2169	if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2170	score > best_score) {
2171	best_score = score;
2172	idx = i;
2173	}
2174	}
2175	if (idx >= 0)
2176	new_audio_stream(o, oc, idx);
2177	}
2178
2179	/* subtitles: pick first */
2180	MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2181	if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2182	for (i = 0; i < nb_input_streams; i++)
2183	if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2184	AVCodecDescriptor const *input_descriptor =
2185	avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2186	AVCodecDescriptor const *output_descriptor = NULL;
2187	AVCodec const *output_codec =
2188	avcodec_find_encoder(oc->oformat->subtitle_codec);
2189	int input_props = 0, output_props = 0;
2190	if (output_codec)
2191	output_descriptor = avcodec_descriptor_get(output_codec->id);
2192	if (input_descriptor)
2193	input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2194	if (output_descriptor)
2195	output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2196	if (subtitle_codec_name ||
2197	input_props & output_props ||
2198	// Map dvb teletext which has neither property to any output subtitle encoder
2199	input_descriptor && output_descriptor &&
2200	(!input_descriptor->props ||
2201	!output_descriptor->props)) {
2202	new_subtitle_stream(o, oc, i);
2203	break;
2204	}
2205	}
2206	}
2207	/* Data only if codec id match */
2208	if (!o->data_disable ) {
2209	enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2210	for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2211	if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2212	&& input_streams[i]->st->codecpar->codec_id == codec_id )
2213	new_data_stream(o, oc, i);
2214	}
2215	}
2216	} else {
2217	for (i = 0; i < o->nb_stream_maps; i++) {
2218	StreamMap *map = &o->stream_maps[i];
2219
2220	if (map->disabled)
2221	continue;
2222
2223	if (map->linklabel) {
2224	FilterGraph *fg;
2225	OutputFilter *ofilter = NULL;
2226	int j, k;
2227
2228	for (j = 0; j < nb_filtergraphs; j++) {
2229	fg = filtergraphs[j];
2230	for (k = 0; k < fg->nb_outputs; k++) {
2231	AVFilterInOut *out = fg->outputs[k]->out_tmp;
2232	if (out && !strcmp(out->name, map->linklabel)) {
2233	ofilter = fg->outputs[k];
2234	goto loop_end;
2235	}
2236	}
2237	}
2238	loop_end:
2239	if (!ofilter) {
2240	av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2241	"in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2242	exit_program(1);
2243	}
2244	init_output_filter(ofilter, o, oc);
2245	} else {
2246	int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2247
2248	ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2249	if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2250	continue;
2251	if(o-> audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2252	continue;
2253	if(o-> video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2254	continue;
2255	if(o-> data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2256	continue;
2257
2258	ost = NULL;
2259	switch (ist->st->codecpar->codec_type) {
2260	case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
2261	case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
2262	case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
2263	case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
2264	case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2265	case AVMEDIA_TYPE_UNKNOWN:
2266	if (copy_unknown_streams) {
2267	ost = new_unknown_stream (o, oc, src_idx);
2268	break;
2269	}
2270	default:
2271	av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2272	"Cannot map stream #%d:%d - unsupported type.\n",
2273	map->file_index, map->stream_index);
2274	if (!ignore_unknown_streams) {
2275	av_log(NULL, AV_LOG_FATAL,
2276	"If you want unsupported types ignored instead "
2277	"of failing, please use the -ignore_unknown option\n"
2278	"If you want them copied, please use -copy_unknown\n");
2279	exit_program(1);
2280	}
2281	}
2282	if (ost)
2283	ost->sync_ist = input_streams[ input_files[map->sync_file_index]->ist_index
2284	+ map->sync_stream_index];
2285	}
2286	}
2287	}
2288
2289	/* handle attached files */
2290	for (i = 0; i < o->nb_attachments; i++) {
2291	AVIOContext *pb;
2292	uint8_t *attachment;
2293	const char *p;
2294	int64_t len;
2295
2296	if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2297	av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2298	o->attachments[i]);
2299	exit_program(1);
2300	}
2301	if ((len = avio_size(pb)) <= 0) {
2302	av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2303	o->attachments[i]);
2304	exit_program(1);
2305	}
2306	if (!(attachment = av_malloc(len))) {
2307	av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2308	o->attachments[i]);
2309	exit_program(1);
2310	}
2311	avio_read(pb, attachment, len);
2312
2313	ost = new_attachment_stream(o, oc, -1);
2314	ost->stream_copy = 0;
2315	ost->attachment_filename = o->attachments[i];
2316	ost->st->codecpar->extradata = attachment;
2317	ost->st->codecpar->extradata_size = len;
2318
2319	p = strrchr(o->attachments[i], '/');
2320	av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2321	avio_closep(&pb);
2322	}
2323
2324	#if FF_API_LAVF_AVCTX
2325	for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2326	AVDictionaryEntry *e;
2327	ost = output_streams[i];
2328
2329	if ((ost->stream_copy || ost->attachment_filename)
2330	&& (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2331	&& (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2332	if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2333	exit_program(1);
2334	}
2335	#endif
2336
2337	if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2338	av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2339	av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2340	exit_program(1);
2341	}
2342
2343	/* check if all codec options have been used */
2344	unused_opts = strip_specifiers(o->g->codec_opts);
2345	for (i = of->ost_index; i < nb_output_streams; i++) {
2346	e = NULL;
2347	while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2348	AV_DICT_IGNORE_SUFFIX)))
2349	av_dict_set(&unused_opts, e->key, NULL, 0);
2350	}
2351
2352	e = NULL;
2353	while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2354	const AVClass *class = avcodec_get_class();
2355	const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2356	AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2357	const AVClass *fclass = avformat_get_class();
2358	const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2359	AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2360	if (!option || foption)
2361	continue;
2362
2363
2364	if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2365	av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2366	"output file #%d (%s) is not an encoding option.\n", e->key,
2367	option->help ? option->help : "", nb_output_files - 1,
2368	filename);
2369	exit_program(1);
2370	}
2371
2372	// gop_timecode is injected by generic code but not always used
2373	if (!strcmp(e->key, "gop_timecode"))
2374	continue;
2375
2376	av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2377	"output file #%d (%s) has not been used for any stream. The most "
2378	"likely reason is either wrong type (e.g. a video option with "
2379	"no video streams) or that it is a private option of some encoder "
2380	"which was not actually used for any stream.\n", e->key,
2381	option->help ? option->help : "", nb_output_files - 1, filename);
2382	}
2383	av_dict_free(&unused_opts);
2384
2385	/* set the decoding_needed flags and create simple filtergraphs */
2386	for (i = of->ost_index; i < nb_output_streams; i++) {
2387	OutputStream *ost = output_streams[i];
2388
2389	if (ost->encoding_needed && ost->source_index >= 0) {
2390	InputStream *ist = input_streams[ost->source_index];
2391	ist->decoding_needed |= DECODING_FOR_OST;
2392
2393	if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2394	ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2395	err = init_simple_filtergraph(ist, ost);
2396	if (err < 0) {
2397	av_log(NULL, AV_LOG_ERROR,
2398	"Error initializing a simple filtergraph between streams "
2399	"%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2400	nb_output_files - 1, ost->st->index);
2401	exit_program(1);
2402	}
2403	}
2404	}
2405
2406	/* set the filter output constraints */
2407	if (ost->filter) {
2408	OutputFilter *f = ost->filter;
2409	int count;
2410	switch (ost->enc_ctx->codec_type) {
2411	case AVMEDIA_TYPE_VIDEO:
2412	f->frame_rate = ost->frame_rate;
2413	f->width = ost->enc_ctx->width;
2414	f->height = ost->enc_ctx->height;
2415	if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2416	f->format = ost->enc_ctx->pix_fmt;
2417	} else if (ost->enc->pix_fmts) {
2418	count = 0;
2419	while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2420	count++;
2421	f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2422	if (!f->formats)
2423	exit_program(1);
2424	memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2425	}
2426	break;
2427	case AVMEDIA_TYPE_AUDIO:
2428	if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2429	f->format = ost->enc_ctx->sample_fmt;
2430	} else if (ost->enc->sample_fmts) {
2431	count = 0;
2432	while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2433	count++;
2434	f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2435	if (!f->formats)
2436	exit_program(1);
2437	memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2438	}
2439	if (ost->enc_ctx->sample_rate) {
2440	f->sample_rate = ost->enc_ctx->sample_rate;
2441	} else if (ost->enc->supported_samplerates) {
2442	count = 0;
2443	while (ost->enc->supported_samplerates[count])
2444	count++;
2445	f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2446	if (!f->sample_rates)
2447	exit_program(1);
2448	memcpy(f->sample_rates, ost->enc->supported_samplerates,
2449	(count + 1) * sizeof(*f->sample_rates));
2450	}
2451	if (ost->enc_ctx->channels) {
2452	f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2453	} else if (ost->enc->channel_layouts) {
2454	count = 0;
2455	while (ost->enc->channel_layouts[count])
2456	count++;
2457	f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2458	if (!f->channel_layouts)
2459	exit_program(1);
2460	memcpy(f->channel_layouts, ost->enc->channel_layouts,
2461	(count + 1) * sizeof(*f->channel_layouts));
2462	}
2463	break;
2464	}
2465	}
2466	}
2467
2468	/* check filename in case of an image number is expected */
2469	if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2470	if (!av_filename_number_test(oc->filename)) {
2471	print_error(oc->filename, AVERROR(EINVAL));
2472	exit_program(1);
2473	}
2474	}
2475
2476	if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2477	av_log(NULL, AV_LOG_ERROR,
2478	"No input streams but output needs an input stream\n");
2479	exit_program(1);
2480	}
2481
2482	if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2483	/* test if it already exists to avoid losing precious files */
2484	assert_file_overwrite(filename);
2485
2486	/* open the file */
2487	if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2488	&oc->interrupt_callback,
2489	&of->opts)) < 0) {
2490	print_error(filename, err);
2491	exit_program(1);
2492	}
2493	} else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2494	assert_file_overwrite(filename);
2495
2496	if (o->mux_preload) {
2497	av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2498	}
2499	oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2500
2501	/* copy metadata */
2502	for (i = 0; i < o->nb_metadata_map; i++) {
2503	char *p;
2504	int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2505
2506	if (in_file_index >= nb_input_files) {
2507	av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2508	exit_program(1);
2509	}
2510	copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2511	in_file_index >= 0 ?
2512	input_files[in_file_index]->ctx : NULL, o);
2513	}
2514
2515	/* copy chapters */
2516	if (o->chapters_input_file >= nb_input_files) {
2517	if (o->chapters_input_file == INT_MAX) {
2518	/* copy chapters from the first input file that has them*/
2519	o->chapters_input_file = -1;
2520	for (i = 0; i < nb_input_files; i++)
2521	if (input_files[i]->ctx->nb_chapters) {
2522	o->chapters_input_file = i;
2523	break;
2524	}
2525	} else {
2526	av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2527	o->chapters_input_file);
2528	exit_program(1);
2529	}
2530	}
2531	if (o->chapters_input_file >= 0)
2532	copy_chapters(input_files[o->chapters_input_file], of,
2533	!o->metadata_chapters_manual);
2534
2535	/* copy global metadata by default */
2536	if (!o->metadata_global_manual && nb_input_files){
2537	av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2538	AV_DICT_DONT_OVERWRITE);
2539	if(o->recording_time != INT64_MAX)
2540	av_dict_set(&oc->metadata, "duration", NULL, 0);
2541	av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2542	}
2543	if (!o->metadata_streams_manual)
2544	for (i = of->ost_index; i < nb_output_streams; i++) {
2545	InputStream *ist;
2546	if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
2547	continue;
2548	ist = input_streams[output_streams[i]->source_index];
2549	av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2550	if (!output_streams[i]->stream_copy) {
2551	av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2552	}
2553	}
2554
2555	/* process manually set programs */
2556	for (i = 0; i < o->nb_program; i++) {
2557	const char *p = o->program[i].u.str;
2558	int progid = i+1;
2559	AVProgram *program;
2560
2561	while(*p) {
2562	const char *p2 = av_get_token(&p, ":");
2563	const char *to_dealloc = p2;
2564	char *key;
2565	if (!p2)
2566	break;
2567
2568	if(*p) p++;
2569
2570	key = av_get_token(&p2, "=");
2571	if (!key || !*p2) {
2572	av_freep(&to_dealloc);
2573	av_freep(&key);
2574	break;
2575	}
2576	p2++;
2577
2578	if (!strcmp(key, "program_num"))
2579	progid = strtol(p2, NULL, 0);
2580	av_freep(&to_dealloc);
2581	av_freep(&key);
2582	}
2583
2584	program = av_new_program(oc, progid);
2585
2586	p = o->program[i].u.str;
2587	while(*p) {
2588	const char *p2 = av_get_token(&p, ":");
2589	const char *to_dealloc = p2;
2590	char *key;
2591	if (!p2)
2592	break;
2593	if(*p) p++;
2594
2595	key = av_get_token(&p2, "=");
2596	if (!key) {
2597	av_log(NULL, AV_LOG_FATAL,
2598	"No '=' character in program string %s.\n",
2599	p2);
2600	exit_program(1);
2601	}
2602	if (!*p2)
2603	exit_program(1);
2604	p2++;
2605
2606	if (!strcmp(key, "title")) {
2607	av_dict_set(&program->metadata, "title", p2, 0);
2608	} else if (!strcmp(key, "program_num")) {
2609	} else if (!strcmp(key, "st")) {
2610	int st_num = strtol(p2, NULL, 0);
2611	av_program_add_stream_index(oc, progid, st_num);
2612	} else {
2613	av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2614	exit_program(1);
2615	}
2616	av_freep(&to_dealloc);
2617	av_freep(&key);
2618	}
2619	}
2620
2621	/* process manually set metadata */
2622	for (i = 0; i < o->nb_metadata; i++) {
2623	AVDictionary **m;
2624	char type, *val;
2625	const char *stream_spec;
2626	int index = 0, j, ret = 0;
2627
2628	val = strchr(o->metadata[i].u.str, '=');
2629	if (!val) {
2630	av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2631	o->metadata[i].u.str);
2632	exit_program(1);
2633	}
2634	*val++ = 0;
2635
2636	parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2637	if (type == 's') {
2638	for (j = 0; j < oc->nb_streams; j++) {
2639	ost = output_streams[nb_output_streams - oc->nb_streams + j];
2640	if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2641	if (!strcmp(o->metadata[i].u.str, "rotate")) {
2642	char *tail;
2643	double theta = av_strtod(val, &tail);
2644	if (!*tail) {
2645	ost->rotate_overridden = 1;
2646	ost->rotate_override_value = theta;
2647	}
2648	} else {
2649	av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2650	}
2651	} else if (ret < 0)
2652	exit_program(1);
2653	}
2654	}
2655	else {
2656	switch (type) {
2657	case 'g':
2658	m = &oc->metadata;
2659	break;
2660	case 'c':
2661	if (index < 0 || index >= oc->nb_chapters) {
2662	av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2663	exit_program(1);
2664	}
2665	m = &oc->chapters[index]->metadata;
2666	break;
2667	case 'p':
2668	if (index < 0 || index >= oc->nb_programs) {
2669	av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2670	exit_program(1);
2671	}
2672	m = &oc->programs[index]->metadata;
2673	break;
2674	default:
2675	av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2676	exit_program(1);
2677	}
2678	av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2679	}
2680	}
2681
2682	return 0;
2683	}
2684
2685	static int opt_target(void *optctx, const char *opt, const char *arg)
2686	{
2687	OptionsContext *o = optctx;
2688	enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2689	static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2690
2691	if (!strncmp(arg, "pal-", 4)) {
2692	norm = PAL;
2693	arg += 4;
2694	} else if (!strncmp(arg, "ntsc-", 5)) {
2695	norm = NTSC;
2696	arg += 5;
2697	} else if (!strncmp(arg, "film-", 5)) {
2698	norm = FILM;
2699	arg += 5;
2700	} else {
2701	/* Try to determine PAL/NTSC by peeking in the input files */
2702	if (nb_input_files) {
2703	int i, j, fr;
2704	for (j = 0; j < nb_input_files; j++) {
2705	for (i = 0; i < input_files[j]->nb_streams; i++) {
2706	AVStream *st = input_files[j]->ctx->streams[i];
2707	if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2708	continue;
2709	fr = st->time_base.den * 1000 / st->time_base.num;
2710	if (fr == 25000) {
2711	norm = PAL;
2712	break;
2713	} else if ((fr == 29970) || (fr == 23976)) {
2714	norm = NTSC;
2715	break;
2716	}
2717	}
2718	if (norm != UNKNOWN)
2719	break;
2720	}
2721	}
2722	if (norm != UNKNOWN)
2723	av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2724	}
2725
2726	if (norm == UNKNOWN) {
2727	av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2728	av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2729	av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2730	exit_program(1);
2731	}
2732
2733	if (!strcmp(arg, "vcd")) {
2734	opt_video_codec(o, "c:v", "mpeg1video");
2735	opt_audio_codec(o, "c:a", "mp2");
2736	parse_option(o, "f", "vcd", options);
2737
2738	parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2739	parse_option(o, "r", frame_rates[norm], options);
2740	opt_default(NULL, "g", norm == PAL ? "15" : "18");
2741
2742	opt_default(NULL, "b:v", "1150000");
2743	opt_default(NULL, "maxrate:v", "1150000");
2744	opt_default(NULL, "minrate:v", "1150000");
2745	opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2746
2747	opt_default(NULL, "b:a", "224000");
2748	parse_option(o, "ar", "44100", options);
2749	parse_option(o, "ac", "2", options);
2750
2751	opt_default(NULL, "packetsize", "2324");
2752	opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2753
2754	/* We have to offset the PTS, so that it is consistent with the SCR.
2755	SCR starts at 36000, but the first two packs contain only padding
2756	and the first pack from the other stream, respectively, may also have
2757	been written before.
2758	So the real data starts at SCR 36000+3*1200. */
2759	o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2760	} else if (!strcmp(arg, "svcd")) {
2761
2762	opt_video_codec(o, "c:v", "mpeg2video");
2763	opt_audio_codec(o, "c:a", "mp2");
2764	parse_option(o, "f", "svcd", options);
2765
2766	parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2767	parse_option(o, "r", frame_rates[norm], options);
2768	parse_option(o, "pix_fmt", "yuv420p", options);
2769	opt_default(NULL, "g", norm == PAL ? "15" : "18");
2770
2771	opt_default(NULL, "b:v", "2040000");
2772	opt_default(NULL, "maxrate:v", "2516000");
2773	opt_default(NULL, "minrate:v", "0"); // 1145000;
2774	opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2775	opt_default(NULL, "scan_offset", "1");
2776
2777	opt_default(NULL, "b:a", "224000");
2778	parse_option(o, "ar", "44100", options);
2779
2780	opt_default(NULL, "packetsize", "2324");
2781
2782	} else if (!strcmp(arg, "dvd")) {
2783
2784	opt_video_codec(o, "c:v", "mpeg2video");
2785	opt_audio_codec(o, "c:a", "ac3");
2786	parse_option(o, "f", "dvd", options);
2787
2788	parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2789	parse_option(o, "r", frame_rates[norm], options);
2790	parse_option(o, "pix_fmt", "yuv420p", options);
2791	opt_default(NULL, "g", norm == PAL ? "15" : "18");
2792
2793	opt_default(NULL, "b:v", "6000000");
2794	opt_default(NULL, "maxrate:v", "9000000");
2795	opt_default(NULL, "minrate:v", "0"); // 1500000;
2796	opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2797
2798	opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2799	opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2800
2801	opt_default(NULL, "b:a", "448000");
2802	parse_option(o, "ar", "48000", options);
2803
2804	} else if (!strncmp(arg, "dv", 2)) {
2805
2806	parse_option(o, "f", "dv", options);
2807
2808	parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2809	parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2810	norm == PAL ? "yuv420p" : "yuv411p", options);
2811	parse_option(o, "r", frame_rates[norm], options);
2812
2813	parse_option(o, "ar", "48000", options);
2814	parse_option(o, "ac", "2", options);
2815
2816	} else {
2817	av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2818	return AVERROR(EINVAL);
2819	}
2820
2821	av_dict_copy(&o->g->codec_opts, codec_opts, AV_DICT_DONT_OVERWRITE);
2822	av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2823
2824	return 0;
2825	}
2826
2827	static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2828	{
2829	av_free (vstats_filename);
2830	vstats_filename = av_strdup (arg);
2831	return 0;
2832	}
2833
2834	static int opt_vstats(void *optctx, const char *opt, const char *arg)
2835	{
2836	char filename[40];
2837	time_t today2 = time(NULL);
2838	struct tm *today = localtime(&today2);
2839
2840	if (!today) { // maybe tomorrow
2841	av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2842	exit_program(1);
2843	}
2844
2845	snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2846	today->tm_sec);
2847	return opt_vstats_file(NULL, opt, filename);
2848	}
2849
2850	static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2851	{
2852	OptionsContext *o = optctx;
2853	return parse_option(o, "frames:v", arg, options);
2854	}
2855
2856	static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2857	{
2858	OptionsContext *o = optctx;
2859	return parse_option(o, "frames:a", arg, options);
2860	}
2861
2862	static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2863	{
2864	OptionsContext *o = optctx;
2865	return parse_option(o, "frames:d", arg, options);
2866	}
2867
2868	static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2869	{
2870	int ret;
2871	AVDictionary *cbak = codec_opts;
2872	AVDictionary *fbak = format_opts;
2873	codec_opts = NULL;
2874	format_opts = NULL;
2875
2876	ret = opt_default(NULL, opt, arg);
2877
2878	av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2879	av_dict_copy(&o->g->format_opts, format_opts, 0);
2880	av_dict_free(&codec_opts);
2881	av_dict_free(&format_opts);
2882	codec_opts = cbak;
2883	format_opts = fbak;
2884
2885	return ret;
2886	}
2887
2888	static int opt_preset(void *optctx, const char *opt, const char *arg)
2889	{
2890	OptionsContext *o = optctx;
2891	FILE *f=NULL;
2892	char filename[1000], line[1000], tmp_line[1000];
2893	const char *codec_name = NULL;
2894
2895	tmp_line[0] = *opt;
2896	tmp_line[1] = 0;
2897	MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2898
2899	if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2900	if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2901	av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2902	}else
2903	av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2904	exit_program(1);
2905	}
2906
2907	while (fgets(line, sizeof(line), f)) {
2908	char *key = tmp_line, *value, *endptr;
2909
2910	if (strcspn(line, "#\n\r") == 0)
2911	continue;
2912	av_strlcpy(tmp_line, line, sizeof(tmp_line));
2913	if (!av_strtok(key, "=", &value) ||
2914	!av_strtok(value, "\r\n", &endptr)) {
2915	av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2916	exit_program(1);
2917	}
2918	av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2919
2920	if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
2921	else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
2922	else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2923	else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
2924	else if (opt_default_new(o, key, value) < 0) {
2925	av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2926	filename, line, key, value);
2927	exit_program(1);
2928	}
2929	}
2930
2931	fclose(f);
2932
2933	return 0;
2934	}
2935
2936	static int opt_old2new(void *optctx, const char *opt, const char *arg)
2937	{
2938	OptionsContext *o = optctx;
2939	char *s = av_asprintf("%s:%c", opt + 1, *opt);
2940	int ret = parse_option(o, s, arg, options);
2941	av_free(s);
2942	return ret;
2943	}
2944
2945	static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2946	{
2947	OptionsContext *o = optctx;
2948
2949	if(!strcmp(opt, "ab")){
2950	av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2951	return 0;
2952	} else if(!strcmp(opt, "b")){
2953	av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2954	av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2955	return 0;
2956	}
2957	av_dict_set(&o->g->codec_opts, opt, arg, 0);
2958	return 0;
2959	}
2960
2961	static int opt_qscale(void *optctx, const char *opt, const char *arg)
2962	{
2963	OptionsContext *o = optctx;
2964	char *s;
2965	int ret;
2966	if(!strcmp(opt, "qscale")){
2967	av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2968	return parse_option(o, "q:v", arg, options);
2969	}
2970	s = av_asprintf("q%s", opt + 6);
2971	ret = parse_option(o, s, arg, options);
2972	av_free(s);
2973	return ret;
2974	}
2975
2976	static int opt_profile(void *optctx, const char *opt, const char *arg)
2977	{
2978	OptionsContext *o = optctx;
2979	if(!strcmp(opt, "profile")){
2980	av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2981	av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2982	return 0;
2983	}
2984	av_dict_set(&o->g->codec_opts, opt, arg, 0);
2985	return 0;
2986	}
2987
2988	static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2989	{
2990	OptionsContext *o = optctx;
2991	return parse_option(o, "filter:v", arg, options);
2992	}
2993
2994	static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2995	{
2996	OptionsContext *o = optctx;
2997	return parse_option(o, "filter:a", arg, options);
2998	}
2999
3000	static int opt_vsync(void *optctx, const char *opt, const char *arg)
3001	{
3002	if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
3003	else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
3004	else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3005	else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
3006
3007	if (video_sync_method == VSYNC_AUTO)
3008	video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3009	return 0;
3010	}
3011
3012	static int opt_timecode(void *optctx, const char *opt, const char *arg)
3013	{
3014	OptionsContext *o = optctx;
3015	char *tcr = av_asprintf("timecode=%s", arg);
3016	int ret = parse_option(o, "metadata:g", tcr, options);
3017	if (ret >= 0)
3018	ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3019	av_free(tcr);
3020	return 0;
3021	}
3022
3023	static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3024	{
3025	OptionsContext *o = optctx;
3026	char layout_str[32];
3027	char *stream_str;
3028	char *ac_str;
3029	int ret, channels, ac_str_size;
3030	uint64_t layout;
3031
3032	layout = av_get_channel_layout(arg);
3033	if (!layout) {
3034	av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3035	return AVERROR(EINVAL);
3036	}
3037	snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3038	ret = opt_default_new(o, opt, layout_str);
3039	if (ret < 0)
3040	return ret;
3041
3042	/* set 'ac' option based on channel layout */
3043	channels = av_get_channel_layout_nb_channels(layout);
3044	snprintf(layout_str, sizeof(layout_str), "%d", channels);
3045	stream_str = strchr(opt, ':');
3046	ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3047	ac_str = av_mallocz(ac_str_size);
3048	if (!ac_str)
3049	return AVERROR(ENOMEM);
3050	av_strlcpy(ac_str, "ac", 3);
3051	if (stream_str)
3052	av_strlcat(ac_str, stream_str, ac_str_size);
3053	ret = parse_option(o, ac_str, layout_str, options);
3054	av_free(ac_str);
3055
3056	return ret;
3057	}
3058
3059	static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3060	{
3061	OptionsContext *o = optctx;
3062	return parse_option(o, "q:a", arg, options);
3063	}
3064
3065	static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3066	{
3067	GROW_ARRAY(filtergraphs, nb_filtergraphs);
3068	if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3069	return AVERROR(ENOMEM);
3070	filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3071	filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3072	if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3073	return AVERROR(ENOMEM);
3074
3075	input_stream_potentially_available = 1;
3076
3077	return 0;
3078	}
3079
3080	static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3081	{
3082	uint8_t *graph_desc = read_file(arg);
3083	if (!graph_desc)
3084	return AVERROR(EINVAL);
3085
3086	GROW_ARRAY(filtergraphs, nb_filtergraphs);
3087	if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3088	return AVERROR(ENOMEM);
3089	filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
3090	filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3091
3092	input_stream_potentially_available = 1;
3093
3094	return 0;
3095	}
3096
3097	void show_help_default(const char *opt, const char *arg)
3098	{
3099	/* per-file options have at least one of those set */
3100	const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3101	int show_advanced = 0, show_avoptions = 0;
3102
3103	if (opt && *opt) {
3104	if (!strcmp(opt, "long"))
3105	show_advanced = 1;
3106	else if (!strcmp(opt, "full"))
3107	show_advanced = show_avoptions = 1;
3108	else
3109	av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3110	}
3111
3112	show_usage();
3113
3114	printf("Getting help:\n"
3115	" -h -- print basic options\n"
3116	" -h long -- print more options\n"
3117	" -h full -- print all options (including all format and codec specific options, very long)\n"
3118	" -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
3119	" See man %s for detailed description of the options.\n"
3120	"\n", program_name);
3121
3122	show_help_options(options, "Print help / information / capabilities:",
3123	OPT_EXIT, 0, 0);
3124
3125	show_help_options(options, "Global options (affect whole program "
3126	"instead of just one file:",
3127	0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3128	if (show_advanced)
3129	show_help_options(options, "Advanced global options:", OPT_EXPERT,
3130	per_file | OPT_EXIT, 0);
3131
3132	show_help_options(options, "Per-file main options:", 0,
3133	OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3134	OPT_EXIT, per_file);
3135	if (show_advanced)
3136	show_help_options(options, "Advanced per-file options:",
3137	OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3138
3139	show_help_options(options, "Video options:",
3140	OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3141	if (show_advanced)
3142	show_help_options(options, "Advanced Video options:",
3143	OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3144
3145	show_help_options(options, "Audio options:",
3146	OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3147	if (show_advanced)
3148	show_help_options(options, "Advanced Audio options:",
3149	OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3150	show_help_options(options, "Subtitle options:",
3151	OPT_SUBTITLE, 0, 0);
3152	printf("\n");
3153
3154	if (show_avoptions) {
3155	int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3156	show_help_children(avcodec_get_class(), flags);
3157	show_help_children(avformat_get_class(), flags);
3158	#if CONFIG_SWSCALE
3159	show_help_children(sws_get_class(), flags);
3160	#endif
3161	show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3162	show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3163	}
3164	}
3165
3166	void show_usage(void)
3167	{
3168	av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3169	av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3170	av_log(NULL, AV_LOG_INFO, "\n");
3171	}
3172
3173	enum OptGroup {
3174	GROUP_OUTFILE,
3175	GROUP_INFILE,
3176	};
3177
3178	static const OptionGroupDef groups[] = {
3179	[GROUP_OUTFILE] = { "output url", NULL, OPT_OUTPUT },
3180	[GROUP_INFILE] = { "input url", "i", OPT_INPUT },
3181	};
3182
3183	static int open_files(OptionGroupList *l, const char *inout,
3184	int (*open_file)(OptionsContext*, const char*))
3185	{
3186	int i, ret;
3187
3188	for (i = 0; i < l->nb_groups; i++) {
3189	OptionGroup *g = &l->groups[i];
3190	OptionsContext o;
3191
3192	init_options(&o);
3193	o.g = g;
3194
3195	ret = parse_optgroup(&o, g);
3196	if (ret < 0) {
3197	av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3198	"%s.\n", inout, g->arg);
3199	return ret;
3200	}
3201
3202	av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3203	ret = open_file(&o, g->arg);
3204	uninit_options(&o);
3205	if (ret < 0) {
3206	av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3207	inout, g->arg);
3208	return ret;
3209	}
3210	av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3211	}
3212
3213	return 0;
3214	}
3215
3216	int ffmpeg_parse_options(int argc, char **argv)
3217	{
3218	OptionParseContext octx;
3219	uint8_t error[128];
3220	int ret;
3221
3222	memset(&octx, 0, sizeof(octx));
3223
3224	/* split the commandline into an internal representation */
3225	ret = split_commandline(&octx, argc, argv, options, groups,
3226	FF_ARRAY_ELEMS(groups));
3227	if (ret < 0) {
3228	av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3229	goto fail;
3230	}
3231
3232	/* apply global options */
3233	ret = parse_optgroup(NULL, &octx.global_opts);
3234	if (ret < 0) {
3235	av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3236	goto fail;
3237	}
3238
3239	/* configure terminal and setup signal handlers */
3240	term_init();
3241
3242	/* open input files */
3243	ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3244	if (ret < 0) {
3245	av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3246	goto fail;
3247	}
3248
3249	/* create the complex filtergraphs */
3250	ret = init_complex_filters();
3251	if (ret < 0) {
3252	av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3253	goto fail;
3254	}
3255
3256	/* open output files */
3257	ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3258	if (ret < 0) {
3259	av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3260	goto fail;
3261	}
3262
3263	check_filter_outputs();
3264
3265	fail:
3266	uninit_parse_context(&octx);
3267	if (ret < 0) {
3268	av_strerror(ret, error, sizeof(error));
3269	av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3270	}
3271	return ret;
3272	}
3273
3274	static int opt_progress(void *optctx, const char *opt, const char *arg)
3275	{
3276	AVIOContext *avio = NULL;
3277	int ret;
3278
3279	if (!strcmp(arg, "-"))
3280	arg = "pipe:";
3281	ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3282	if (ret < 0) {
3283	av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3284	arg, av_err2str(ret));
3285	return ret;
3286	}
3287	progress_avio = avio;
3288	return 0;
3289	}
3290
3291	#define OFFSET(x) offsetof(OptionsContext, x)
3292	const OptionDef options[] = {
3293	/* main options */
3294	#include "cmdutils_common_opts.h"
3295	{ "f", HAS_ARG | OPT_STRING | OPT_OFFSET |
3296	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(format) },
3297	"force format", "fmt" },
3298	{ "y", OPT_BOOL, { &file_overwrite },
3299	"overwrite output files" },
3300	{ "n", OPT_BOOL, { &no_file_overwrite },
3301	"never overwrite output files" },
3302	{ "ignore_unknown", OPT_BOOL, { &ignore_unknown_streams },
3303	"Ignore unknown stream types" },
3304	{ "copy_unknown", OPT_BOOL | OPT_EXPERT, { &copy_unknown_streams },
3305	"Copy unknown stream types" },
3306	{ "c", HAS_ARG | OPT_STRING | OPT_SPEC |
3307	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3308	"codec name", "codec" },
3309	{ "codec", HAS_ARG | OPT_STRING | OPT_SPEC |
3310	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(codec_names) },
3311	"codec name", "codec" },
3312	{ "pre", HAS_ARG | OPT_STRING | OPT_SPEC |
3313	OPT_OUTPUT, { .off = OFFSET(presets) },
3314	"preset name", "preset" },
3315	{ "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3316	OPT_OUTPUT, { .func_arg = opt_map },
3317	"set input stream mapping",
3318	"[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3319	{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3320	"map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3321	{ "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC |
3322	OPT_OUTPUT, { .off = OFFSET(metadata_map) },
3323	"set metadata information of outfile from infile",
3324	"outfile[,metadata]:infile[,metadata]" },
3325	{ "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3326	OPT_OUTPUT, { .off = OFFSET(chapters_input_file) },
3327	"set chapters mapping", "input_file_index" },
3328	{ "t", HAS_ARG | OPT_TIME | OPT_OFFSET |
3329	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(recording_time) },
3330	"record or transcode \"duration\" seconds of audio/video",
3331	"duration" },
3332	{ "to", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(stop_time) },
3333	"record or transcode stop time", "time_stop" },
3334	{ "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3335	"set the limit file size in bytes", "limit_size" },
3336	{ "ss", HAS_ARG | OPT_TIME | OPT_OFFSET |
3337	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time) },
3338	"set the start time offset", "time_off" },
3339	{ "sseof", HAS_ARG | OPT_TIME | OPT_OFFSET |
3340	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(start_time_eof) },
3341	"set the start time offset relative to EOF", "time_off" },
3342	{ "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3343	OPT_INPUT, { .off = OFFSET(seek_timestamp) },
3344	"enable/disable seeking by timestamp with -ss" },
3345	{ "accurate_seek", OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3346	OPT_INPUT, { .off = OFFSET(accurate_seek) },
3347	"enable/disable accurate seeking with -ss" },
3348	{ "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET |
3349	OPT_EXPERT | OPT_INPUT, { .off = OFFSET(input_ts_offset) },
3350	"set the input ts offset", "time_off" },
3351	{ "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3352	OPT_EXPERT | OPT_INPUT, { .off = OFFSET(ts_scale) },
3353	"set the input ts scale", "scale" },
3354	{ "timestamp", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_recording_timestamp },
3355	"set the recording timestamp ('now' to set the current time)", "time" },
3356	{ "metadata", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3357	"add metadata", "string=string" },
3358	{ "program", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3359	"add program with specified streams", "title=string:st=number..." },
3360	{ "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3361	OPT_OUTPUT, { .func_arg = opt_data_frames },
3362	"set the number of data frames to output", "number" },
3363	{ "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
3364	"add timings for benchmarking" },
3365	{ "benchmark_all", OPT_BOOL | OPT_EXPERT, { &do_benchmark_all },
3366	"add timings for each task" },
3367	{ "progress", HAS_ARG | OPT_EXPERT, { .func_arg = opt_progress },
3368	"write program-readable progress information", "url" },
3369	{ "stdin", OPT_BOOL | OPT_EXPERT, { &stdin_interaction },
3370	"enable or disable interaction on standard input" },
3371	{ "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
3372	"set max runtime in seconds", "limit" },
3373	{ "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
3374	"dump each input packet" },
3375	{ "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
3376	"when dumping packets, also dump the payload" },
3377	{ "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3378	OPT_INPUT, { .off = OFFSET(rate_emu) },
3379	"read input at native frame rate", "" },
3380	{ "target", HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_target },
3381	"specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3382	"with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3383	{ "vsync", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vsync },
3384	"video sync method", "" },
3385	{ "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &frame_drop_threshold },
3386	"frame drop threshold", "" },
3387	{ "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
3388	"audio sync method", "" },
3389	{ "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
3390	"audio drift threshold", "threshold" },
3391	{ "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
3392	"copy timestamps" },
3393	{ "start_at_zero", OPT_BOOL | OPT_EXPERT, { &start_at_zero },
3394	"shift input timestamps to start at 0 when using copyts" },
3395	{ "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, { &copy_tb },
3396	"copy input stream time base when stream copying", "mode" },
3397	{ "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3398	OPT_OUTPUT, { .off = OFFSET(shortest) },
3399	"finish encoding within shortest input" },
3400	{ "apad", OPT_STRING | HAS_ARG | OPT_SPEC |
3401	OPT_OUTPUT, { .off = OFFSET(apad) },
3402	"audio pad", "" },
3403	{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
3404	"timestamp discontinuity delta threshold", "threshold" },
3405	{ "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_error_threshold },
3406	"timestamp error delta threshold", "threshold" },
3407	{ "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
3408	"exit on error", "error" },
3409	{ "abort_on", HAS_ARG | OPT_EXPERT, { .func_arg = opt_abort_on },
3410	"abort on the specified condition flags", "flags" },
3411	{ "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3412	OPT_OUTPUT, { .off = OFFSET(copy_initial_nonkeyframes) },
3413	"copy initial non-keyframes" },
3414	{ "copypriorss", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(copy_prior_start) },
3415	"copy or discard frames before start time" },
3416	{ "frames", OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3417	"set the number of frames to output", "number" },
3418	{ "tag", OPT_STRING | HAS_ARG | OPT_SPEC |
3419	OPT_EXPERT | OPT_OUTPUT | OPT_INPUT, { .off = OFFSET(codec_tags) },
3420	"force codec tag/fourcc", "fourcc/tag" },
3421	{ "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3422	OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(qscale) },
3423	"use fixed quality scale (VBR)", "q" },
3424	{ "qscale", HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3425	OPT_OUTPUT, { .func_arg = opt_qscale },
3426	"use fixed quality scale (VBR)", "q" },
3427	{ "profile", HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3428	"set profile", "profile" },
3429	{ "filter", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3430	"set stream filtergraph", "filter_graph" },
3431	{ "filter_threads", HAS_ARG | OPT_INT, { &filter_nbthreads },
3432	"number of non-complex filter threads" },
3433	{ "filter_script", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3434	"read stream filtergraph description from a file", "filename" },
3435	{ "reinit_filter", HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT, { .off = OFFSET(reinit_filters) },
3436	"reinit filtergraph on input parameter changes", "" },
3437	{ "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3438	"create a complex filtergraph", "graph_description" },
3439	{ "filter_complex_threads", HAS_ARG | OPT_INT, { &filter_complex_nbthreads },
3440	"number of threads for -filter_complex" },
3441	{ "lavfi", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
3442	"create a complex filtergraph", "graph_description" },
3443	{ "filter_complex_script", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex_script },
3444	"read complex filtergraph description from a file", "filename" },
3445	{ "stats", OPT_BOOL, { &print_stats },
3446	"print progress report during encoding", },
3447	{ "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3448	OPT_OUTPUT, { .func_arg = opt_attach },
3449	"add an attachment to the output file", "filename" },
3450	{ "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3451	OPT_EXPERT | OPT_INPUT, { .off = OFFSET(dump_attachment) },
3452	"extract an attachment into a file", "filename" },
3453	{ "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3454	OPT_OFFSET, { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3455	{ "debug_ts", OPT_BOOL | OPT_EXPERT, { &debug_ts },
3456	"print timestamp debugging info" },
3457	{ "max_error_rate", HAS_ARG | OPT_FLOAT, { &max_error_rate },
3458	"maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3459	{ "discard", OPT_STRING | HAS_ARG | OPT_SPEC |
3460	OPT_INPUT, { .off = OFFSET(discard) },
3461	"discard", "" },
3462	{ "disposition", OPT_STRING | HAS_ARG | OPT_SPEC |
3463	OPT_OUTPUT, { .off = OFFSET(disposition) },
3464	"disposition", "" },
3465	{ "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3466	{ .off = OFFSET(thread_queue_size) },
3467	"set the maximum number of queued packets from the demuxer" },
3468
3469	/* video options */
3470	{ "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_frames },
3471	"set the number of video frames to output", "number" },
3472	{ "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3473	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_rates) },
3474	"set frame rate (Hz value, fraction or abbreviation)", "rate" },
3475	{ "s", OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3476	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_sizes) },
3477	"set frame size (WxH or abbreviation)", "size" },
3478	{ "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC |
3479	OPT_OUTPUT, { .off = OFFSET(frame_aspect_ratios) },
3480	"set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3481	{ "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3482	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(frame_pix_fmts) },
3483	"set pixel format", "format" },
3484	{ "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG, { &frame_bits_per_raw_sample },
3485	"set the number of bits per raw sample", "number" },
3486	{ "intra", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &intra_only },
3487	"deprecated use -g 1" },
3488	{ "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3489	"disable video" },
3490	{ "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3491	OPT_OUTPUT, { .off = OFFSET(rc_overrides) },
3492	"rate control override for specific intervals", "override" },
3493	{ "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_INPUT |
3494	OPT_OUTPUT, { .func_arg = opt_video_codec },
3495	"force video codec ('copy' to copy stream)", "codec" },
3496	{ "sameq", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3497	"Removed" },
3498	{ "same_quant", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_sameq },
3499	"Removed" },
3500	{ "timecode", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_timecode },
3501	"set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3502	{ "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT, { .off = OFFSET(pass) },
3503	"select the pass number (1 to 3)", "n" },
3504	{ "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3505	OPT_OUTPUT, { .off = OFFSET(passlogfiles) },
3506	"select two pass log file name prefix", "prefix" },
3507	{ "deinterlace", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_deinterlace },
3508	"this option is deprecated, use the yadif filter instead" },
3509	{ "psnr", OPT_VIDEO | OPT_BOOL | OPT_EXPERT, { &do_psnr },
3510	"calculate PSNR of compressed frames" },
3511	{ "vstats", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_vstats },
3512	"dump video coding statistics to file" },
3513	{ "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { .func_arg = opt_vstats_file },
3514	"dump video coding statistics to file", "file" },
3515	{ "vstats_version", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &vstats_version },
3516	"Version of the vstats format to use."},
3517	{ "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_video_filters },
3518	"set video filters", "filter_graph" },
3519	{ "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3520	OPT_OUTPUT, { .off = OFFSET(intra_matrices) },
3521	"specify intra matrix coeffs", "matrix" },
3522	{ "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3523	OPT_OUTPUT, { .off = OFFSET(inter_matrices) },
3524	"specify inter matrix coeffs", "matrix" },
3525	{ "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC |
3526	OPT_OUTPUT, { .off = OFFSET(chroma_intra_matrices) },
3527	"specify intra matrix coeffs", "matrix" },
3528	{ "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC |
3529	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(top_field_first) },
3530	"top=1/bottom=0/auto=-1 field first", "" },
3531	{ "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3532	OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_old2new },
3533	"force video tag/fourcc", "fourcc/tag" },
3534	{ "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
3535	"show QP histogram" },
3536	{ "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3537	OPT_OUTPUT, { .off = OFFSET(force_fps) },
3538	"force the selected framerate, disable the best supported framerate selection" },
3539	{ "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3540	OPT_OUTPUT, { .func_arg = opt_streamid },
3541	"set the value of an outfile streamid", "streamIndex:value" },
3542	{ "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3543	OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(forced_key_frames) },
3544	"force key frames at specified timestamps", "timestamps" },
3545	{ "ab", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3546	"audio bitrate (please use -b:a)", "bitrate" },
3547	{ "b", OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_bitrate },
3548	"video bitrate (please use -b:v)", "bitrate" },
3549	{ "hwaccel", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3550	OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccels) },
3551	"use HW accelerated decoding", "hwaccel name" },
3552	{ "hwaccel_device", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3553	OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_devices) },
3554	"select a device for HW acceleration", "devicename" },
3555	{ "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3556	OPT_SPEC | OPT_INPUT, { .off = OFFSET(hwaccel_output_formats) },
3557	"select output format used with HW accelerated decoding", "format" },
3558	#if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3559	{ "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3560	#endif
3561	{ "hwaccels", OPT_EXIT, { .func_arg = show_hwaccels },
3562	"show available HW acceleration methods" },
3563	{ "autorotate", HAS_ARG | OPT_BOOL | OPT_SPEC |
3564	OPT_EXPERT | OPT_INPUT, { .off = OFFSET(autorotate) },
3565	"automatically insert correct rotate filters" },
3566	{ "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check},
3567	"attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
3568
3569	/* audio options */
3570	{ "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames },
3571	"set the number of audio frames to output", "number" },
3572	{ "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_qscale },
3573	"set audio quality (codec-specific)", "quality", },
3574	{ "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3575	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_sample_rate) },
3576	"set audio sampling rate (in Hz)", "rate" },
3577	{ "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC |
3578	OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(audio_channels) },
3579	"set number of audio channels", "channels" },
3580	{ "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3581	"disable audio" },
3582	{ "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE |
3583	OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_audio_codec },
3584	"force audio codec ('copy' to copy stream)", "codec" },
3585	{ "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3586	OPT_OUTPUT, { .func_arg = opt_old2new },
3587	"force audio tag/fourcc", "fourcc/tag" },
3588	{ "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
3589	"change audio volume (256=normal)" , "volume" },
3590	{ "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC |
3591	OPT_STRING | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(sample_fmts) },
3592	"set sample format", "format" },
3593	{ "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3594	OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_channel_layout },
3595	"set channel layout", "layout" },
3596	{ "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_filters },
3597	"set audio filters", "filter_graph" },
3598	{ "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3599	"set the maximum number of channels to try to guess the channel layout" },
3600
3601	/* subtitle options */
3602	{ "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3603	"disable subtitle" },
3604	{ "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3605	"force subtitle codec ('copy' to copy stream)", "codec" },
3606	{ "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3607	, "force subtitle tag/fourcc", "fourcc/tag" },
3608	{ "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3609	"fix subtitles duration" },
3610	{ "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3611	"set canvas size (WxH or abbreviation)", "size" },
3612
3613	/* grab options */
3614	{ "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3615	"deprecated, use -channel", "channel" },
3616	{ "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3617	"deprecated, use -standard", "standard" },
3618	{ "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3619
3620	/* muxer options */
3621	{ "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3622	"set the maximum demux-decode delay", "seconds" },
3623	{ "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3624	"set the initial demux-decode delay", "seconds" },
3625	{ "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3626	"override the options from ffserver", "" },
3627	{ "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3628	"specify a file in which to print sdp information", "file" },
3629
3630	{ "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3631	"set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3632
3633	{ "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3634	"A comma-separated list of bitstream filters", "bitstream_filters" },
3635	{ "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3636	"deprecated", "audio bitstream_filters" },
3637	{ "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3638	"deprecated", "video bitstream_filters" },
3639
3640	{ "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3641	"set the audio options to the indicated preset", "preset" },
3642	{ "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3643	"set the video options to the indicated preset", "preset" },
3644	{ "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3645	"set the subtitle options to the indicated preset", "preset" },
3646	{ "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3647	"set options from indicated preset file", "filename" },
3648
3649	{ "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3650	"maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3651
3652	/* data codec support */
3653	{ "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3654	"force data codec ('copy' to copy stream)", "codec" },
3655	{ "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3656	"disable data" },
3657
3658	#if CONFIG_VAAPI
3659	{ "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3660	"set VAAPI hardware device (DRM path or X11 display name)", "device" },
3661	#endif
3662
3663	#if CONFIG_QSV
3664	{ "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3665	"set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3666	#endif
3667
3668	{ NULL, },
3669	};
3670