git.sesse.net Git - ffmpeg/blob - avconv_opt.c

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