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