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(1);\
  54     }\
  55 }
  56
  57 char *vstats_filename;
  58
  59 float audio_drift_threshold = 0.1;
  60 float dts_delta_threshold   = 10;
  61
  62 int audio_volume      = 256;
  63 int audio_sync_method = 0;
  64 int video_sync_method = VSYNC_AUTO;
  65 int do_deinterlace    = 0;
  66 int do_benchmark      = 0;
  67 int do_hex_dump       = 0;
  68 int do_pkt_dump       = 0;
  69 int copy_ts           = 0;
  70 int copy_tb           = 1;
  71 int exit_on_error     = 0;
  72 int print_stats       = 1;
  73 int qp_hist           = 0;
  74
  75 static int file_overwrite     = 0;
  76 static int video_discard      = 0;
  77 static int intra_dc_precision = 8;
  78 static int using_stdin        = 0;
  79 static int input_sync;
  80
  81 void reset_options(OptionsContext *o)
  82 {
  83     const OptionDef *po = options;
  84     int i;
  85
  86     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
  87     while (po->name) {
  88         void *dst = (uint8_t*)o + po->u.off;
  89
  90         if (po->flags & OPT_SPEC) {
  91             SpecifierOpt **so = dst;
  92             int i, *count = (int*)(so + 1);
  93             for (i = 0; i < *count; i++) {
  94                 av_freep(&(*so)[i].specifier);
  95                 if (po->flags & OPT_STRING)
  96                     av_freep(&(*so)[i].u.str);
  97             }
  98             av_freep(so);
  99             *count = 0;
 100         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 101             av_freep(dst);
 102         po++;
 103     }
 104
 105     for (i = 0; i < o->nb_stream_maps; i++)
 106         av_freep(&o->stream_maps[i].linklabel);
 107     av_freep(&o->stream_maps);
 108     av_freep(&o->meta_data_maps);
 109     av_freep(&o->streamid_map);
 110
 111     memset(o, 0, sizeof(*o));
 112
 113     o->mux_max_delay  = 0.7;
 114     o->recording_time = INT64_MAX;
 115     o->limit_filesize = UINT64_MAX;
 116     o->chapters_input_file = INT_MAX;
 117
 118     uninit_opts();
 119     init_opts();
 120 }
 121
 122
 123 static double parse_frame_aspect_ratio(const char *arg)
 124 {
 125     int x = 0, y = 0;
 126     double ar = 0;
 127     const char *p;
 128     char *end;
 129
 130     p = strchr(arg, ':');
 131     if (p) {
 132         x = strtol(arg, &end, 10);
 133         if (end == p)
 134             y = strtol(end + 1, &end, 10);
 135         if (x > 0 && y > 0)
 136             ar = (double)x / (double)y;
 137     } else
 138         ar = strtod(arg, NULL);
 139
 140     if (!ar) {
 141         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
 142         exit(1);
 143     }
 144     return ar;
 145 }
 146
 147 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 148 {
 149     OptionsContext *o = optctx;
 150     return parse_option(o, "codec:a", arg, options);
 151 }
 152
 153 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 154 {
 155     OptionsContext *o = optctx;
 156     return parse_option(o, "codec:v", arg, options);
 157 }
 158
 159 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 160 {
 161     OptionsContext *o = optctx;
 162     return parse_option(o, "codec:s", arg, options);
 163 }
 164
 165 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 166 {
 167     OptionsContext *o = optctx;
 168     return parse_option(o, "codec:d", arg, options);
 169 }
 170
 171 static int opt_map(void *optctx, const char *opt, const char *arg)
 172 {
 173     OptionsContext *o = optctx;
 174     StreamMap *m = NULL;
 175     int i, negative = 0, file_idx;
 176     int sync_file_idx = -1, sync_stream_idx;
 177     char *p, *sync;
 178     char *map;
 179
 180     if (*arg == '-') {
 181         negative = 1;
 182         arg++;
 183     }
 184     map = av_strdup(arg);
 185
 186     /* parse sync stream first, just pick first matching stream */
 187     if (sync = strchr(map, ',')) {
 188         *sync = 0;
 189         sync_file_idx = strtol(sync + 1, &sync, 0);
 190         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 191             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 192             exit(1);
 193         }
 194         if (*sync)
 195             sync++;
 196         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 197             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 198                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 199                 sync_stream_idx = i;
 200                 break;
 201             }
 202         if (i == input_files[sync_file_idx]->nb_streams) {
 203             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 204                                        "match any streams.\n", arg);
 205             exit(1);
 206         }
 207     }
 208
 209
 210     if (map[0] == '[') {
 211         /* this mapping refers to lavfi output */
 212         const char *c = map + 1;
 213         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 214                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
 215         m = &o->stream_maps[o->nb_stream_maps - 1];
 216         m->linklabel = av_get_token(&c, "]");
 217         if (!m->linklabel) {
 218             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 219             exit(1);
 220         }
 221     } else {
 222         file_idx = strtol(map, &p, 0);
 223         if (file_idx >= nb_input_files || file_idx < 0) {
 224             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 225             exit(1);
 226         }
 227         if (negative)
 228             /* disable some already defined maps */
 229             for (i = 0; i < o->nb_stream_maps; i++) {
 230                 m = &o->stream_maps[i];
 231                 if (file_idx == m->file_index &&
 232                     check_stream_specifier(input_files[m->file_index]->ctx,
 233                                            input_files[m->file_index]->ctx->streams[m->stream_index],
 234                                            *p == ':' ? p + 1 : p) > 0)
 235                     m->disabled = 1;
 236             }
 237         else
 238             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 239                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 240                             *p == ':' ? p + 1 : p) <= 0)
 241                     continue;
 242                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 243                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
 244                 m = &o->stream_maps[o->nb_stream_maps - 1];
 245
 246                 m->file_index   = file_idx;
 247                 m->stream_index = i;
 248
 249                 if (sync_file_idx >= 0) {
 250                     m->sync_file_index   = sync_file_idx;
 251                     m->sync_stream_index = sync_stream_idx;
 252                 } else {
 253                     m->sync_file_index   = file_idx;
 254                     m->sync_stream_index = i;
 255                 }
 256             }
 257     }
 258
 259     if (!m) {
 260         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 261         exit(1);
 262     }
 263
 264     av_freep(&map);
 265     return 0;
 266 }
 267
 268 static int opt_attach(void *optctx, const char *opt, const char *arg)
 269 {
 270     OptionsContext *o = optctx;
 271     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
 272                                 &o->nb_attachments, o->nb_attachments + 1);
 273     o->attachments[o->nb_attachments - 1] = arg;
 274     return 0;
 275 }
 276
 277 /**
 278  * Parse a metadata specifier passed as 'arg' parameter.
 279  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 280  * @param index for type c/p, chapter/program index is written here
 281  * @param stream_spec for type s, the stream specifier is written here
 282  */
 283 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 284 {
 285     if (*arg) {
 286         *type = *arg;
 287         switch (*arg) {
 288         case 'g':
 289             break;
 290         case 's':
 291             if (*(++arg) && *arg != ':') {
 292                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 293                 exit(1);
 294             }
 295             *stream_spec = *arg == ':' ? arg + 1 : "";
 296             break;
 297         case 'c':
 298         case 'p':
 299             if (*(++arg) == ':')
 300                 *index = strtol(++arg, NULL, 0);
 301             break;
 302         default:
 303             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 304             exit(1);
 305         }
 306     } else
 307         *type = 'g';
 308 }
 309
 310 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 311 {
 312     AVDictionary **meta_in = NULL;
 313     AVDictionary **meta_out;
 314     int i, ret = 0;
 315     char type_in, type_out;
 316     const char *istream_spec = NULL, *ostream_spec = NULL;
 317     int idx_in = 0, idx_out = 0;
 318
 319     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 320     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 321
 322     if (type_in == 'g' || type_out == 'g')
 323         o->metadata_global_manual = 1;
 324     if (type_in == 's' || type_out == 's')
 325         o->metadata_streams_manual = 1;
 326     if (type_in == 'c' || type_out == 'c')
 327         o->metadata_chapters_manual = 1;
 328
 329     /* ic is NULL when just disabling automatic mappings */
 330     if (!ic)
 331         return 0;
 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(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(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(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(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(1);
 409     }
 410     if (codec->type != type) {
 411         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 412         exit(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 /* Add all the streams from the given input file to the global
 431  * list of input streams. */
 432 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 433 {
 434     int i;
 435
 436     for (i = 0; i < ic->nb_streams; i++) {
 437         AVStream *st = ic->streams[i];
 438         AVCodecContext *dec = st->codec;
 439         InputStream *ist = av_mallocz(sizeof(*ist));
 440         char *framerate = NULL;
 441
 442         if (!ist)
 443             exit(1);
 444
 445         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
 446         input_streams[nb_input_streams - 1] = ist;
 447
 448         ist->st = st;
 449         ist->file_index = nb_input_files;
 450         ist->discard = 1;
 451         st->discard  = AVDISCARD_ALL;
 452         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, NULL);
 453
 454         ist->ts_scale = 1.0;
 455         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 456
 457         ist->dec = choose_decoder(o, ic, st);
 458
 459         switch (dec->codec_type) {
 460         case AVMEDIA_TYPE_VIDEO:
 461             ist->resample_height  = dec->height;
 462             ist->resample_width   = dec->width;
 463             ist->resample_pix_fmt = dec->pix_fmt;
 464
 465             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 466             if (framerate && av_parse_video_rate(&ist->framerate,
 467                                                  framerate) < 0) {
 468                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 469                        framerate);
 470                 exit(1);
 471             }
 472
 473             break;
 474         case AVMEDIA_TYPE_AUDIO:
 475             guess_input_channel_layout(ist);
 476
 477             ist->resample_sample_fmt     = dec->sample_fmt;
 478             ist->resample_sample_rate    = dec->sample_rate;
 479             ist->resample_channels       = dec->channels;
 480             ist->resample_channel_layout = dec->channel_layout;
 481
 482             break;
 483         case AVMEDIA_TYPE_DATA:
 484         case AVMEDIA_TYPE_SUBTITLE:
 485         case AVMEDIA_TYPE_ATTACHMENT:
 486         case AVMEDIA_TYPE_UNKNOWN:
 487             break;
 488         default:
 489             abort();
 490         }
 491     }
 492 }
 493
 494 static void assert_file_overwrite(const char *filename)
 495 {
 496     if (!file_overwrite &&
 497         (strchr(filename, ':') == NULL || filename[1] == ':' ||
 498          av_strstart(filename, "file:", NULL))) {
 499         if (avio_check(filename, 0) == 0) {
 500             if (!using_stdin) {
 501                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 502                 fflush(stderr);
 503                 if (!read_yesno()) {
 504                     fprintf(stderr, "Not overwriting - exiting\n");
 505                     exit(1);
 506                 }
 507             }
 508             else {
 509                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
 510                 exit(1);
 511             }
 512         }
 513     }
 514 }
 515
 516 static void dump_attachment(AVStream *st, const char *filename)
 517 {
 518     int ret;
 519     AVIOContext *out = NULL;
 520     AVDictionaryEntry *e;
 521
 522     if (!st->codec->extradata_size) {
 523         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 524                nb_input_files - 1, st->index);
 525         return;
 526     }
 527     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 528         filename = e->value;
 529     if (!*filename) {
 530         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 531                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 532         exit(1);
 533     }
 534
 535     assert_file_overwrite(filename);
 536
 537     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 538         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 539                filename);
 540         exit(1);
 541     }
 542
 543     avio_write(out, st->codec->extradata, st->codec->extradata_size);
 544     avio_flush(out);
 545     avio_close(out);
 546 }
 547
 548 static int opt_input_file(void *optctx, const char *opt, const char *filename)
 549 {
 550     OptionsContext *o = optctx;
 551     AVFormatContext *ic;
 552     AVInputFormat *file_iformat = NULL;
 553     int err, i, ret;
 554     int64_t timestamp;
 555     uint8_t buf[128];
 556     AVDictionary **opts;
 557     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
 558
 559     if (o->format) {
 560         if (!(file_iformat = av_find_input_format(o->format))) {
 561             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
 562             exit(1);
 563         }
 564     }
 565
 566     if (!strcmp(filename, "-"))
 567         filename = "pipe:";
 568
 569     using_stdin |= !strncmp(filename, "pipe:", 5) ||
 570                     !strcmp(filename, "/dev/stdin");
 571
 572     /* get default parameters from command line */
 573     ic = avformat_alloc_context();
 574     if (!ic) {
 575         print_error(filename, AVERROR(ENOMEM));
 576         exit(1);
 577     }
 578     if (o->nb_audio_sample_rate) {
 579         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
 580         av_dict_set(&format_opts, "sample_rate", buf, 0);
 581     }
 582     if (o->nb_audio_channels) {
 583         /* because we set audio_channels based on both the "ac" and
 584          * "channel_layout" options, we need to check that the specified
 585          * demuxer actually has the "channels" option before setting it */
 586         if (file_iformat && file_iformat->priv_class &&
 587             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
 588                         AV_OPT_SEARCH_FAKE_OBJ)) {
 589             snprintf(buf, sizeof(buf), "%d",
 590                      o->audio_channels[o->nb_audio_channels - 1].u.i);
 591             av_dict_set(&format_opts, "channels", buf, 0);
 592         }
 593     }
 594     if (o->nb_frame_rates) {
 595         /* set the format-level framerate option;
 596          * this is important for video grabbers, e.g. x11 */
 597         if (file_iformat && file_iformat->priv_class &&
 598             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
 599                         AV_OPT_SEARCH_FAKE_OBJ)) {
 600             av_dict_set(&format_opts, "framerate",
 601                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
 602         }
 603     }
 604     if (o->nb_frame_sizes) {
 605         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
 606     }
 607     if (o->nb_frame_pix_fmts)
 608         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
 609
 610     ic->flags |= AVFMT_FLAG_NONBLOCK;
 611     ic->interrupt_callback = int_cb;
 612
 613     /* open the input file with generic libav function */
 614     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
 615     if (err < 0) {
 616         print_error(filename, err);
 617         exit(1);
 618     }
 619     assert_avoptions(format_opts);
 620
 621     /* apply forced codec ids */
 622     for (i = 0; i < ic->nb_streams; i++)
 623         choose_decoder(o, ic, ic->streams[i]);
 624
 625     /* Set AVCodecContext options for avformat_find_stream_info */
 626     opts = setup_find_stream_info_opts(ic, codec_opts);
 627     orig_nb_streams = ic->nb_streams;
 628
 629     /* If not enough info to get the stream parameters, we decode the
 630        first frames to get it. (used in mpeg case for example) */
 631     ret = avformat_find_stream_info(ic, opts);
 632     if (ret < 0) {
 633         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
 634         avformat_close_input(&ic);
 635         exit(1);
 636     }
 637
 638     timestamp = o->start_time;
 639     /* add the stream start time */
 640     if (ic->start_time != AV_NOPTS_VALUE)
 641         timestamp += ic->start_time;
 642
 643     /* if seeking requested, we execute it */
 644     if (o->start_time != 0) {
 645         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 646         if (ret < 0) {
 647             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
 648                    filename, (double)timestamp / AV_TIME_BASE);
 649         }
 650     }
 651
 652     /* update the current parameters so that they match the one of the input stream */
 653     add_input_streams(o, ic);
 654
 655     /* dump the file content */
 656     av_dump_format(ic, nb_input_files, filename, 0);
 657
 658     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
 659     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
 660         exit(1);
 661
 662     input_files[nb_input_files - 1]->ctx        = ic;
 663     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
 664     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 665     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
 666     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
 667
 668     for (i = 0; i < o->nb_dump_attachment; i++) {
 669         int j;
 670
 671         for (j = 0; j < ic->nb_streams; j++) {
 672             AVStream *st = ic->streams[j];
 673
 674             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 675                 dump_attachment(st, o->dump_attachment[i].u.str);
 676         }
 677     }
 678
 679     for (i = 0; i < orig_nb_streams; i++)
 680         av_dict_free(&opts[i]);
 681     av_freep(&opts);
 682
 683     reset_options(o);
 684     return 0;
 685 }
 686
 687 static uint8_t *get_line(AVIOContext *s)
 688 {
 689     AVIOContext *line;
 690     uint8_t *buf;
 691     char c;
 692
 693     if (avio_open_dyn_buf(&line) < 0) {
 694         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 695         exit(1);
 696     }
 697
 698     while ((c = avio_r8(s)) && c != '\n')
 699         avio_w8(line, c);
 700     avio_w8(line, 0);
 701     avio_close_dyn_buf(line, &buf);
 702
 703     return buf;
 704 }
 705
 706 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 707 {
 708     int i, ret = 1;
 709     char filename[1000];
 710     const char *base[3] = { getenv("AVCONV_DATADIR"),
 711                             getenv("HOME"),
 712                             AVCONV_DATADIR,
 713                             };
 714
 715     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 716         if (!base[i])
 717             continue;
 718         if (codec_name) {
 719             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 720                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 721             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 722         }
 723         if (ret) {
 724             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 725                      i != 1 ? "" : "/.avconv", preset_name);
 726             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 727         }
 728     }
 729     return ret;
 730 }
 731
 732 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 733 {
 734     char *codec_name = NULL;
 735
 736     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 737     if (!codec_name) {
 738         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 739                                                   NULL, ost->st->codec->codec_type);
 740         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 741     } else if (!strcmp(codec_name, "copy"))
 742         ost->stream_copy = 1;
 743     else {
 744         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 745         ost->st->codec->codec_id = ost->enc->id;
 746     }
 747 }
 748
 749 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
 750 {
 751     OutputStream *ost;
 752     AVStream *st = avformat_new_stream(oc, NULL);
 753     int idx      = oc->nb_streams - 1, ret = 0;
 754     char *bsf = NULL, *next, *codec_tag = NULL;
 755     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 756     double qscale = -1;
 757
 758     if (!st) {
 759         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 760         exit(1);
 761     }
 762
 763     if (oc->nb_streams - 1 < o->nb_streamid_map)
 764         st->id = o->streamid_map[oc->nb_streams - 1];
 765
 766     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
 767                                 nb_output_streams + 1);
 768     if (!(ost = av_mallocz(sizeof(*ost))))
 769         exit(1);
 770     output_streams[nb_output_streams - 1] = ost;
 771
 772     ost->file_index = nb_output_files;
 773     ost->index      = idx;
 774     ost->st         = st;
 775     st->codec->codec_type = type;
 776     choose_encoder(o, oc, ost);
 777     if (ost->enc) {
 778         AVIOContext *s = NULL;
 779         char *buf = NULL, *arg = NULL, *preset = NULL;
 780
 781         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
 782
 783         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 784         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 785             do  {
 786                 buf = get_line(s);
 787                 if (!buf[0] || buf[0] == '#') {
 788                     av_free(buf);
 789                     continue;
 790                 }
 791                 if (!(arg = strchr(buf, '='))) {
 792                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 793                     exit(1);
 794                 }
 795                 *arg++ = 0;
 796                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 797                 av_free(buf);
 798             } while (!s->eof_reached);
 799             avio_close(s);
 800         }
 801         if (ret) {
 802             av_log(NULL, AV_LOG_FATAL,
 803                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
 804                    preset, ost->file_index, ost->index);
 805             exit(1);
 806         }
 807     }
 808
 809     avcodec_get_context_defaults3(st->codec, ost->enc);
 810     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 811
 812     ost->max_frames = INT64_MAX;
 813     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 814
 815     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 816     while (bsf) {
 817         if (next = strchr(bsf, ','))
 818             *next++ = 0;
 819         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 820             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 821             exit(1);
 822         }
 823         if (bsfc_prev)
 824             bsfc_prev->next = bsfc;
 825         else
 826             ost->bitstream_filters = bsfc;
 827
 828         bsfc_prev = bsfc;
 829         bsf       = next;
 830     }
 831
 832     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 833     if (codec_tag) {
 834         uint32_t tag = strtol(codec_tag, &next, 0);
 835         if (*next)
 836             tag = AV_RL32(codec_tag);
 837         st->codec->codec_tag = tag;
 838     }
 839
 840     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 841     if (qscale >= 0) {
 842         st->codec->flags |= CODEC_FLAG_QSCALE;
 843         st->codec->global_quality = FF_QP2LAMBDA * qscale;
 844     }
 845
 846     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 847         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
 848
 849     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
 850
 851     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
 852
 853     return ost;
 854 }
 855
 856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 857 {
 858     int i;
 859     const char *p = str;
 860     for (i = 0;; i++) {
 861         dest[i] = atoi(p);
 862         if (i == 63)
 863             break;
 864         p = strchr(p, ',');
 865         if (!p) {
 866             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
 867             exit(1);
 868         }
 869         p++;
 870     }
 871 }
 872
 873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
 874 {
 875     AVStream *st;
 876     OutputStream *ost;
 877     AVCodecContext *video_enc;
 878
 879     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
 880     st  = ost->st;
 881     video_enc = st->codec;
 882
 883     if (!ost->stream_copy) {
 884         const char *p = NULL;
 885         char *frame_rate = NULL, *frame_size = NULL;
 886         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
 887         char *intra_matrix = NULL, *inter_matrix = NULL;
 888         const char *filters = "null";
 889         int do_pass = 0;
 890         int i;
 891
 892         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
 893         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
 894             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
 895             exit(1);
 896         }
 897
 898         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
 899         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
 900             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
 901             exit(1);
 902         }
 903
 904         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
 905         if (frame_aspect_ratio)
 906             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
 907
 908         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
 909         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
 910             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
 911             exit(1);
 912         }
 913         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
 914
 915         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
 916         if (intra_matrix) {
 917             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
 918                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
 919                 exit(1);
 920             }
 921             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
 922         }
 923         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
 924         if (inter_matrix) {
 925             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
 926                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
 927                 exit(1);
 928             }
 929             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
 930         }
 931
 932         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
 933         for (i = 0; p; i++) {
 934             int start, end, q;
 935             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
 936             if (e != 3) {
 937                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
 938                 exit(1);
 939             }
 940             video_enc->rc_override =
 941                 av_realloc(video_enc->rc_override,
 942                            sizeof(RcOverride) * (i + 1));
 943             video_enc->rc_override[i].start_frame = start;
 944             video_enc->rc_override[i].end_frame   = end;
 945             if (q > 0) {
 946                 video_enc->rc_override[i].qscale         = q;
 947                 video_enc->rc_override[i].quality_factor = 1.0;
 948             }
 949             else {
 950                 video_enc->rc_override[i].qscale         = 0;
 951                 video_enc->rc_override[i].quality_factor = -q/100.0;
 952             }
 953             p = strchr(p, '/');
 954             if (p) p++;
 955         }
 956         video_enc->rc_override_count = i;
 957         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         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
 963         if (do_pass) {
 964             if (do_pass == 1) {
 965                 video_enc->flags |= CODEC_FLAG_PASS1;
 966             } else {
 967                 video_enc->flags |= CODEC_FLAG_PASS2;
 968             }
 969         }
 970
 971         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
 972         if (ost->logfile_prefix &&
 973             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
 974             exit(1);
 975
 976         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
 977         if (ost->forced_keyframes)
 978             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
 979
 980         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
 981
 982         ost->top_field_first = -1;
 983         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
 984
 985         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
 986         ost->avfilter = av_strdup(filters);
 987     } else {
 988         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
 989     }
 990
 991     return ost;
 992 }
 993
 994 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
 995 {
 996     AVStream *st;
 997     OutputStream *ost;
 998     AVCodecContext *audio_enc;
 999
1000     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1001     st  = ost->st;
1002
1003     audio_enc = st->codec;
1004     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1005
1006     if (!ost->stream_copy) {
1007         char *sample_fmt = NULL;
1008         const char *filters = "anull";
1009
1010         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1011
1012         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1013         if (sample_fmt &&
1014             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1015             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1016             exit(1);
1017         }
1018
1019         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1020
1021         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1022         ost->avfilter = av_strdup(filters);
1023     }
1024
1025     return ost;
1026 }
1027
1028 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1029 {
1030     OutputStream *ost;
1031
1032     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1033     if (!ost->stream_copy) {
1034         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1035         exit(1);
1036     }
1037
1038     return ost;
1039 }
1040
1041 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1042 {
1043     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1044     ost->stream_copy = 1;
1045     return ost;
1046 }
1047
1048 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1049 {
1050     AVStream *st;
1051     OutputStream *ost;
1052     AVCodecContext *subtitle_enc;
1053
1054     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1055     st  = ost->st;
1056     subtitle_enc = st->codec;
1057
1058     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1059
1060     return ost;
1061 }
1062
1063 /* arg format is "output-stream-index:streamid-value". */
1064 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1065 {
1066     OptionsContext *o = optctx;
1067     int idx;
1068     char *p;
1069     char idx_str[16];
1070
1071     av_strlcpy(idx_str, arg, sizeof(idx_str));
1072     p = strchr(idx_str, ':');
1073     if (!p) {
1074         av_log(NULL, AV_LOG_FATAL,
1075                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1076                arg, opt);
1077         exit(1);
1078     }
1079     *p++ = '\0';
1080     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1081     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1082     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1083     return 0;
1084 }
1085
1086 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1087 {
1088     AVFormatContext *is = ifile->ctx;
1089     AVFormatContext *os = ofile->ctx;
1090     AVChapter **tmp;
1091     int i;
1092
1093     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1094     if (!tmp)
1095         return AVERROR(ENOMEM);
1096     os->chapters = tmp;
1097
1098     for (i = 0; i < is->nb_chapters; i++) {
1099         AVChapter *in_ch = is->chapters[i], *out_ch;
1100         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1101                                        AV_TIME_BASE_Q, in_ch->time_base);
1102         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1103                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1104
1105
1106         if (in_ch->end < ts_off)
1107             continue;
1108         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1109             break;
1110
1111         out_ch = av_mallocz(sizeof(AVChapter));
1112         if (!out_ch)
1113             return AVERROR(ENOMEM);
1114
1115         out_ch->id        = in_ch->id;
1116         out_ch->time_base = in_ch->time_base;
1117         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1118         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1119
1120         if (copy_metadata)
1121             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1122
1123         os->chapters[os->nb_chapters++] = out_ch;
1124     }
1125     return 0;
1126 }
1127
1128 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1129                                AVFormatContext *oc)
1130 {
1131     OutputStream *ost;
1132
1133     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1134                                   ofilter->out_tmp->pad_idx)) {
1135     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1136     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1137     default:
1138         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1139                "currently.\n");
1140         exit(1);
1141     }
1142
1143     ost->source_index = -1;
1144     ost->filter       = ofilter;
1145
1146     ofilter->ost      = ost;
1147
1148     if (ost->stream_copy) {
1149         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1150                "which is fed from a complex filtergraph. Filtering and streamcopy "
1151                "cannot be used together.\n", ost->file_index, ost->index);
1152         exit(1);
1153     }
1154
1155     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1156         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1157         exit(1);
1158     }
1159     avfilter_inout_free(&ofilter->out_tmp);
1160 }
1161
1162 static int configure_complex_filters(void)
1163 {
1164     int i, ret = 0;
1165
1166     for (i = 0; i < nb_filtergraphs; i++)
1167         if (!filtergraphs[i]->graph &&
1168             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1169             return ret;
1170     return 0;
1171 }
1172
1173 void opt_output_file(void *optctx, const char *filename)
1174 {
1175     OptionsContext *o = optctx;
1176     AVFormatContext *oc;
1177     int i, j, err;
1178     AVOutputFormat *file_oformat;
1179     OutputStream *ost;
1180     InputStream  *ist;
1181
1182     if (configure_complex_filters() < 0) {
1183         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1184         exit(1);
1185     }
1186
1187     if (!strcmp(filename, "-"))
1188         filename = "pipe:";
1189
1190     oc = avformat_alloc_context();
1191     if (!oc) {
1192         print_error(filename, AVERROR(ENOMEM));
1193         exit(1);
1194     }
1195
1196     if (o->format) {
1197         file_oformat = av_guess_format(o->format, NULL, NULL);
1198         if (!file_oformat) {
1199             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1200             exit(1);
1201         }
1202     } else {
1203         file_oformat = av_guess_format(NULL, filename, NULL);
1204         if (!file_oformat) {
1205             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1206                    filename);
1207             exit(1);
1208         }
1209     }
1210
1211     oc->oformat = file_oformat;
1212     oc->interrupt_callback = int_cb;
1213     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1214
1215     /* create streams for all unlabeled output pads */
1216     for (i = 0; i < nb_filtergraphs; i++) {
1217         FilterGraph *fg = filtergraphs[i];
1218         for (j = 0; j < fg->nb_outputs; j++) {
1219             OutputFilter *ofilter = fg->outputs[j];
1220
1221             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1222                 continue;
1223
1224             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1225                                           ofilter->out_tmp->pad_idx)) {
1226             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1227             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1228             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1229             }
1230             init_output_filter(ofilter, o, oc);
1231         }
1232     }
1233
1234     if (!o->nb_stream_maps) {
1235         /* pick the "best" stream of each type */
1236 #define NEW_STREAM(type, index)\
1237         if (index >= 0) {\
1238             ost = new_ ## type ## _stream(o, oc);\
1239             ost->source_index = index;\
1240             ost->sync_ist     = input_streams[index];\
1241             input_streams[index]->discard = 0;\
1242             input_streams[index]->st->discard = AVDISCARD_NONE;\
1243         }
1244
1245         /* video: highest resolution */
1246         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1247             int area = 0, idx = -1;
1248             for (i = 0; i < nb_input_streams; i++) {
1249                 ist = input_streams[i];
1250                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1251                     ist->st->codec->width * ist->st->codec->height > area) {
1252                     area = ist->st->codec->width * ist->st->codec->height;
1253                     idx = i;
1254                 }
1255             }
1256             NEW_STREAM(video, idx);
1257         }
1258
1259         /* audio: most channels */
1260         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1261             int channels = 0, idx = -1;
1262             for (i = 0; i < nb_input_streams; i++) {
1263                 ist = input_streams[i];
1264                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1265                     ist->st->codec->channels > channels) {
1266                     channels = ist->st->codec->channels;
1267                     idx = i;
1268                 }
1269             }
1270             NEW_STREAM(audio, idx);
1271         }
1272
1273         /* subtitles: pick first */
1274         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1275             for (i = 0; i < nb_input_streams; i++)
1276                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1277                     NEW_STREAM(subtitle, i);
1278                     break;
1279                 }
1280         }
1281         /* do something with data? */
1282     } else {
1283         for (i = 0; i < o->nb_stream_maps; i++) {
1284             StreamMap *map = &o->stream_maps[i];
1285
1286             if (map->disabled)
1287                 continue;
1288
1289             if (map->linklabel) {
1290                 FilterGraph *fg;
1291                 OutputFilter *ofilter = NULL;
1292                 int j, k;
1293
1294                 for (j = 0; j < nb_filtergraphs; j++) {
1295                     fg = filtergraphs[j];
1296                     for (k = 0; k < fg->nb_outputs; k++) {
1297                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1298                         if (out && !strcmp(out->name, map->linklabel)) {
1299                             ofilter = fg->outputs[k];
1300                             goto loop_end;
1301                         }
1302                     }
1303                 }
1304 loop_end:
1305                 if (!ofilter) {
1306                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1307                            "in any defined filter graph.\n", map->linklabel);
1308                     exit(1);
1309                 }
1310                 init_output_filter(ofilter, o, oc);
1311             } else {
1312                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1313                 switch (ist->st->codec->codec_type) {
1314                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1315                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1316                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1317                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1318                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1319                 default:
1320                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1321                            map->file_index, map->stream_index);
1322                     exit(1);
1323                 }
1324
1325                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1326                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1327                                                map->sync_stream_index];
1328                 ist->discard = 0;
1329                 ist->st->discard = AVDISCARD_NONE;
1330             }
1331         }
1332     }
1333
1334     /* handle attached files */
1335     for (i = 0; i < o->nb_attachments; i++) {
1336         AVIOContext *pb;
1337         uint8_t *attachment;
1338         const char *p;
1339         int64_t len;
1340
1341         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1342             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1343                    o->attachments[i]);
1344             exit(1);
1345         }
1346         if ((len = avio_size(pb)) <= 0) {
1347             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1348                    o->attachments[i]);
1349             exit(1);
1350         }
1351         if (!(attachment = av_malloc(len))) {
1352             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1353                    o->attachments[i]);
1354             exit(1);
1355         }
1356         avio_read(pb, attachment, len);
1357
1358         ost = new_attachment_stream(o, oc);
1359         ost->stream_copy               = 0;
1360         ost->source_index              = -1;
1361         ost->attachment_filename       = o->attachments[i];
1362         ost->st->codec->extradata      = attachment;
1363         ost->st->codec->extradata_size = len;
1364
1365         p = strrchr(o->attachments[i], '/');
1366         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1367         avio_close(pb);
1368     }
1369
1370     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1371     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1372         exit(1);
1373
1374     output_files[nb_output_files - 1]->ctx            = oc;
1375     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1376     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1377     if (o->recording_time != INT64_MAX)
1378         oc->duration = o->recording_time;
1379     output_files[nb_output_files - 1]->start_time     = o->start_time;
1380     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1381     output_files[nb_output_files - 1]->shortest       = o->shortest;
1382     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1383
1384     /* check filename in case of an image number is expected */
1385     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1386         if (!av_filename_number_test(oc->filename)) {
1387             print_error(oc->filename, AVERROR(EINVAL));
1388             exit(1);
1389         }
1390     }
1391
1392     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1393         /* test if it already exists to avoid losing precious files */
1394         assert_file_overwrite(filename);
1395
1396         /* open the file */
1397         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1398                               &oc->interrupt_callback,
1399                               &output_files[nb_output_files - 1]->opts)) < 0) {
1400             print_error(filename, err);
1401             exit(1);
1402         }
1403     }
1404
1405     if (o->mux_preload) {
1406         uint8_t buf[64];
1407         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1408         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1409     }
1410     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1411     oc->flags |= AVFMT_FLAG_NONBLOCK;
1412
1413     /* copy metadata */
1414     for (i = 0; i < o->nb_metadata_map; i++) {
1415         char *p;
1416         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1417
1418         if (in_file_index >= nb_input_files) {
1419             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1420             exit(1);
1421         }
1422         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1423                       in_file_index >= 0 ?
1424                       input_files[in_file_index]->ctx : NULL, o);
1425     }
1426
1427     /* copy chapters */
1428     if (o->chapters_input_file >= nb_input_files) {
1429         if (o->chapters_input_file == INT_MAX) {
1430             /* copy chapters from the first input file that has them*/
1431             o->chapters_input_file = -1;
1432             for (i = 0; i < nb_input_files; i++)
1433                 if (input_files[i]->ctx->nb_chapters) {
1434                     o->chapters_input_file = i;
1435                     break;
1436                 }
1437         } else {
1438             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1439                    o->chapters_input_file);
1440             exit(1);
1441         }
1442     }
1443     if (o->chapters_input_file >= 0)
1444         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1445                       !o->metadata_chapters_manual);
1446
1447     /* copy global metadata by default */
1448     if (!o->metadata_global_manual && nb_input_files)
1449         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1450                      AV_DICT_DONT_OVERWRITE);
1451     if (!o->metadata_streams_manual)
1452         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1453             InputStream *ist;
1454             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1455                 continue;
1456             ist = input_streams[output_streams[i]->source_index];
1457             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1458         }
1459
1460     /* process manually set metadata */
1461     for (i = 0; i < o->nb_metadata; i++) {
1462         AVDictionary **m;
1463         char type, *val;
1464         const char *stream_spec;
1465         int index = 0, j, ret;
1466
1467         val = strchr(o->metadata[i].u.str, '=');
1468         if (!val) {
1469             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1470                    o->metadata[i].u.str);
1471             exit(1);
1472         }
1473         *val++ = 0;
1474
1475         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1476         if (type == 's') {
1477             for (j = 0; j < oc->nb_streams; j++) {
1478                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1479                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1480                 } else if (ret < 0)
1481                     exit(1);
1482             }
1483         }
1484         else {
1485             switch (type) {
1486             case 'g':
1487                 m = &oc->metadata;
1488                 break;
1489             case 'c':
1490                 if (index < 0 || index >= oc->nb_chapters) {
1491                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1492                     exit(1);
1493                 }
1494                 m = &oc->chapters[index]->metadata;
1495                 break;
1496             default:
1497                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1498                 exit(1);
1499             }
1500             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1501         }
1502     }
1503
1504     reset_options(o);
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(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(NULL, "g", norm == PAL ? "15" : "18");
1563
1564         opt_default(NULL, "b", "1150000");
1565         opt_default(NULL, "maxrate", "1150000");
1566         opt_default(NULL, "minrate", "1150000");
1567         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1568
1569         opt_default(NULL, "b:a", "224000");
1570         parse_option(o, "ar", "44100", options);
1571         parse_option(o, "ac", "2", options);
1572
1573         opt_default(NULL, "packetsize", "2324");
1574         opt_default(NULL, "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(NULL, "g", norm == PAL ? "15" : "18");
1591
1592         opt_default(NULL, "b", "2040000");
1593         opt_default(NULL, "maxrate", "2516000");
1594         opt_default(NULL, "minrate", "0"); // 1145000;
1595         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1596         opt_default(NULL, "flags", "+scan_offset");
1597
1598
1599         opt_default(NULL, "b:a", "224000");
1600         parse_option(o, "ar", "44100", options);
1601
1602         opt_default(NULL, "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(NULL, "g", norm == PAL ? "15" : "18");
1613
1614         opt_default(NULL, "b", "6000000");
1615         opt_default(NULL, "maxrate", "9000000");
1616         opt_default(NULL, "minrate", "0"); // 1500000;
1617         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1618
1619         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1620         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1621
1622         opt_default(NULL, "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(void *optctx, 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(void *optctx, 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(NULL, 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(void *optctx, 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(void *optctx, 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(void *optctx, 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(NULL, 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(void *optctx, 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_PERFILE;
1796     int show_advanced = 0, show_avoptions = 0;
1797
1798     if (opt && *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_PERFILE,                       { .func_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_PERFILE,          { .func_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_PERFILE | OPT_EXPERT,          { .func_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_PERFILE,                       { .func_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_PERFILE | OPT_EXPERT,          { .func_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_PERFILE,                        { .func_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_PERFILE,                        { .func_arg = opt_video_codec },
1973         "force video codec ('copy' to copy stream)", "codec" },
1974     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
1975         "select the pass number (1 or 2)", "n" },
1976     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
1977         "select two pass log file name prefix", "prefix" },
1978     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
1979         "this option is deprecated, use the yadif filter instead" },
1980     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
1981         "dump video coding statistics to file" },
1982     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
1983         "dump video coding statistics to file", "file" },
1984     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
1985         "video filters", "filter list" },
1986     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
1987         "specify intra matrix coeffs", "matrix" },
1988     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
1989         "specify inter matrix coeffs", "matrix" },
1990     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
1991         "top=1/bottom=0/auto=-1 field first", "" },
1992     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
1993         "intra_dc_precision", "precision" },
1994     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_video_tag },
1995         "force video tag/fourcc", "fourcc/tag" },
1996     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
1997         "show QP histogram" },
1998     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
1999         "force the selected framerate, disable the best supported framerate selection" },
2000     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2001         "set the value of an outfile streamid", "streamIndex:value" },
2002     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2003         { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2004
2005     /* audio options */
2006     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2007         "set the number of audio frames to record", "number" },
2008     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2009         "set audio quality (codec-specific)", "quality", },
2010     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2011         "set audio sampling rate (in Hz)", "rate" },
2012     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2013         "set number of audio channels", "channels" },
2014     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2015         "disable audio" },
2016     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2017         "force audio codec ('copy' to copy stream)", "codec" },
2018     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_audio_tag },
2019         "force audio tag/fourcc", "fourcc/tag" },
2020     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2021         "change audio volume (256=normal)" , "volume" },
2022     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2023         "set sample format", "format" },
2024     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2025         "set channel layout", "layout" },
2026     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2027         "audio filters", "filter list" },
2028
2029     /* subtitle options */
2030     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2031         "disable subtitle" },
2032     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2033         "force subtitle codec ('copy' to copy stream)", "codec" },
2034     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2035         , "force subtitle tag/fourcc", "fourcc/tag" },
2036
2037     /* grab options */
2038     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2039
2040     /* muxer options */
2041     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2042         "set the maximum demux-decode delay", "seconds" },
2043     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2044         "set the initial demux-decode delay", "seconds" },
2045
2046     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2047         "A comma-separated list of bitstream filters", "bitstream_filters" },
2048
2049     /* data codec support */
2050     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2051         "force data codec ('copy' to copy stream)", "codec" },
2052
2053     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2054         "generic catch all option", "" },
2055     { NULL, },
2056 };