?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'libav/master'
[FFMpeg-mirror/mplayer-patches.git] / avconv_opt.c
blob5bb7fb75f5cd3d3eb2840149478893a696caeaaf
1 /*
2 * avconv option parsing
3 *
4 * This file is part of Libav.
5 *
6 * Libav 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 * Libav 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 Libav; 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 "avconv.h"
24 #include "cmdutils.h"
25
26 #include "libavformat/avformat.h"
27
28 #include "libavcodec/avcodec.h"
29
30 #include "libavfilter/avfilter.h"
31 #include "libavfilter/avfiltergraph.h"
32
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/avutil.h"
36 #include "libavutil/channel_layout.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/fifo.h"
39 #include "libavutil/mathematics.h"
40 #include "libavutil/opt.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/pixdesc.h"
43 #include "libavutil/pixfmt.h"
44
45 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
46 {\
47 int i, ret;\
48 for (i = 0; i < o->nb_ ## name; i++) {\
49 char *spec = o->name[i].specifier;\
50 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
51 outvar = o->name[i].u.type;\
52 else if (ret < 0)\
53 exit(1);\
54 }\
55 }
56
57 char *vstats_filename;
58
59 float audio_drift_threshold = 0.1;
60 float dts_delta_threshold = 10;
61
62 int audio_volume = 256;
63 int audio_sync_method = 0;
64 int video_sync_method = VSYNC_AUTO;
65 int do_deinterlace = 0;
66 int do_benchmark = 0;
67 int do_hex_dump = 0;
68 int do_pkt_dump = 0;
69 int copy_ts = 0;
70 int copy_tb = 1;
71 int exit_on_error = 0;
72 int print_stats = 1;
73 int qp_hist = 0;
74
75 static int file_overwrite = 0;
76 static int video_discard = 0;
77 static int intra_dc_precision = 8;
78 static int using_stdin = 0;
79 static int input_sync;
80
81 static void uninit_options(OptionsContext *o)
82 {
83 const OptionDef *po = options;
84 int i;
85
86 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
87 while (po->name) {
88 void *dst = (uint8_t*)o + po->u.off;
89
90 if (po->flags & OPT_SPEC) {
91 SpecifierOpt **so = dst;
92 int i, *count = (int*)(so + 1);
93 for (i = 0; i < *count; i++) {
94 av_freep(&(*so)[i].specifier);
95 if (po->flags & OPT_STRING)
96 av_freep(&(*so)[i].u.str);
97 }
98 av_freep(so);
99 *count = 0;
100 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
101 av_freep(dst);
102 po++;
103 }
104
105 for (i = 0; i < o->nb_stream_maps; i++)
106 av_freep(&o->stream_maps[i].linklabel);
107 av_freep(&o->stream_maps);
108 av_freep(&o->meta_data_maps);
109 av_freep(&o->streamid_map);
110 }
111
112 static void init_options(OptionsContext *o)
113 {
114 memset(o, 0, sizeof(*o));
115
116 o->mux_max_delay = 0.7;
117 o->recording_time = INT64_MAX;
118 o->limit_filesize = UINT64_MAX;
119 o->chapters_input_file = INT_MAX;
120 }
121
122 static double parse_frame_aspect_ratio(const char *arg)
123 {
124 int x = 0, y = 0;
125 double ar = 0;
126 const char *p;
127 char *end;
128
129 p = strchr(arg, ':');
130 if (p) {
131 x = strtol(arg, &end, 10);
132 if (end == p)
133 y = strtol(end + 1, &end, 10);
134 if (x > 0 && y > 0)
135 ar = (double)x / (double)y;
136 } else
137 ar = strtod(arg, NULL);
138
139 if (!ar) {
140 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
141 exit(1);
142 }
143 return ar;
144 }
145
146 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
147 {
148 OptionsContext *o = optctx;
149 return parse_option(o, "codec:a", arg, options);
150 }
151
152 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
153 {
154 OptionsContext *o = optctx;
155 return parse_option(o, "codec:v", arg, options);
156 }
157
158 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
159 {
160 OptionsContext *o = optctx;
161 return parse_option(o, "codec:s", arg, options);
162 }
163
164 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
165 {
166 OptionsContext *o = optctx;
167 return parse_option(o, "codec:d", arg, options);
168 }
169
170 static int opt_map(void *optctx, const char *opt, const char *arg)
171 {
172 OptionsContext *o = optctx;
173 StreamMap *m = NULL;
174 int i, negative = 0, file_idx;
175 int sync_file_idx = -1, sync_stream_idx;
176 char *p, *sync;
177 char *map;
178
179 if (*arg == '-') {
180 negative = 1;
181 arg++;
182 }
183 map = av_strdup(arg);
184
185 /* parse sync stream first, just pick first matching stream */
186 if (sync = strchr(map, ',')) {
187 *sync = 0;
188 sync_file_idx = strtol(sync + 1, &sync, 0);
189 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
190 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
191 exit(1);
192 }
193 if (*sync)
194 sync++;
195 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
196 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
197 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
198 sync_stream_idx = i;
199 break;
200 }
201 if (i == input_files[sync_file_idx]->nb_streams) {
202 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
203 "match any streams.\n", arg);
204 exit(1);
205 }
206 }
207
208
209 if (map[0] == '[') {
210 /* this mapping refers to lavfi output */
211 const char *c = map + 1;
212 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
213 m = &o->stream_maps[o->nb_stream_maps - 1];
214 m->linklabel = av_get_token(&c, "]");
215 if (!m->linklabel) {
216 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
217 exit(1);
218 }
219 } else {
220 file_idx = strtol(map, &p, 0);
221 if (file_idx >= nb_input_files || file_idx < 0) {
222 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
223 exit(1);
224 }
225 if (negative)
226 /* disable some already defined maps */
227 for (i = 0; i < o->nb_stream_maps; i++) {
228 m = &o->stream_maps[i];
229 if (file_idx == m->file_index &&
230 check_stream_specifier(input_files[m->file_index]->ctx,
231 input_files[m->file_index]->ctx->streams[m->stream_index],
232 *p == ':' ? p + 1 : p) > 0)
233 m->disabled = 1;
234 }
235 else
236 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
237 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
238 *p == ':' ? p + 1 : p) <= 0)
239 continue;
240 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
241 m = &o->stream_maps[o->nb_stream_maps - 1];
242
243 m->file_index = file_idx;
244 m->stream_index = i;
245
246 if (sync_file_idx >= 0) {
247 m->sync_file_index = sync_file_idx;
248 m->sync_stream_index = sync_stream_idx;
249 } else {
250 m->sync_file_index = file_idx;
251 m->sync_stream_index = i;
252 }
253 }
254 }
255
256 if (!m) {
257 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
258 exit(1);
259 }
260
261 av_freep(&map);
262 return 0;
263 }
264
265 static int opt_attach(void *optctx, const char *opt, const char *arg)
266 {
267 OptionsContext *o = optctx;
268 GROW_ARRAY(o->attachments, o->nb_attachments);
269 o->attachments[o->nb_attachments - 1] = arg;
270 return 0;
271 }
272
273 /**
274 * Parse a metadata specifier passed as 'arg' parameter.
275 * @param arg metadata string to parse
276 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
277 * @param index for type c/p, chapter/program index is written here
278 * @param stream_spec for type s, the stream specifier is written here
279 */
280 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
281 {
282 if (*arg) {
283 *type = *arg;
284 switch (*arg) {
285 case 'g':
286 break;
287 case 's':
288 if (*(++arg) && *arg != ':') {
289 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
290 exit(1);
291 }
292 *stream_spec = *arg == ':' ? arg + 1 : "";
293 break;
294 case 'c':
295 case 'p':
296 if (*(++arg) == ':')
297 *index = strtol(++arg, NULL, 0);
298 break;
299 default:
300 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
301 exit(1);
302 }
303 } else
304 *type = 'g';
305 }
306
307 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
308 {
309 AVDictionary **meta_in = NULL;
310 AVDictionary **meta_out;
311 int i, ret = 0;
312 char type_in, type_out;
313 const char *istream_spec = NULL, *ostream_spec = NULL;
314 int idx_in = 0, idx_out = 0;
315
316 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
317 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
318
319 if (type_in == 'g' || type_out == 'g')
320 o->metadata_global_manual = 1;
321 if (type_in == 's' || type_out == 's')
322 o->metadata_streams_manual = 1;
323 if (type_in == 'c' || type_out == 'c')
324 o->metadata_chapters_manual = 1;
325
326 /* ic is NULL when just disabling automatic mappings */
327 if (!ic)
328 return 0;
329
330 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
331 if ((index) < 0 || (index) >= (nb_elems)) {\
332 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
333 (desc), (index));\
334 exit(1);\
335 }
336
337 #define SET_DICT(type, meta, context, index)\
338 switch (type) {\
339 case 'g':\
340 meta = &context->metadata;\
341 break;\
342 case 'c':\
343 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
344 meta = &context->chapters[index]->metadata;\
345 break;\
346 case 'p':\
347 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
348 meta = &context->programs[index]->metadata;\
349 break;\
350 case 's':\
351 break; /* handled separately below */ \
352 default: av_assert0(0);\
353 }\
354
355 SET_DICT(type_in, meta_in, ic, idx_in);
356 SET_DICT(type_out, meta_out, oc, idx_out);
357
358 /* for input streams choose first matching stream */
359 if (type_in == 's') {
360 for (i = 0; i < ic->nb_streams; i++) {
361 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
362 meta_in = &ic->streams[i]->metadata;
363 break;
364 } else if (ret < 0)
365 exit(1);
366 }
367 if (!meta_in) {
368 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
369 exit(1);
370 }
371 }
372
373 if (type_out == 's') {
374 for (i = 0; i < oc->nb_streams; i++) {
375 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
376 meta_out = &oc->streams[i]->metadata;
377 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
378 } else if (ret < 0)
379 exit(1);
380 }
381 } else
382 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
383
384 return 0;
385 }
386
387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
388 {
389 const AVCodecDescriptor *desc;
390 const char *codec_string = encoder ? "encoder" : "decoder";
391 AVCodec *codec;
392
393 codec = encoder ?
394 avcodec_find_encoder_by_name(name) :
395 avcodec_find_decoder_by_name(name);
396
397 if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
398 codec = encoder ? avcodec_find_encoder(desc->id) :
399 avcodec_find_decoder(desc->id);
400 if (codec)
401 av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
402 codec_string, codec->name, desc->name);
403 }
404
405 if (!codec) {
406 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
407 exit(1);
408 }
409 if (codec->type != type) {
410 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
411 exit(1);
412 }
413 return codec;
414 }
415
416 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
417 {
418 char *codec_name = NULL;
419
420 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
421 if (codec_name) {
422 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
423 st->codec->codec_id = codec->id;
424 return codec;
425 } else
426 return avcodec_find_decoder(st->codec->codec_id);
427 }
428
429 /* Add all the streams from the given input file to the global
430 * list of input streams. */
431 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
432 {
433 int i;
434
435 for (i = 0; i < ic->nb_streams; i++) {
436 AVStream *st = ic->streams[i];
437 AVCodecContext *dec = st->codec;
438 InputStream *ist = av_mallocz(sizeof(*ist));
439 char *framerate = NULL;
440
441 if (!ist)
442 exit(1);
443
444 GROW_ARRAY(input_streams, nb_input_streams);
445 input_streams[nb_input_streams - 1] = ist;
446
447 ist->st = st;
448 ist->file_index = nb_input_files;
449 ist->discard = 1;
450 st->discard = AVDISCARD_ALL;
451
452 ist->ts_scale = 1.0;
453 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
454
455 ist->dec = choose_decoder(o, ic, st);
456 ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
457
458 switch (dec->codec_type) {
459 case AVMEDIA_TYPE_VIDEO:
460 ist->resample_height = dec->height;
461 ist->resample_width = dec->width;
462 ist->resample_pix_fmt = dec->pix_fmt;
463
464 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
465 if (framerate && av_parse_video_rate(&ist->framerate,
466 framerate) < 0) {
467 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
468 framerate);
469 exit(1);
470 }
471
472 break;
473 case AVMEDIA_TYPE_AUDIO:
474 guess_input_channel_layout(ist);
475
476 ist->resample_sample_fmt = dec->sample_fmt;
477 ist->resample_sample_rate = dec->sample_rate;
478 ist->resample_channels = dec->channels;
479 ist->resample_channel_layout = dec->channel_layout;
480
481 break;
482 case AVMEDIA_TYPE_DATA:
483 case AVMEDIA_TYPE_SUBTITLE:
484 case AVMEDIA_TYPE_ATTACHMENT:
485 case AVMEDIA_TYPE_UNKNOWN:
486 break;
487 default:
488 abort();
489 }
490 }
491 }
492
493 static void assert_file_overwrite(const char *filename)
494 {
495 if (!file_overwrite &&
496 (strchr(filename, ':') == NULL || filename[1] == ':' ||
497 av_strstart(filename, "file:", NULL))) {
498 if (avio_check(filename, 0) == 0) {
499 if (!using_stdin) {
500 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
501 fflush(stderr);
502 if (!read_yesno()) {
503 fprintf(stderr, "Not overwriting - exiting\n");
504 exit(1);
505 }
506 }
507 else {
508 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
509 exit(1);
510 }
511 }
512 }
513 }
514
515 static void dump_attachment(AVStream *st, const char *filename)
516 {
517 int ret;
518 AVIOContext *out = NULL;
519 AVDictionaryEntry *e;
520
521 if (!st->codec->extradata_size) {
522 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
523 nb_input_files - 1, st->index);
524 return;
525 }
526 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
527 filename = e->value;
528 if (!*filename) {
529 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
530 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
531 exit(1);
532 }
533
534 assert_file_overwrite(filename);
535
536 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
537 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
538 filename);
539 exit(1);
540 }
541
542 avio_write(out, st->codec->extradata, st->codec->extradata_size);
543 avio_flush(out);
544 avio_close(out);
545 }
546
547 static int open_input_file(OptionsContext *o, const char *filename)
548 {
549 AVFormatContext *ic;
550 AVInputFormat *file_iformat = NULL;
551 int err, i, ret;
552 int64_t timestamp;
553 uint8_t buf[128];
554 AVDictionary **opts;
555 int orig_nb_streams; // number of streams before avformat_find_stream_info
556
557 if (o->format) {
558 if (!(file_iformat = av_find_input_format(o->format))) {
559 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
560 exit(1);
561 }
562 }
563
564 if (!strcmp(filename, "-"))
565 filename = "pipe:";
566
567 using_stdin |= !strncmp(filename, "pipe:", 5) ||
568 !strcmp(filename, "/dev/stdin");
569
570 /* get default parameters from command line */
571 ic = avformat_alloc_context();
572 if (!ic) {
573 print_error(filename, AVERROR(ENOMEM));
574 exit(1);
575 }
576 if (o->nb_audio_sample_rate) {
577 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
578 av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
579 }
580 if (o->nb_audio_channels) {
581 /* because we set audio_channels based on both the "ac" and
582 * "channel_layout" options, we need to check that the specified
583 * demuxer actually has the "channels" option before setting it */
584 if (file_iformat && file_iformat->priv_class &&
585 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
586 AV_OPT_SEARCH_FAKE_OBJ)) {
587 snprintf(buf, sizeof(buf), "%d",
588 o->audio_channels[o->nb_audio_channels - 1].u.i);
589 av_dict_set(&o->g->format_opts, "channels", buf, 0);
590 }
591 }
592 if (o->nb_frame_rates) {
593 /* set the format-level framerate option;
594 * this is important for video grabbers, e.g. x11 */
595 if (file_iformat && file_iformat->priv_class &&
596 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
597 AV_OPT_SEARCH_FAKE_OBJ)) {
598 av_dict_set(&o->g->format_opts, "framerate",
599 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
600 }
601 }
602 if (o->nb_frame_sizes) {
603 av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
604 }
605 if (o->nb_frame_pix_fmts)
606 av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
607
608 ic->flags |= AVFMT_FLAG_NONBLOCK;
609 ic->interrupt_callback = int_cb;
610
611 /* open the input file with generic libav function */
612 err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
613 if (err < 0) {
614 print_error(filename, err);
615 exit(1);
616 }
617 assert_avoptions(o->g->format_opts);
618
619 /* apply forced codec ids */
620 for (i = 0; i < ic->nb_streams; i++)
621 choose_decoder(o, ic, ic->streams[i]);
622
623 /* Set AVCodecContext options for avformat_find_stream_info */
624 opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
625 orig_nb_streams = ic->nb_streams;
626
627 /* If not enough info to get the stream parameters, we decode the
628 first frames to get it. (used in mpeg case for example) */
629 ret = avformat_find_stream_info(ic, opts);
630 if (ret < 0) {
631 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
632 avformat_close_input(&ic);
633 exit(1);
634 }
635
636 timestamp = o->start_time;
637 /* add the stream start time */
638 if (ic->start_time != AV_NOPTS_VALUE)
639 timestamp += ic->start_time;
640
641 /* if seeking requested, we execute it */
642 if (o->start_time != 0) {
643 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
644 if (ret < 0) {
645 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
646 filename, (double)timestamp / AV_TIME_BASE);
647 }
648 }
649
650 /* update the current parameters so that they match the one of the input stream */
651 add_input_streams(o, ic);
652
653 /* dump the file content */
654 av_dump_format(ic, nb_input_files, filename, 0);
655
656 GROW_ARRAY(input_files, nb_input_files);
657 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
658 exit(1);
659
660 input_files[nb_input_files - 1]->ctx = ic;
661 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
662 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
663 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
664 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
665
666 for (i = 0; i < o->nb_dump_attachment; i++) {
667 int j;
668
669 for (j = 0; j < ic->nb_streams; j++) {
670 AVStream *st = ic->streams[j];
671
672 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
673 dump_attachment(st, o->dump_attachment[i].u.str);
674 }
675 }
676
677 for (i = 0; i < orig_nb_streams; i++)
678 av_dict_free(&opts[i]);
679 av_freep(&opts);
680
681 return 0;
682 }
683
684 static uint8_t *get_line(AVIOContext *s)
685 {
686 AVIOContext *line;
687 uint8_t *buf;
688 char c;
689
690 if (avio_open_dyn_buf(&line) < 0) {
691 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
692 exit(1);
693 }
694
695 while ((c = avio_r8(s)) && c != '\n')
696 avio_w8(line, c);
697 avio_w8(line, 0);
698 avio_close_dyn_buf(line, &buf);
699
700 return buf;
701 }
702
703 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
704 {
705 int i, ret = 1;
706 char filename[1000];
707 const char *base[3] = { getenv("AVCONV_DATADIR"),
708 getenv("HOME"),
709 AVCONV_DATADIR,
710 };
711
712 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
713 if (!base[i])
714 continue;
715 if (codec_name) {
716 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
717 i != 1 ? "" : "/.avconv", codec_name, preset_name);
718 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
719 }
720 if (ret) {
721 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
722 i != 1 ? "" : "/.avconv", preset_name);
723 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
724 }
725 }
726 return ret;
727 }
728
729 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
730 {
731 char *codec_name = NULL;
732
733 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
734 if (!codec_name) {
735 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
736 NULL, ost->st->codec->codec_type);
737 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
738 } else if (!strcmp(codec_name, "copy"))
739 ost->stream_copy = 1;
740 else {
741 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
742 ost->st->codec->codec_id = ost->enc->id;
743 }
744 }
745
746 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
747 {
748 OutputStream *ost;
749 AVStream *st = avformat_new_stream(oc, NULL);
750 int idx = oc->nb_streams - 1, ret = 0;
751 char *bsf = NULL, *next, *codec_tag = NULL;
752 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
753 double qscale = -1;
754
755 if (!st) {
756 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
757 exit(1);
758 }
759
760 if (oc->nb_streams - 1 < o->nb_streamid_map)
761 st->id = o->streamid_map[oc->nb_streams - 1];
762
763 GROW_ARRAY(output_streams, nb_output_streams);
764 if (!(ost = av_mallocz(sizeof(*ost))))
765 exit(1);
766 output_streams[nb_output_streams - 1] = ost;
767
768 ost->file_index = nb_output_files;
769 ost->index = idx;
770 ost->st = st;
771 st->codec->codec_type = type;
772 choose_encoder(o, oc, ost);
773 if (ost->enc) {
774 AVIOContext *s = NULL;
775 char *buf = NULL, *arg = NULL, *preset = NULL;
776
777 ost->opts = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
778
779 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
780 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
781 do {
782 buf = get_line(s);
783 if (!buf[0] || buf[0] == '#') {
784 av_free(buf);
785 continue;
786 }
787 if (!(arg = strchr(buf, '='))) {
788 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
789 exit(1);
790 }
791 *arg++ = 0;
792 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
793 av_free(buf);
794 } while (!s->eof_reached);
795 avio_close(s);
796 }
797 if (ret) {
798 av_log(NULL, AV_LOG_FATAL,
799 "Preset %s specified for stream %d:%d, but could not be opened.\n",
800 preset, ost->file_index, ost->index);
801 exit(1);
802 }
803 } else {
804 ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
805 }
806
807 avcodec_get_context_defaults3(st->codec, ost->enc);
808 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
809
810 ost->max_frames = INT64_MAX;
811 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
812
813 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
814 while (bsf) {
815 if (next = strchr(bsf, ','))
816 *next++ = 0;
817 if (!(bsfc = av_bitstream_filter_init(bsf))) {
818 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
819 exit(1);
820 }
821 if (bsfc_prev)
822 bsfc_prev->next = bsfc;
823 else
824 ost->bitstream_filters = bsfc;
825
826 bsfc_prev = bsfc;
827 bsf = next;
828 }
829
830 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
831 if (codec_tag) {
832 uint32_t tag = strtol(codec_tag, &next, 0);
833 if (*next)
834 tag = AV_RL32(codec_tag);
835 st->codec->codec_tag = tag;
836 }
837
838 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
839 if (qscale >= 0) {
840 st->codec->flags |= CODEC_FLAG_QSCALE;
841 st->codec->global_quality = FF_QP2LAMBDA * qscale;
842 }
843
844 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
845 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
846
847 av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
848
849 av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
850
851 ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
852
853 return ost;
854 }
855
856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
857 {
858 int i;
859 const char *p = str;
860 for (i = 0;; i++) {
861 dest[i] = atoi(p);
862 if (i == 63)
863 break;
864 p = strchr(p, ',');
865 if (!p) {
866 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
867 exit(1);
868 }
869 p++;
870 }
871 }
872
873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
874 {
875 AVStream *st;
876 OutputStream *ost;
877 AVCodecContext *video_enc;
878
879 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
880 st = ost->st;
881 video_enc = st->codec;
882
883 if (!ost->stream_copy) {
884 const char *p = NULL;
885 char *frame_rate = NULL, *frame_size = NULL;
886 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
887 char *intra_matrix = NULL, *inter_matrix = NULL;
888 const char *filters = "null";
889 int do_pass = 0;
890 int i;
891
892 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
893 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
894 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
895 exit(1);
896 }
897
898 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
899 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
900 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
901 exit(1);
902 }
903
904 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
905 if (frame_aspect_ratio)
906 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
907
908 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
909 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
910 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
911 exit(1);
912 }
913 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
914
915 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
916 if (intra_matrix) {
917 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
918 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
919 exit(1);
920 }
921 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
922 }
923 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
924 if (inter_matrix) {
925 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
926 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
927 exit(1);
928 }
929 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
930 }
931
932 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
933 for (i = 0; p; i++) {
934 int start, end, q;
935 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
936 if (e != 3) {
937 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
938 exit(1);
939 }
940 video_enc->rc_override =
941 av_realloc(video_enc->rc_override,
942 sizeof(RcOverride) * (i + 1));
943 video_enc->rc_override[i].start_frame = start;
944 video_enc->rc_override[i].end_frame = end;
945 if (q > 0) {
946 video_enc->rc_override[i].qscale = q;
947 video_enc->rc_override[i].quality_factor = 1.0;
948 }
949 else {
950 video_enc->rc_override[i].qscale = 0;
951 video_enc->rc_override[i].quality_factor = -q/100.0;
952 }
953 p = strchr(p, '/');
954 if (p) p++;
955 }
956 video_enc->rc_override_count = i;
957 video_enc->intra_dc_precision = intra_dc_precision - 8;
958
959 /* two pass mode */
960 MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
961 if (do_pass) {
962 if (do_pass == 1) {
963 video_enc->flags |= CODEC_FLAG_PASS1;
964 } else {
965 video_enc->flags |= CODEC_FLAG_PASS2;
966 }
967 }
968
969 MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
970 if (ost->logfile_prefix &&
971 !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
972 exit(1);
973
974 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
975 if (ost->forced_keyframes)
976 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
977
978 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
979
980 ost->top_field_first = -1;
981 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
982
983 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
984 ost->avfilter = av_strdup(filters);
985 } else {
986 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
987 }
988
989 return ost;
990 }
991
992 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
993 {
994 AVStream *st;
995 OutputStream *ost;
996 AVCodecContext *audio_enc;
997
998 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
999 st = ost->st;
1000
1001 audio_enc = st->codec;
1002 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1003
1004 if (!ost->stream_copy) {
1005 char *sample_fmt = NULL;
1006 const char *filters = "anull";
1007
1008 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1009
1010 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1011 if (sample_fmt &&
1012 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1013 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1014 exit(1);
1015 }
1016
1017 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1018
1019 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1020 ost->avfilter = av_strdup(filters);
1021 }
1022
1023 return ost;
1024 }
1025
1026 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1027 {
1028 OutputStream *ost;
1029
1030 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1031 if (!ost->stream_copy) {
1032 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1033 exit(1);
1034 }
1035
1036 return ost;
1037 }
1038
1039 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1040 {
1041 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1042 ost->stream_copy = 1;
1043 return ost;
1044 }
1045
1046 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1047 {
1048 AVStream *st;
1049 OutputStream *ost;
1050 AVCodecContext *subtitle_enc;
1051
1052 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1053 st = ost->st;
1054 subtitle_enc = st->codec;
1055
1056 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1057
1058 return ost;
1059 }
1060
1061 /* arg format is "output-stream-index:streamid-value". */
1062 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1063 {
1064 OptionsContext *o = optctx;
1065 int idx;
1066 char *p;
1067 char idx_str[16];
1068
1069 av_strlcpy(idx_str, arg, sizeof(idx_str));
1070 p = strchr(idx_str, ':');
1071 if (!p) {
1072 av_log(NULL, AV_LOG_FATAL,
1073 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1074 arg, opt);
1075 exit(1);
1076 }
1077 *p++ = '\0';
1078 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1079 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1080 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1081 return 0;
1082 }
1083
1084 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1085 {
1086 AVFormatContext *is = ifile->ctx;
1087 AVFormatContext *os = ofile->ctx;
1088 AVChapter **tmp;
1089 int i;
1090
1091 tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1092 if (!tmp)
1093 return AVERROR(ENOMEM);
1094 os->chapters = tmp;
1095
1096 for (i = 0; i < is->nb_chapters; i++) {
1097 AVChapter *in_ch = is->chapters[i], *out_ch;
1098 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
1099 AV_TIME_BASE_Q, in_ch->time_base);
1100 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1101 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1102
1103
1104 if (in_ch->end < ts_off)
1105 continue;
1106 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1107 break;
1108
1109 out_ch = av_mallocz(sizeof(AVChapter));
1110 if (!out_ch)
1111 return AVERROR(ENOMEM);
1112
1113 out_ch->id = in_ch->id;
1114 out_ch->time_base = in_ch->time_base;
1115 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1116 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1117
1118 if (copy_metadata)
1119 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1120
1121 os->chapters[os->nb_chapters++] = out_ch;
1122 }
1123 return 0;
1124 }
1125
1126 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1127 AVFormatContext *oc)
1128 {
1129 OutputStream *ost;
1130
1131 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1132 ofilter->out_tmp->pad_idx)) {
1133 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1134 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1135 default:
1136 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1137 "currently.\n");
1138 exit(1);
1139 }
1140
1141 ost->source_index = -1;
1142 ost->filter = ofilter;
1143
1144 ofilter->ost = ost;
1145
1146 if (ost->stream_copy) {
1147 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1148 "which is fed from a complex filtergraph. Filtering and streamcopy "
1149 "cannot be used together.\n", ost->file_index, ost->index);
1150 exit(1);
1151 }
1152
1153 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1154 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1155 exit(1);
1156 }
1157 avfilter_inout_free(&ofilter->out_tmp);
1158 }
1159
1160 static int configure_complex_filters(void)
1161 {
1162 int i, ret = 0;
1163
1164 for (i = 0; i < nb_filtergraphs; i++)
1165 if (!filtergraphs[i]->graph &&
1166 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1167 return ret;
1168 return 0;
1169 }
1170
1171 static int open_output_file(OptionsContext *o, const char *filename)
1172 {
1173 AVFormatContext *oc;
1174 int i, j, err;
1175 AVOutputFormat *file_oformat;
1176 OutputStream *ost;
1177 InputStream *ist;
1178
1179 if (configure_complex_filters() < 0) {
1180 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1181 exit(1);
1182 }
1183
1184 if (!strcmp(filename, "-"))
1185 filename = "pipe:";
1186
1187 oc = avformat_alloc_context();
1188 if (!oc) {
1189 print_error(filename, AVERROR(ENOMEM));
1190 exit(1);
1191 }
1192
1193 if (o->format) {
1194 file_oformat = av_guess_format(o->format, NULL, NULL);
1195 if (!file_oformat) {
1196 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1197 exit(1);
1198 }
1199 } else {
1200 file_oformat = av_guess_format(NULL, filename, NULL);
1201 if (!file_oformat) {
1202 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1203 filename);
1204 exit(1);
1205 }
1206 }
1207
1208 oc->oformat = file_oformat;
1209 oc->interrupt_callback = int_cb;
1210 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1211
1212 /* create streams for all unlabeled output pads */
1213 for (i = 0; i < nb_filtergraphs; i++) {
1214 FilterGraph *fg = filtergraphs[i];
1215 for (j = 0; j < fg->nb_outputs; j++) {
1216 OutputFilter *ofilter = fg->outputs[j];
1217
1218 if (!ofilter->out_tmp || ofilter->out_tmp->name)
1219 continue;
1220
1221 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1222 ofilter->out_tmp->pad_idx)) {
1223 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
1224 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
1225 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1226 }
1227 init_output_filter(ofilter, o, oc);
1228 }
1229 }
1230
1231 if (!o->nb_stream_maps) {
1232 /* pick the "best" stream of each type */
1233 #define NEW_STREAM(type, index)\
1234 if (index >= 0) {\
1235 ost = new_ ## type ## _stream(o, oc);\
1236 ost->source_index = index;\
1237 ost->sync_ist = input_streams[index];\
1238 input_streams[index]->discard = 0;\
1239 input_streams[index]->st->discard = AVDISCARD_NONE;\
1240 }
1241
1242 /* video: highest resolution */
1243 if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1244 int area = 0, idx = -1;
1245 for (i = 0; i < nb_input_streams; i++) {
1246 ist = input_streams[i];
1247 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1248 ist->st->codec->width * ist->st->codec->height > area) {
1249 area = ist->st->codec->width * ist->st->codec->height;
1250 idx = i;
1251 }
1252 }
1253 NEW_STREAM(video, idx);
1254 }
1255
1256 /* audio: most channels */
1257 if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1258 int channels = 0, idx = -1;
1259 for (i = 0; i < nb_input_streams; i++) {
1260 ist = input_streams[i];
1261 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1262 ist->st->codec->channels > channels) {
1263 channels = ist->st->codec->channels;
1264 idx = i;
1265 }
1266 }
1267 NEW_STREAM(audio, idx);
1268 }
1269
1270 /* subtitles: pick first */
1271 if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1272 for (i = 0; i < nb_input_streams; i++)
1273 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1274 NEW_STREAM(subtitle, i);
1275 break;
1276 }
1277 }
1278 /* do something with data? */
1279 } else {
1280 for (i = 0; i < o->nb_stream_maps; i++) {
1281 StreamMap *map = &o->stream_maps[i];
1282
1283 if (map->disabled)
1284 continue;
1285
1286 if (map->linklabel) {
1287 FilterGraph *fg;
1288 OutputFilter *ofilter = NULL;
1289 int j, k;
1290
1291 for (j = 0; j < nb_filtergraphs; j++) {
1292 fg = filtergraphs[j];
1293 for (k = 0; k < fg->nb_outputs; k++) {
1294 AVFilterInOut *out = fg->outputs[k]->out_tmp;
1295 if (out && !strcmp(out->name, map->linklabel)) {
1296 ofilter = fg->outputs[k];
1297 goto loop_end;
1298 }
1299 }
1300 }
1301 loop_end:
1302 if (!ofilter) {
1303 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1304 "in any defined filter graph.\n", map->linklabel);
1305 exit(1);
1306 }
1307 init_output_filter(ofilter, o, oc);
1308 } else {
1309 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1310 switch (ist->st->codec->codec_type) {
1311 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1312 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1313 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1314 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
1315 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1316 default:
1317 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1318 map->file_index, map->stream_index);
1319 exit(1);
1320 }
1321
1322 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1323 ost->sync_ist = input_streams[input_files[map->sync_file_index]->ist_index +
1324 map->sync_stream_index];
1325 ist->discard = 0;
1326 ist->st->discard = AVDISCARD_NONE;
1327 }
1328 }
1329 }
1330
1331 /* handle attached files */
1332 for (i = 0; i < o->nb_attachments; i++) {
1333 AVIOContext *pb;
1334 uint8_t *attachment;
1335 const char *p;
1336 int64_t len;
1337
1338 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1339 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1340 o->attachments[i]);
1341 exit(1);
1342 }
1343 if ((len = avio_size(pb)) <= 0) {
1344 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1345 o->attachments[i]);
1346 exit(1);
1347 }
1348 if (!(attachment = av_malloc(len))) {
1349 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1350 o->attachments[i]);
1351 exit(1);
1352 }
1353 avio_read(pb, attachment, len);
1354
1355 ost = new_attachment_stream(o, oc);
1356 ost->stream_copy = 0;
1357 ost->source_index = -1;
1358 ost->attachment_filename = o->attachments[i];
1359 ost->st->codec->extradata = attachment;
1360 ost->st->codec->extradata_size = len;
1361
1362 p = strrchr(o->attachments[i], '/');
1363 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1364 avio_close(pb);
1365 }
1366
1367 GROW_ARRAY(output_files, nb_output_files);
1368 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1369 exit(1);
1370
1371 output_files[nb_output_files - 1]->ctx = oc;
1372 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
1373 output_files[nb_output_files - 1]->recording_time = o->recording_time;
1374 if (o->recording_time != INT64_MAX)
1375 oc->duration = o->recording_time;
1376 output_files[nb_output_files - 1]->start_time = o->start_time;
1377 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1378 output_files[nb_output_files - 1]->shortest = o->shortest;
1379 av_dict_copy(&output_files[nb_output_files - 1]->opts, o->g->format_opts, 0);
1380
1381 /* check filename in case of an image number is expected */
1382 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1383 if (!av_filename_number_test(oc->filename)) {
1384 print_error(oc->filename, AVERROR(EINVAL));
1385 exit(1);
1386 }
1387 }
1388
1389 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1390 /* test if it already exists to avoid losing precious files */
1391 assert_file_overwrite(filename);
1392
1393 /* open the file */
1394 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1395 &oc->interrupt_callback,
1396 &output_files[nb_output_files - 1]->opts)) < 0) {
1397 print_error(filename, err);
1398 exit(1);
1399 }
1400 }
1401
1402 if (o->mux_preload) {
1403 uint8_t buf[64];
1404 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1405 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1406 }
1407 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1408 oc->flags |= AVFMT_FLAG_NONBLOCK;
1409
1410 /* copy metadata */
1411 for (i = 0; i < o->nb_metadata_map; i++) {
1412 char *p;
1413 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1414
1415 if (in_file_index >= nb_input_files) {
1416 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1417 exit(1);
1418 }
1419 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1420 in_file_index >= 0 ?
1421 input_files[in_file_index]->ctx : NULL, o);
1422 }
1423
1424 /* copy chapters */
1425 if (o->chapters_input_file >= nb_input_files) {
1426 if (o->chapters_input_file == INT_MAX) {
1427 /* copy chapters from the first input file that has them*/
1428 o->chapters_input_file = -1;
1429 for (i = 0; i < nb_input_files; i++)
1430 if (input_files[i]->ctx->nb_chapters) {
1431 o->chapters_input_file = i;
1432 break;
1433 }
1434 } else {
1435 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1436 o->chapters_input_file);
1437 exit(1);
1438 }
1439 }
1440 if (o->chapters_input_file >= 0)
1441 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1442 !o->metadata_chapters_manual);
1443
1444 /* copy global metadata by default */
1445 if (!o->metadata_global_manual && nb_input_files)
1446 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1447 AV_DICT_DONT_OVERWRITE);
1448 if (!o->metadata_streams_manual)
1449 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1450 InputStream *ist;
1451 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
1452 continue;
1453 ist = input_streams[output_streams[i]->source_index];
1454 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1455 }
1456
1457 /* process manually set metadata */
1458 for (i = 0; i < o->nb_metadata; i++) {
1459 AVDictionary **m;
1460 char type, *val;
1461 const char *stream_spec;
1462 int index = 0, j, ret;
1463
1464 val = strchr(o->metadata[i].u.str, '=');
1465 if (!val) {
1466 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1467 o->metadata[i].u.str);
1468 exit(1);
1469 }
1470 *val++ = 0;
1471
1472 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1473 if (type == 's') {
1474 for (j = 0; j < oc->nb_streams; j++) {
1475 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1476 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1477 } else if (ret < 0)
1478 exit(1);
1479 }
1480 }
1481 else {
1482 switch (type) {
1483 case 'g':
1484 m = &oc->metadata;
1485 break;
1486 case 'c':
1487 if (index < 0 || index >= oc->nb_chapters) {
1488 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1489 exit(1);
1490 }
1491 m = &oc->chapters[index]->metadata;
1492 break;
1493 default:
1494 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1495 exit(1);
1496 }
1497 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1498 }
1499 }
1500
1501 return 0;
1502 }
1503
1504 static int opt_target(void *optctx, const char *opt, const char *arg)
1505 {
1506 OptionsContext *o = optctx;
1507 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1508 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1509
1510 if (!strncmp(arg, "pal-", 4)) {
1511 norm = PAL;
1512 arg += 4;
1513 } else if (!strncmp(arg, "ntsc-", 5)) {
1514 norm = NTSC;
1515 arg += 5;
1516 } else if (!strncmp(arg, "film-", 5)) {
1517 norm = FILM;
1518 arg += 5;
1519 } else {
1520 /* Try to determine PAL/NTSC by peeking in the input files */
1521 if (nb_input_files) {
1522 int i, j, fr;
1523 for (j = 0; j < nb_input_files; j++) {
1524 for (i = 0; i < input_files[j]->nb_streams; i++) {
1525 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1526 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1527 continue;
1528 fr = c->time_base.den * 1000 / c->time_base.num;
1529 if (fr == 25000) {
1530 norm = PAL;
1531 break;
1532 } else if ((fr == 29970) || (fr == 23976)) {
1533 norm = NTSC;
1534 break;
1535 }
1536 }
1537 if (norm != UNKNOWN)
1538 break;
1539 }
1540 }
1541 if (norm != UNKNOWN)
1542 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1543 }
1544
1545 if (norm == UNKNOWN) {
1546 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1547 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1548 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1549 exit(1);
1550 }
1551
1552 if (!strcmp(arg, "vcd")) {
1553 opt_video_codec(o, "c:v", "mpeg1video");
1554 opt_audio_codec(o, "c:a", "mp2");
1555 parse_option(o, "f", "vcd", options);
1556
1557 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1558 parse_option(o, "r", frame_rates[norm], options);
1559 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1560
1561 opt_default(NULL, "b", "1150000");
1562 opt_default(NULL, "maxrate", "1150000");
1563 opt_default(NULL, "minrate", "1150000");
1564 opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1565
1566 opt_default(NULL, "b:a", "224000");
1567 parse_option(o, "ar", "44100", options);
1568 parse_option(o, "ac", "2", options);
1569
1570 opt_default(NULL, "packetsize", "2324");
1571 opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1572
1573 /* We have to offset the PTS, so that it is consistent with the SCR.
1574 SCR starts at 36000, but the first two packs contain only padding
1575 and the first pack from the other stream, respectively, may also have
1576 been written before.
1577 So the real data starts at SCR 36000+3*1200. */
1578 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1579 } else if (!strcmp(arg, "svcd")) {
1580
1581 opt_video_codec(o, "c:v", "mpeg2video");
1582 opt_audio_codec(o, "c:a", "mp2");
1583 parse_option(o, "f", "svcd", options);
1584
1585 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1586 parse_option(o, "r", frame_rates[norm], options);
1587 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1588
1589 opt_default(NULL, "b", "2040000");
1590 opt_default(NULL, "maxrate", "2516000");
1591 opt_default(NULL, "minrate", "0"); // 1145000;
1592 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1593 opt_default(NULL, "flags", "+scan_offset");
1594
1595
1596 opt_default(NULL, "b:a", "224000");
1597 parse_option(o, "ar", "44100", options);
1598
1599 opt_default(NULL, "packetsize", "2324");
1600
1601 } else if (!strcmp(arg, "dvd")) {
1602
1603 opt_video_codec(o, "c:v", "mpeg2video");
1604 opt_audio_codec(o, "c:a", "ac3");
1605 parse_option(o, "f", "dvd", options);
1606
1607 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1608 parse_option(o, "r", frame_rates[norm], options);
1609 opt_default(NULL, "g", norm == PAL ? "15" : "18");
1610
1611 opt_default(NULL, "b", "6000000");
1612 opt_default(NULL, "maxrate", "9000000");
1613 opt_default(NULL, "minrate", "0"); // 1500000;
1614 opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1615
1616 opt_default(NULL, "packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1617 opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1618
1619 opt_default(NULL, "b:a", "448000");
1620 parse_option(o, "ar", "48000", options);
1621
1622 } else if (!strncmp(arg, "dv", 2)) {
1623
1624 parse_option(o, "f", "dv", options);
1625
1626 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1627 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1628 norm == PAL ? "yuv420p" : "yuv411p", options);
1629 parse_option(o, "r", frame_rates[norm], options);
1630
1631 parse_option(o, "ar", "48000", options);
1632 parse_option(o, "ac", "2", options);
1633
1634 } else {
1635 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1636 return AVERROR(EINVAL);
1637 }
1638 return 0;
1639 }
1640
1641 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1642 {
1643 av_free (vstats_filename);
1644 vstats_filename = av_strdup (arg);
1645 return 0;
1646 }
1647
1648 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1649 {
1650 char filename[40];
1651 time_t today2 = time(NULL);
1652 struct tm *today = localtime(&today2);
1653
1654 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1655 today->tm_sec);
1656 return opt_vstats_file(NULL, opt, filename);
1657 }
1658
1659 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1660 {
1661 OptionsContext *o = optctx;
1662 return parse_option(o, "frames:v", arg, options);
1663 }
1664
1665 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1666 {
1667 OptionsContext *o = optctx;
1668 return parse_option(o, "frames:a", arg, options);
1669 }
1670
1671 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1672 {
1673 OptionsContext *o = optctx;
1674 return parse_option(o, "frames:d", arg, options);
1675 }
1676
1677 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1678 {
1679 OptionsContext *o = optctx;
1680 return parse_option(o, "tag:v", arg, options);
1681 }
1682
1683 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1684 {
1685 OptionsContext *o = optctx;
1686 return parse_option(o, "tag:a", arg, options);
1687 }
1688
1689 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1690 {
1691 OptionsContext *o = optctx;
1692 return parse_option(o, "tag:s", arg, options);
1693 }
1694
1695 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1696 {
1697 OptionsContext *o = optctx;
1698 return parse_option(o, "filter:v", arg, options);
1699 }
1700
1701 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1702 {
1703 OptionsContext *o = optctx;
1704 return parse_option(o, "filter:a", arg, options);
1705 }
1706
1707 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1708 {
1709 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
1710 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
1711 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1712
1713 if (video_sync_method == VSYNC_AUTO)
1714 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1715 return 0;
1716 }
1717
1718 #if FF_API_DEINTERLACE
1719 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1720 {
1721 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1722 do_deinterlace = 1;
1723 return 0;
1724 }
1725 #endif
1726
1727 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1728 {
1729 int flags = av_parse_cpu_flags(arg);
1730
1731 if (flags < 0)
1732 return flags;
1733
1734 av_set_cpu_flags_mask(flags);
1735 return 0;
1736 }
1737
1738 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1739 {
1740 OptionsContext *o = optctx;
1741 char layout_str[32];
1742 char *stream_str;
1743 char *ac_str;
1744 int ret, channels, ac_str_size;
1745 uint64_t layout;
1746
1747 layout = av_get_channel_layout(arg);
1748 if (!layout) {
1749 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1750 return AVERROR(EINVAL);
1751 }
1752 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1753 ret = opt_default(NULL, opt, layout_str);
1754 if (ret < 0)
1755 return ret;
1756
1757 /* set 'ac' option based on channel layout */
1758 channels = av_get_channel_layout_nb_channels(layout);
1759 snprintf(layout_str, sizeof(layout_str), "%d", channels);
1760 stream_str = strchr(opt, ':');
1761 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1762 ac_str = av_mallocz(ac_str_size);
1763 if (!ac_str)
1764 return AVERROR(ENOMEM);
1765 av_strlcpy(ac_str, "ac", 3);
1766 if (stream_str)
1767 av_strlcat(ac_str, stream_str, ac_str_size);
1768 ret = parse_option(o, ac_str, layout_str, options);
1769 av_free(ac_str);
1770
1771 return ret;
1772 }
1773
1774 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1775 {
1776 OptionsContext *o = optctx;
1777 return parse_option(o, "q:a", arg, options);
1778 }
1779
1780 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1781 {
1782 GROW_ARRAY(filtergraphs, nb_filtergraphs);
1783 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1784 return AVERROR(ENOMEM);
1785 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
1786 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1787 return 0;
1788 }
1789
1790 void show_help_default(const char *opt, const char *arg)
1791 {
1792 /* per-file options have at least one of those set */
1793 const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1794 int show_advanced = 0, show_avoptions = 0;
1795
1796 if (opt && *opt) {
1797 if (!strcmp(opt, "long"))
1798 show_advanced = 1;
1799 else if (!strcmp(opt, "full"))
1800 show_advanced = show_avoptions = 1;
1801 else
1802 av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1803 }
1804
1805 show_usage();
1806
1807 printf("Getting help:\n"
1808 " -h -- print basic options\n"
1809 " -h long -- print more options\n"
1810 " -h full -- print all options (including all format and codec specific options, very long)\n"
1811 " See man %s for detailed description of the options.\n"
1812 "\n", program_name);
1813
1814 show_help_options(options, "Print help / information / capabilities:",
1815 OPT_EXIT, 0, 0);
1816
1817 show_help_options(options, "Global options (affect whole program "
1818 "instead of just one file:",
1819 0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1820 if (show_advanced)
1821 show_help_options(options, "Advanced global options:", OPT_EXPERT,
1822 per_file | OPT_EXIT, 0);
1823
1824 show_help_options(options, "Per-file main options:", 0,
1825 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1826 OPT_EXIT, per_file);
1827 if (show_advanced)
1828 show_help_options(options, "Advanced per-file options:",
1829 OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1830
1831 show_help_options(options, "Video options:",
1832 OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1833 if (show_advanced)
1834 show_help_options(options, "Advanced Video options:",
1835 OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1836
1837 show_help_options(options, "Audio options:",
1838 OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1839 if (show_advanced)
1840 show_help_options(options, "Advanced Audio options:",
1841 OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1842 show_help_options(options, "Subtitle options:",
1843 OPT_SUBTITLE, 0, 0);
1844 printf("\n");
1845
1846 if (show_avoptions) {
1847 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1848 show_help_children(avcodec_get_class(), flags);
1849 show_help_children(avformat_get_class(), flags);
1850 show_help_children(sws_get_class(), flags);
1851 }
1852 }
1853
1854 void show_usage(void)
1855 {
1856 printf("Hyper fast Audio and Video encoder\n");
1857 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1858 printf("\n");
1859 }
1860
1861 enum OptGroup {
1862 GROUP_OUTFILE,
1863 GROUP_INFILE,
1864 };
1865
1866 static const OptionGroupDef groups[] = {
1867 [GROUP_OUTFILE] = { "output file", NULL },
1868 [GROUP_INFILE] = { "input file", "i" },
1869 };
1870
1871 static int open_files(OptionGroupList *l, const char *inout,
1872 int (*open_file)(OptionsContext*, const char*))
1873 {
1874 int i, ret;
1875
1876 for (i = 0; i < l->nb_groups; i++) {
1877 OptionGroup *g = &l->groups[i];
1878 OptionsContext o;
1879
1880 init_options(&o);
1881 o.g = g;
1882
1883 ret = parse_optgroup(&o, g);
1884 if (ret < 0) {
1885 av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1886 "%s.\n", inout, g->arg);
1887 return ret;
1888 }
1889
1890 av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1891 ret = open_file(&o, g->arg);
1892 uninit_options(&o);
1893 if (ret < 0) {
1894 av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1895 inout, g->arg);
1896 return ret;
1897 }
1898 av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
1899 }
1900
1901 return 0;
1902 }
1903
1904 int avconv_parse_options(int argc, char **argv)
1905 {
1906 OptionParseContext octx;
1907 uint8_t error[128];
1908 int ret;
1909
1910 memset(&octx, 0, sizeof(octx));
1911
1912 /* split the commandline into an internal representation */
1913 ret = split_commandline(&octx, argc, argv, options, groups,
1914 FF_ARRAY_ELEMS(groups));
1915 if (ret < 0) {
1916 av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1917 goto fail;
1918 }
1919
1920 /* apply global options */
1921 ret = parse_optgroup(NULL, &octx.global_opts);
1922 if (ret < 0) {
1923 av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1924 goto fail;
1925 }
1926
1927 /* open input files */
1928 ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1929 if (ret < 0) {
1930 av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1931 goto fail;
1932 }
1933
1934 /* open output files */
1935 ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1936 if (ret < 0) {
1937 av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1938 goto fail;
1939 }
1940
1941 fail:
1942 uninit_parse_context(&octx);
1943 if (ret < 0) {
1944 av_strerror(ret, error, sizeof(error));
1945 av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1946 }
1947 return ret;
1948 }
1949
1950 #define OFFSET(x) offsetof(OptionsContext, x)
1951 const OptionDef options[] = {
1952 /* main options */
1953 #include "cmdutils_common_opts.h"
1954 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, { .off = OFFSET(format) },
1955 "force format", "fmt" },
1956 { "y", OPT_BOOL, { &file_overwrite },
1957 "overwrite output files" },
1958 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1959 "codec name", "codec" },
1960 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(codec_names) },
1961 "codec name", "codec" },
1962 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(presets) },
1963 "preset name", "preset" },
1964 { "map", HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_map },
1965 "set input stream mapping",
1966 "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1967 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata_map) },
1968 "set metadata information of outfile from infile",
1969 "outfile[,metadata]:infile[,metadata]" },
1970 { "map_chapters", HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1971 "set chapters mapping", "input_file_index" },
1972 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(recording_time) },
1973 "record or transcode \"duration\" seconds of audio/video",
1974 "duration" },
1975 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, { .off = OFFSET(limit_filesize) },
1976 "set the limit file size in bytes", "limit_size" },
1977 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, { .off = OFFSET(start_time) },
1978 "set the start time offset", "time_off" },
1979 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1980 "set the input ts offset", "time_off" },
1981 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1982 "set the input ts scale", "scale" },
1983 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(metadata) },
1984 "add metadata", "string=string" },
1985 { "dframes", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_frames },
1986 "set the number of data frames to record", "number" },
1987 { "benchmark", OPT_BOOL | OPT_EXPERT, { &do_benchmark },
1988 "add timings for benchmarking" },
1989 { "timelimit", HAS_ARG | OPT_EXPERT, { .func_arg = opt_timelimit },
1990 "set max runtime in seconds", "limit" },
1991 { "dump", OPT_BOOL | OPT_EXPERT, { &do_pkt_dump },
1992 "dump each input packet" },
1993 { "hex", OPT_BOOL | OPT_EXPERT, { &do_hex_dump },
1994 "when dumping packets, also dump the payload" },
1995 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(rate_emu) },
1996 "read input at native frame rate", "" },
1997 { "target", HAS_ARG | OPT_PERFILE, { .func_arg = opt_target },
1998 "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1999 " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2000 { "vsync", HAS_ARG | OPT_EXPERT, { opt_vsync },
2001 "video sync method", "" },
2002 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, { &audio_sync_method },
2003 "audio sync method", "" },
2004 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &audio_drift_threshold },
2005 "audio drift threshold", "threshold" },
2006 { "copyts", OPT_BOOL | OPT_EXPERT, { &copy_ts },
2007 "copy timestamps" },
2008 { "copytb", OPT_BOOL | OPT_EXPERT, { &copy_tb },
2009 "copy input stream time base when stream copying" },
2010 { "shortest", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(shortest) },
2011 "finish encoding within shortest input" },
2012 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, { &dts_delta_threshold },
2013 "timestamp discontinuity delta threshold", "threshold" },
2014 { "xerror", OPT_BOOL | OPT_EXPERT, { &exit_on_error },
2015 "exit on error", "error" },
2016 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(copy_initial_nonkeyframes) },
2017 "copy initial non-keyframes" },
2018 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, { .off = OFFSET(max_frames) },
2019 "set the number of frames to record", "number" },
2020 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2021 "force codec tag/fourcc", "fourcc/tag" },
2022 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2023 "use fixed quality scale (VBR)", "q" },
2024 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2025 "use fixed quality scale (VBR)", "q" },
2026 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(filters) },
2027 "set stream filterchain", "filter_list" },
2028 { "filter_complex", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_complex },
2029 "create a complex filtergraph", "graph_description" },
2030 { "stats", OPT_BOOL, { &print_stats },
2031 "print progress report during encoding", },
2032 { "attach", HAS_ARG | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_attach },
2033 "add an attachment to the output file", "filename" },
2034 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2035 "extract an attachment into a file", "filename" },
2036 { "cpuflags", HAS_ARG | OPT_EXPERT, { .func_arg = opt_cpuflags },
2037 "set CPU flags mask", "mask" },
2038
2039 /* video options */
2040 { "vframes", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_frames },
2041 "set the number of video frames to record", "number" },
2042 { "r", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_rates) },
2043 "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2044 { "s", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_sizes) },
2045 "set frame size (WxH or abbreviation)", "size" },
2046 { "aspect", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_aspect_ratios) },
2047 "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2048 { "pix_fmt", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2049 "set pixel format", "format" },
2050 { "vn", OPT_VIDEO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(video_disable) },
2051 "disable video" },
2052 { "vdt", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &video_discard },
2053 "discard threshold", "n" },
2054 { "rc_override", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2055 "rate control override for specific intervals", "override" },
2056 { "vcodec", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_codec },
2057 "force video codec ('copy' to copy stream)", "codec" },
2058 { "pass", OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT, { .off = OFFSET(pass) },
2059 "select the pass number (1 or 2)", "n" },
2060 { "passlogfile", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(passlogfiles) },
2061 "select two pass log file name prefix", "prefix" },
2062 #if FF_API_DEINTERLACE
2063 { "deinterlace", OPT_VIDEO | OPT_EXPERT , { .func_arg = opt_deinterlace },
2064 "this option is deprecated, use the yadif filter instead" },
2065 #endif
2066 { "vstats", OPT_VIDEO | OPT_EXPERT , { &opt_vstats },
2067 "dump video coding statistics to file" },
2068 { "vstats_file", OPT_VIDEO | HAS_ARG | OPT_EXPERT , { opt_vstats_file },
2069 "dump video coding statistics to file", "file" },
2070 { "vf", OPT_VIDEO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_video_filters },
2071 "video filters", "filter list" },
2072 { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2073 "specify intra matrix coeffs", "matrix" },
2074 { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2075 "specify inter matrix coeffs", "matrix" },
2076 { "top", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_INT| OPT_SPEC, { .off = OFFSET(top_field_first) },
2077 "top=1/bottom=0/auto=-1 field first", "" },
2078 { "dc", OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT , { &intra_dc_precision },
2079 "intra_dc_precision", "precision" },
2080 { "vtag", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_video_tag },
2081 "force video tag/fourcc", "fourcc/tag" },
2082 { "qphist", OPT_VIDEO | OPT_BOOL | OPT_EXPERT , { &qp_hist },
2083 "show QP histogram" },
2084 { "force_fps", OPT_VIDEO | OPT_BOOL | OPT_EXPERT | OPT_SPEC, { .off = OFFSET(force_fps) },
2085 "force the selected framerate, disable the best supported framerate selection" },
2086 { "streamid", OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_streamid },
2087 "set the value of an outfile streamid", "streamIndex:value" },
2088 { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_SPEC,
2089 { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2090
2091 /* audio options */
2092 { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_frames },
2093 "set the number of audio frames to record", "number" },
2094 { "aq", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_qscale },
2095 "set audio quality (codec-specific)", "quality", },
2096 { "ar", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_sample_rate) },
2097 "set audio sampling rate (in Hz)", "rate" },
2098 { "ac", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC, { .off = OFFSET(audio_channels) },
2099 "set number of audio channels", "channels" },
2100 { "an", OPT_AUDIO | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(audio_disable) },
2101 "disable audio" },
2102 { "acodec", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_codec },
2103 "force audio codec ('copy' to copy stream)", "codec" },
2104 { "atag", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_audio_tag },
2105 "force audio tag/fourcc", "fourcc/tag" },
2106 { "vol", OPT_AUDIO | HAS_ARG | OPT_INT, { &audio_volume },
2107 "change audio volume (256=normal)" , "volume" },
2108 { "sample_fmt", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2109 "set sample format", "format" },
2110 { "channel_layout", OPT_AUDIO | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_channel_layout },
2111 "set channel layout", "layout" },
2112 { "af", OPT_AUDIO | HAS_ARG | OPT_PERFILE, { .func_arg = opt_audio_filters },
2113 "audio filters", "filter list" },
2114
2115 /* subtitle options */
2116 { "sn", OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2117 "disable subtitle" },
2118 { "scodec", OPT_SUBTITLE | HAS_ARG | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2119 "force subtitle codec ('copy' to copy stream)", "codec" },
2120 { "stag", OPT_SUBTITLE | HAS_ARG | OPT_EXPERT | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2121 , "force subtitle tag/fourcc", "fourcc/tag" },
2122
2123 /* grab options */
2124 { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2125
2126 /* muxer options */
2127 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2128 "set the maximum demux-decode delay", "seconds" },
2129 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2130 "set the initial demux-decode delay", "seconds" },
2131
2132 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2133 "A comma-separated list of bitstream filters", "bitstream_filters" },
2134
2135 /* data codec support */
2136 { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2137 "force data codec ('copy' to copy stream)", "codec" },
2138
2139 { NULL, },
2140 };
A couple of patches to make building with MPlayer easier