avconv_opt.c

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