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