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