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

   1 /*
   2  * ffmpeg option parsing
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 "ffmpeg.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 #define MATCH_PER_TYPE_OPT(name, type, outvar, fmtctx, mediatype)\
  58 {\
  59     int i;\
  60     for (i = 0; i < o->nb_ ## name; i++) {\
  61         char *spec = o->name[i].specifier;\
  62         if (!strcmp(spec, mediatype))\
  63             outvar = o->name[i].u.type;\
  64     }\
  65 }
  66 char *vstats_filename;
  67
  68 float audio_drift_threshold = 0.1;
  69 float dts_delta_threshold   = 10;
  70 float dts_error_threshold   = 3600*30;
  71
  72 int audio_volume      = 256;
  73 int audio_sync_method = 0;
  74 int video_sync_method = VSYNC_AUTO;
  75 int do_deinterlace    = 0;
  76 int do_benchmark      = 0;
  77 int do_benchmark_all  = 0;
  78 int do_hex_dump       = 0;
  79 int do_pkt_dump       = 0;
  80 int copy_ts           = 0;
  81 int copy_tb           = -1;
  82 int debug_ts          = 0;
  83 int exit_on_error     = 0;
  84 int print_stats       = 1;
  85 int qp_hist           = 0;
  86 int stdin_interaction = 1;
  87 int frame_bits_per_raw_sample = 0;
  88
  89
  90 static int intra_only         = 0;
  91 static int file_overwrite     = 0;
  92 static int no_file_overwrite  = 0;
  93 static int video_discard      = 0;
  94 static int intra_dc_precision = 8;
  95 static int do_psnr            = 0;
  96 static int input_sync;
  97
  98 void reset_options(OptionsContext *o, int is_input)
  99 {
 100     const OptionDef *po = options;
 101     OptionsContext bak= *o;
 102     int i;
 103
 104     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 105     while (po->name) {
 106         void *dst = (uint8_t*)o + po->u.off;
 107
 108         if (po->flags & OPT_SPEC) {
 109             SpecifierOpt **so = dst;
 110             int i, *count = (int*)(so + 1);
 111             for (i = 0; i < *count; i++) {
 112                 av_freep(&(*so)[i].specifier);
 113                 if (po->flags & OPT_STRING)
 114                     av_freep(&(*so)[i].u.str);
 115             }
 116             av_freep(so);
 117             *count = 0;
 118         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 119             av_freep(dst);
 120         po++;
 121     }
 122
 123     for (i = 0; i < o->nb_stream_maps; i++)
 124         av_freep(&o->stream_maps[i].linklabel);
 125     av_freep(&o->stream_maps);
 126     av_freep(&o->audio_channel_maps);
 127     av_freep(&o->streamid_map);
 128
 129     memset(o, 0, sizeof(*o));
 130
 131     if (is_input) {
 132         o->recording_time = bak.recording_time;
 133         if (o->recording_time != INT64_MAX)
 134             av_log(NULL, AV_LOG_WARNING,
 135                    "-t is not an input option, keeping it for the next output;"
 136                    " consider fixing your command line.\n");
 137     } else
 138     o->recording_time = INT64_MAX;
 139     o->mux_max_delay  = 0.7;
 140     o->limit_filesize = UINT64_MAX;
 141     o->chapters_input_file = INT_MAX;
 142
 143     uninit_opts();
 144     init_opts();
 145 }
 146
 147
 148 static int opt_frame_crop(void *optctx, const char *opt, const char *arg)
 149 {
 150     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
 151     return AVERROR(EINVAL);
 152 }
 153
 154 static int opt_pad(void *optctx, const char *opt, const char *arg)
 155 {
 156     av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
 157     return -1;
 158 }
 159
 160 static int opt_sameq(void *optctx, const char *opt, const char *arg)
 161 {
 162     av_log(NULL, AV_LOG_WARNING, "Ignoring option '%s'\n", opt);
 163     return 0;
 164 }
 165
 166 static int opt_video_channel(void *optctx, const char *opt, const char *arg)
 167 {
 168     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
 169     return opt_default(optctx, "channel", arg);
 170 }
 171
 172 static int opt_video_standard(void *optctx, const char *opt, const char *arg)
 173 {
 174     av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
 175     return opt_default(optctx, "standard", arg);
 176 }
 177
 178 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 179 {
 180     OptionsContext *o = optctx;
 181     return parse_option(o, "codec:a", arg, options);
 182 }
 183
 184 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 185 {
 186     OptionsContext *o = optctx;
 187     return parse_option(o, "codec:v", arg, options);
 188 }
 189
 190 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 191 {
 192     OptionsContext *o = optctx;
 193     return parse_option(o, "codec:s", arg, options);
 194 }
 195
 196 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 197 {
 198     OptionsContext *o = optctx;
 199     return parse_option(o, "codec:d", arg, options);
 200 }
 201
 202 static int opt_map(void *optctx, const char *opt, const char *arg)
 203 {
 204     OptionsContext *o = optctx;
 205     StreamMap *m = NULL;
 206     int i, negative = 0, file_idx;
 207     int sync_file_idx = -1, sync_stream_idx = 0;
 208     char *p, *sync;
 209     char *map;
 210
 211     if (*arg == '-') {
 212         negative = 1;
 213         arg++;
 214     }
 215     map = av_strdup(arg);
 216
 217     /* parse sync stream first, just pick first matching stream */
 218     if (sync = strchr(map, ',')) {
 219         *sync = 0;
 220         sync_file_idx = strtol(sync + 1, &sync, 0);
 221         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 222             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 223             exit(1);
 224         }
 225         if (*sync)
 226             sync++;
 227         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 228             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 229                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 230                 sync_stream_idx = i;
 231                 break;
 232             }
 233         if (i == input_files[sync_file_idx]->nb_streams) {
 234             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 235                                        "match any streams.\n", arg);
 236             exit(1);
 237         }
 238     }
 239
 240
 241     if (map[0] == '[') {
 242         /* this mapping refers to lavfi output */
 243         const char *c = map + 1;
 244         o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 245                                     &o->nb_stream_maps, o->nb_stream_maps + 1);
 246         m = &o->stream_maps[o->nb_stream_maps - 1];
 247         m->linklabel = av_get_token(&c, "]");
 248         if (!m->linklabel) {
 249             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 250             exit(1);
 251         }
 252     } else {
 253         file_idx = strtol(map, &p, 0);
 254         if (file_idx >= nb_input_files || file_idx < 0) {
 255             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 256             exit(1);
 257         }
 258         if (negative)
 259             /* disable some already defined maps */
 260             for (i = 0; i < o->nb_stream_maps; i++) {
 261                 m = &o->stream_maps[i];
 262                 if (file_idx == m->file_index &&
 263                     check_stream_specifier(input_files[m->file_index]->ctx,
 264                                            input_files[m->file_index]->ctx->streams[m->stream_index],
 265                                            *p == ':' ? p + 1 : p) > 0)
 266                     m->disabled = 1;
 267             }
 268         else
 269             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 270                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 271                             *p == ':' ? p + 1 : p) <= 0)
 272                     continue;
 273                 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
 274                                             &o->nb_stream_maps, o->nb_stream_maps + 1);
 275                 m = &o->stream_maps[o->nb_stream_maps - 1];
 276
 277                 m->file_index   = file_idx;
 278                 m->stream_index = i;
 279
 280                 if (sync_file_idx >= 0) {
 281                     m->sync_file_index   = sync_file_idx;
 282                     m->sync_stream_index = sync_stream_idx;
 283                 } else {
 284                     m->sync_file_index   = file_idx;
 285                     m->sync_stream_index = i;
 286                 }
 287             }
 288     }
 289
 290     if (!m) {
 291         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 292         exit(1);
 293     }
 294
 295     av_freep(&map);
 296     return 0;
 297 }
 298
 299 static int opt_attach(void *optctx, const char *opt, const char *arg)
 300 {
 301     OptionsContext *o = optctx;
 302     o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
 303                                 &o->nb_attachments, o->nb_attachments + 1);
 304     o->attachments[o->nb_attachments - 1] = arg;
 305     return 0;
 306 }
 307
 308 static int opt_map_channel(void *optctx, const char *opt, const char *arg)
 309 {
 310     OptionsContext *o = optctx;
 311     int n;
 312     AVStream *st;
 313     AudioChannelMap *m;
 314
 315     o->audio_channel_maps =
 316         grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
 317                    &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
 318     m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
 319
 320     /* muted channel syntax */
 321     n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
 322     if ((n == 1 || n == 3) && m->channel_idx == -1) {
 323         m->file_idx = m->stream_idx = -1;
 324         if (n == 1)
 325             m->ofile_idx = m->ostream_idx = -1;
 326         return 0;
 327     }
 328
 329     /* normal syntax */
 330     n = sscanf(arg, "%d.%d.%d:%d.%d",
 331                &m->file_idx,  &m->stream_idx, &m->channel_idx,
 332                &m->ofile_idx, &m->ostream_idx);
 333
 334     if (n != 3 && n != 5) {
 335         av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
 336                "[file.stream.channel|-1][:syncfile:syncstream]\n");
 337         exit(1);
 338     }
 339
 340     if (n != 5) // only file.stream.channel specified
 341         m->ofile_idx = m->ostream_idx = -1;
 342
 343     /* check input */
 344     if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
 345         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
 346                m->file_idx);
 347         exit(1);
 348     }
 349     if (m->stream_idx < 0 ||
 350         m->stream_idx >= input_files[m->file_idx]->nb_streams) {
 351         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
 352                m->file_idx, m->stream_idx);
 353         exit(1);
 354     }
 355     st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
 356     if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
 357         av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
 358                m->file_idx, m->stream_idx);
 359         exit(1);
 360     }
 361     if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
 362         av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
 363                m->file_idx, m->stream_idx, m->channel_idx);
 364         exit(1);
 365     }
 366     return 0;
 367 }
 368
 369 /**
 370  * Parse a metadata specifier passed as 'arg' parameter.
 371  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 372  * @param index for type c/p, chapter/program index is written here
 373  * @param stream_spec for type s, the stream specifier is written here
 374  */
 375 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 376 {
 377     if (*arg) {
 378         *type = *arg;
 379         switch (*arg) {
 380         case 'g':
 381             break;
 382         case 's':
 383             if (*(++arg) && *arg != ':') {
 384                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 385                 exit(1);
 386             }
 387             *stream_spec = *arg == ':' ? arg + 1 : "";
 388             break;
 389         case 'c':
 390         case 'p':
 391             if (*(++arg) == ':')
 392                 *index = strtol(++arg, NULL, 0);
 393             break;
 394         default:
 395             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 396             exit(1);
 397         }
 398     } else
 399         *type = 'g';
 400 }
 401
 402 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 403 {
 404     AVDictionary **meta_in = NULL;
 405     AVDictionary **meta_out = NULL;
 406     int i, ret = 0;
 407     char type_in, type_out;
 408     const char *istream_spec = NULL, *ostream_spec = NULL;
 409     int idx_in = 0, idx_out = 0;
 410
 411     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 412     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 413
 414     if (!ic) {
 415         if (type_out == 'g' || !*outspec)
 416             o->metadata_global_manual = 1;
 417         if (type_out == 's' || !*outspec)
 418             o->metadata_streams_manual = 1;
 419         if (type_out == 'c' || !*outspec)
 420             o->metadata_chapters_manual = 1;
 421         return 0;
 422     }
 423
 424     if (type_in == 'g' || type_out == 'g')
 425         o->metadata_global_manual = 1;
 426     if (type_in == 's' || type_out == 's')
 427         o->metadata_streams_manual = 1;
 428     if (type_in == 'c' || type_out == 'c')
 429         o->metadata_chapters_manual = 1;
 430
 431 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
 432     if ((index) < 0 || (index) >= (nb_elems)) {\
 433         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
 434                 (desc), (index));\
 435         exit(1);\
 436     }
 437
 438 #define SET_DICT(type, meta, context, index)\
 439         switch (type) {\
 440         case 'g':\
 441             meta = &context->metadata;\
 442             break;\
 443         case 'c':\
 444             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
 445             meta = &context->chapters[index]->metadata;\
 446             break;\
 447         case 'p':\
 448             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
 449             meta = &context->programs[index]->metadata;\
 450             break;\
 451         default: av_assert0(0);\
 452         case 's':\
 453             break;\
 454         }\
 455
 456     SET_DICT(type_in, meta_in, ic, idx_in);
 457     SET_DICT(type_out, meta_out, oc, idx_out);
 458
 459     /* for input streams choose first matching stream */
 460     if (type_in == 's') {
 461         for (i = 0; i < ic->nb_streams; i++) {
 462             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
 463                 meta_in = &ic->streams[i]->metadata;
 464                 break;
 465             } else if (ret < 0)
 466                 exit(1);
 467         }
 468         if (!meta_in) {
 469             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
 470             exit(1);
 471         }
 472     }
 473
 474     if (type_out == 's') {
 475         for (i = 0; i < oc->nb_streams; i++) {
 476             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
 477                 meta_out = &oc->streams[i]->metadata;
 478                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 479             } else if (ret < 0)
 480                 exit(1);
 481         }
 482     } else
 483         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 484
 485     return 0;
 486 }
 487
 488 static int opt_recording_timestamp(void *optctx, const char *opt, const char *arg)
 489 {
 490     OptionsContext *o = optctx;
 491     char buf[128];
 492     int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
 493     struct tm time = *gmtime((time_t*)&recording_timestamp);
 494     strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
 495     parse_option(o, "metadata", buf, options);
 496
 497     av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
 498                                  "tag instead.\n", opt);
 499     return 0;
 500 }
 501
 502 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 503 {
 504     const AVCodecDescriptor *desc;
 505     const char *codec_string = encoder ? "encoder" : "decoder";
 506     AVCodec *codec;
 507
 508     codec = encoder ?
 509         avcodec_find_encoder_by_name(name) :
 510         avcodec_find_decoder_by_name(name);
 511
 512     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
 513         codec = encoder ? avcodec_find_encoder(desc->id) :
 514                           avcodec_find_decoder(desc->id);
 515         if (codec)
 516             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
 517                    codec_string, codec->name, desc->name);
 518     }
 519
 520     if (!codec) {
 521         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
 522         exit(1);
 523     }
 524     if (codec->type != type) {
 525         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 526         exit(1);
 527     }
 528     return codec;
 529 }
 530
 531 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
 532 {
 533     char *codec_name = NULL;
 534
 535     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
 536     if (codec_name) {
 537         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
 538         st->codec->codec_id = codec->id;
 539         return codec;
 540     } else
 541         return avcodec_find_decoder(st->codec->codec_id);
 542 }
 543
 544 /* Add all the streams from the given input file to the global
 545  * list of input streams. */
 546 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 547 {
 548     int i;
 549     char *next, *codec_tag = NULL;
 550
 551     for (i = 0; i < ic->nb_streams; i++) {
 552         AVStream *st = ic->streams[i];
 553         AVCodecContext *dec = st->codec;
 554         InputStream *ist = av_mallocz(sizeof(*ist));
 555         char *framerate = NULL;
 556
 557         if (!ist)
 558             exit(1);
 559
 560         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
 561         input_streams[nb_input_streams - 1] = ist;
 562
 563         ist->st = st;
 564         ist->file_index = nb_input_files;
 565         ist->discard = 1;
 566         st->discard  = AVDISCARD_ALL;
 567         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
 568
 569         ist->ts_scale = 1.0;
 570         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 571
 572         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
 573         if (codec_tag) {
 574             uint32_t tag = strtol(codec_tag, &next, 0);
 575             if (*next)
 576                 tag = AV_RL32(codec_tag);
 577             st->codec->codec_tag = tag;
 578         }
 579
 580         ist->dec = choose_decoder(o, ic, st);
 581
 582         ist->reinit_filters = -1;
 583         MATCH_PER_STREAM_OPT(reinit_filters, i, ist->reinit_filters, ic, st);
 584
 585         switch (dec->codec_type) {
 586         case AVMEDIA_TYPE_VIDEO:
 587             if(!ist->dec)
 588                 ist->dec = avcodec_find_decoder(dec->codec_id);
 589             if (dec->lowres) {
 590                 dec->flags |= CODEC_FLAG_EMU_EDGE;
 591             }
 592
 593             ist->resample_height  = dec->height;
 594             ist->resample_width   = dec->width;
 595             ist->resample_pix_fmt = dec->pix_fmt;
 596
 597             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 598             if (framerate && av_parse_video_rate(&ist->framerate,
 599                                                  framerate) < 0) {
 600                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 601                        framerate);
 602                 exit(1);
 603             }
 604
 605             ist->top_field_first = -1;
 606             MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
 607
 608             break;
 609         case AVMEDIA_TYPE_AUDIO:
 610             guess_input_channel_layout(ist);
 611
 612             ist->resample_sample_fmt     = dec->sample_fmt;
 613             ist->resample_sample_rate    = dec->sample_rate;
 614             ist->resample_channels       = dec->channels;
 615             ist->resample_channel_layout = dec->channel_layout;
 616
 617             break;
 618         case AVMEDIA_TYPE_DATA:
 619         case AVMEDIA_TYPE_SUBTITLE:
 620             if(!ist->dec)
 621                 ist->dec = avcodec_find_decoder(dec->codec_id);
 622             MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
 623             break;
 624         case AVMEDIA_TYPE_ATTACHMENT:
 625         case AVMEDIA_TYPE_UNKNOWN:
 626             break;
 627         default:
 628             abort();
 629         }
 630     }
 631 }
 632
 633 static void assert_file_overwrite(const char *filename)
 634 {
 635     if ((!file_overwrite || no_file_overwrite) &&
 636         (strchr(filename, ':') == NULL || filename[1] == ':' ||
 637          av_strstart(filename, "file:", NULL))) {
 638         if (avio_check(filename, 0) == 0) {
 639             if (stdin_interaction && (!no_file_overwrite || file_overwrite)) {
 640                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 641                 fflush(stderr);
 642                 term_exit();
 643                 signal(SIGINT, SIG_DFL);
 644                 if (!read_yesno()) {
 645                     av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
 646                     exit(1);
 647                 }
 648                 term_init();
 649             }
 650             else {
 651                 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
 652                 exit(1);
 653             }
 654         }
 655     }
 656 }
 657
 658 static void dump_attachment(AVStream *st, const char *filename)
 659 {
 660     int ret;
 661     AVIOContext *out = NULL;
 662     AVDictionaryEntry *e;
 663
 664     if (!st->codec->extradata_size) {
 665         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 666                nb_input_files - 1, st->index);
 667         return;
 668     }
 669     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 670         filename = e->value;
 671     if (!*filename) {
 672         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 673                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 674         exit(1);
 675     }
 676
 677     assert_file_overwrite(filename);
 678
 679     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 680         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 681                filename);
 682         exit(1);
 683     }
 684
 685     avio_write(out, st->codec->extradata, st->codec->extradata_size);
 686     avio_flush(out);
 687     avio_close(out);
 688 }
 689
 690 static int opt_input_file(void *optctx, const char *opt, const char *filename)
 691 {
 692     OptionsContext *o = optctx;
 693     AVFormatContext *ic;
 694     AVInputFormat *file_iformat = NULL;
 695     int err, i, ret;
 696     int64_t timestamp;
 697     uint8_t buf[128];
 698     AVDictionary **opts;
 699     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
 700     char *   video_codec_name = NULL;
 701     char *   audio_codec_name = NULL;
 702     char *subtitle_codec_name = NULL;
 703
 704     if (o->format) {
 705         if (!(file_iformat = av_find_input_format(o->format))) {
 706             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
 707             exit(1);
 708         }
 709     }
 710
 711     if (!strcmp(filename, "-"))
 712         filename = "pipe:";
 713
 714     stdin_interaction &= strncmp(filename, "pipe:", 5) &&
 715                          strcmp(filename, "/dev/stdin");
 716
 717     /* get default parameters from command line */
 718     ic = avformat_alloc_context();
 719     if (!ic) {
 720         print_error(filename, AVERROR(ENOMEM));
 721         exit(1);
 722     }
 723     if (o->nb_audio_sample_rate) {
 724         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
 725         av_dict_set(&format_opts, "sample_rate", buf, 0);
 726     }
 727     if (o->nb_audio_channels) {
 728         /* because we set audio_channels based on both the "ac" and
 729          * "channel_layout" options, we need to check that the specified
 730          * demuxer actually has the "channels" option before setting it */
 731         if (file_iformat && file_iformat->priv_class &&
 732             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
 733                         AV_OPT_SEARCH_FAKE_OBJ)) {
 734             snprintf(buf, sizeof(buf), "%d",
 735                      o->audio_channels[o->nb_audio_channels - 1].u.i);
 736             av_dict_set(&format_opts, "channels", buf, 0);
 737         }
 738     }
 739     if (o->nb_frame_rates) {
 740         /* set the format-level framerate option;
 741          * this is important for video grabbers, e.g. x11 */
 742         if (file_iformat && file_iformat->priv_class &&
 743             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
 744                         AV_OPT_SEARCH_FAKE_OBJ)) {
 745             av_dict_set(&format_opts, "framerate",
 746                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
 747         }
 748     }
 749     if (o->nb_frame_sizes) {
 750         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
 751     }
 752     if (o->nb_frame_pix_fmts)
 753         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
 754
 755     MATCH_PER_TYPE_OPT(codec_names, str,    video_codec_name, ic, "v");
 756     MATCH_PER_TYPE_OPT(codec_names, str,    audio_codec_name, ic, "a");
 757     MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, ic, "s");
 758
 759     ic->video_codec_id   = video_codec_name ?
 760         find_codec_or_die(video_codec_name   , AVMEDIA_TYPE_VIDEO   , 0)->id : AV_CODEC_ID_NONE;
 761     ic->audio_codec_id   = audio_codec_name ?
 762         find_codec_or_die(audio_codec_name   , AVMEDIA_TYPE_AUDIO   , 0)->id : AV_CODEC_ID_NONE;
 763     ic->subtitle_codec_id= subtitle_codec_name ?
 764         find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : AV_CODEC_ID_NONE;
 765     ic->flags |= AVFMT_FLAG_NONBLOCK;
 766     ic->interrupt_callback = int_cb;
 767
 768     /* open the input file with generic avformat function */
 769     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
 770     if (err < 0) {
 771         print_error(filename, err);
 772         exit(1);
 773     }
 774     assert_avoptions(format_opts);
 775
 776     /* apply forced codec ids */
 777     for (i = 0; i < ic->nb_streams; i++)
 778         choose_decoder(o, ic, ic->streams[i]);
 779
 780     /* Set AVCodecContext options for avformat_find_stream_info */
 781     opts = setup_find_stream_info_opts(ic, codec_opts);
 782     orig_nb_streams = ic->nb_streams;
 783
 784     /* If not enough info to get the stream parameters, we decode the
 785        first frames to get it. (used in mpeg case for example) */
 786     ret = avformat_find_stream_info(ic, opts);
 787     if (ret < 0) {
 788         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
 789         avformat_close_input(&ic);
 790         exit(1);
 791     }
 792
 793     timestamp = o->start_time;
 794     /* add the stream start time */
 795     if (ic->start_time != AV_NOPTS_VALUE)
 796         timestamp += ic->start_time;
 797
 798     /* if seeking requested, we execute it */
 799     if (o->start_time != 0) {
 800         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 801         if (ret < 0) {
 802             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
 803                    filename, (double)timestamp / AV_TIME_BASE);
 804         }
 805     }
 806
 807     /* update the current parameters so that they match the one of the input stream */
 808     add_input_streams(o, ic);
 809
 810     /* dump the file content */
 811     av_dump_format(ic, nb_input_files, filename, 0);
 812
 813     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
 814     if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
 815         exit(1);
 816
 817     input_files[nb_input_files - 1]->ctx        = ic;
 818     input_files[nb_input_files - 1]->ist_index  = nb_input_streams - ic->nb_streams;
 819     input_files[nb_input_files - 1]->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 820     input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
 821     input_files[nb_input_files - 1]->rate_emu   = o->rate_emu;
 822
 823     for (i = 0; i < o->nb_dump_attachment; i++) {
 824         int j;
 825
 826         for (j = 0; j < ic->nb_streams; j++) {
 827             AVStream *st = ic->streams[j];
 828
 829             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 830                 dump_attachment(st, o->dump_attachment[i].u.str);
 831         }
 832     }
 833
 834     for (i = 0; i < orig_nb_streams; i++)
 835         av_dict_free(&opts[i]);
 836     av_freep(&opts);
 837
 838     reset_options(o, 1);
 839     return 0;
 840 }
 841
 842 static uint8_t *get_line(AVIOContext *s)
 843 {
 844     AVIOContext *line;
 845     uint8_t *buf;
 846     char c;
 847
 848     if (avio_open_dyn_buf(&line) < 0) {
 849         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 850         exit(1);
 851     }
 852
 853     while ((c = avio_r8(s)) && c != '\n')
 854         avio_w8(line, c);
 855     avio_w8(line, 0);
 856     avio_close_dyn_buf(line, &buf);
 857
 858     return buf;
 859 }
 860
 861 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 862 {
 863     int i, ret = 1;
 864     char filename[1000];
 865     const char *base[3] = { getenv("AVCONV_DATADIR"),
 866                             getenv("HOME"),
 867                             AVCONV_DATADIR,
 868                             };
 869
 870     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 871         if (!base[i])
 872             continue;
 873         if (codec_name) {
 874             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 875                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 876             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 877         }
 878         if (ret) {
 879             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 880                      i != 1 ? "" : "/.avconv", preset_name);
 881             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 882         }
 883     }
 884     return ret;
 885 }
 886
 887 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 888 {
 889     char *codec_name = NULL;
 890
 891     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 892     if (!codec_name) {
 893         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 894                                                   NULL, ost->st->codec->codec_type);
 895         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 896     } else if (!strcmp(codec_name, "copy"))
 897         ost->stream_copy = 1;
 898     else {
 899         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 900         ost->st->codec->codec_id = ost->enc->id;
 901     }
 902 }
 903
 904 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
 905 {
 906     OutputStream *ost;
 907     AVStream *st = avformat_new_stream(oc, NULL);
 908     int idx      = oc->nb_streams - 1, ret = 0;
 909     char *bsf = NULL, *next, *codec_tag = NULL;
 910     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 911     double qscale = -1;
 912     char *buf = NULL, *arg = NULL, *preset = NULL;
 913     AVIOContext *s = NULL;
 914
 915     if (!st) {
 916         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 917         exit(1);
 918     }
 919
 920     if (oc->nb_streams - 1 < o->nb_streamid_map)
 921         st->id = o->streamid_map[oc->nb_streams - 1];
 922
 923     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
 924                                 nb_output_streams + 1);
 925     if (!(ost = av_mallocz(sizeof(*ost))))
 926         exit(1);
 927     output_streams[nb_output_streams - 1] = ost;
 928
 929     ost->file_index = nb_output_files;
 930     ost->index      = idx;
 931     ost->st         = st;
 932     st->codec->codec_type = type;
 933     choose_encoder(o, oc, ost);
 934     if (ost->enc) {
 935         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
 936     }
 937
 938     avcodec_get_context_defaults3(st->codec, ost->enc);
 939     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 940
 941     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 942     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 943         do  {
 944             buf = get_line(s);
 945             if (!buf[0] || buf[0] == '#') {
 946                 av_free(buf);
 947                 continue;
 948             }
 949             if (!(arg = strchr(buf, '='))) {
 950                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 951                 exit(1);
 952             }
 953             *arg++ = 0;
 954             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 955             av_free(buf);
 956         } while (!s->eof_reached);
 957         avio_close(s);
 958     }
 959     if (ret) {
 960         av_log(NULL, AV_LOG_FATAL,
 961                "Preset %s specified for stream %d:%d, but could not be opened.\n",
 962                preset, ost->file_index, ost->index);
 963         exit(1);
 964     }
 965
 966     ost->max_frames = INT64_MAX;
 967     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 968
 969     ost->copy_prior_start = -1;
 970     MATCH_PER_STREAM_OPT(copy_prior_start, i, ost->copy_prior_start, oc ,st);
 971
 972     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 973     while (bsf) {
 974         if (next = strchr(bsf, ','))
 975             *next++ = 0;
 976         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 977             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 978             exit(1);
 979         }
 980         if (bsfc_prev)
 981             bsfc_prev->next = bsfc;
 982         else
 983             ost->bitstream_filters = bsfc;
 984
 985         bsfc_prev = bsfc;
 986         bsf       = next;
 987     }
 988
 989     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 990     if (codec_tag) {
 991         uint32_t tag = strtol(codec_tag, &next, 0);
 992         if (*next)
 993             tag = AV_RL32(codec_tag);
 994         st->codec->codec_tag = tag;
 995     }
 996
 997     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 998     if (qscale >= 0) {
 999         st->codec->flags |= CODEC_FLAG_QSCALE;
1000         st->codec->global_quality = FF_QP2LAMBDA * qscale;
1001     }
1002
1003     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1004         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
1005
1006     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
1007     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1008     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1009
1010     ost->source_index = source_index;
1011     if (source_index >= 0) {
1012         ost->sync_ist = input_streams[source_index];
1013         input_streams[source_index]->discard = 0;
1014         input_streams[source_index]->st->discard = AVDISCARD_NONE;
1015     }
1016
1017     return ost;
1018 }
1019
1020 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1021 {
1022     int i;
1023     const char *p = str;
1024     for (i = 0;; i++) {
1025         dest[i] = atoi(p);
1026         if (i == 63)
1027             break;
1028         p = strchr(p, ',');
1029         if (!p) {
1030             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1031             exit(1);
1032         }
1033         p++;
1034     }
1035 }
1036
1037 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1038 {
1039     AVStream *st;
1040     OutputStream *ost;
1041     AVCodecContext *video_enc;
1042     char *frame_rate = NULL;
1043
1044     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1045     st  = ost->st;
1046     video_enc = st->codec;
1047
1048     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1049     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1050         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1051         exit(1);
1052     }
1053
1054     if (!ost->stream_copy) {
1055         const char *p = NULL;
1056         char *frame_size = NULL;
1057         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1058         char *intra_matrix = NULL, *inter_matrix = NULL;
1059         const char *filters = "null";
1060         int do_pass = 0;
1061         int i;
1062
1063         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1064         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1065             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1066             exit(1);
1067         }
1068
1069         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1070         if (frame_aspect_ratio) {
1071             AVRational q;
1072             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1073                 q.num <= 0 || q.den <= 0) {
1074                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1075                 exit(1);
1076             }
1077             ost->frame_aspect_ratio = av_q2d(q);
1078         }
1079
1080         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1081         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1082         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1083             ost->keep_pix_fmt = 1;
1084             if (!*++frame_pix_fmt)
1085                 frame_pix_fmt = NULL;
1086         }
1087         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1088             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1089             exit(1);
1090         }
1091         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1092
1093         if (intra_only)
1094             video_enc->gop_size = 0;
1095         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1096         if (intra_matrix) {
1097             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1098                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1099                 exit(1);
1100             }
1101             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1102         }
1103         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1104         if (inter_matrix) {
1105             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1106                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1107                 exit(1);
1108             }
1109             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1110         }
1111
1112         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1113         for (i = 0; p; i++) {
1114             int start, end, q;
1115             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1116             if (e != 3) {
1117                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1118                 exit(1);
1119             }
1120             /* FIXME realloc failure */
1121             video_enc->rc_override =
1122                 av_realloc(video_enc->rc_override,
1123                            sizeof(RcOverride) * (i + 1));
1124             video_enc->rc_override[i].start_frame = start;
1125             video_enc->rc_override[i].end_frame   = end;
1126             if (q > 0) {
1127                 video_enc->rc_override[i].qscale         = q;
1128                 video_enc->rc_override[i].quality_factor = 1.0;
1129             }
1130             else {
1131                 video_enc->rc_override[i].qscale         = 0;
1132                 video_enc->rc_override[i].quality_factor = -q/100.0;
1133             }
1134             p = strchr(p, '/');
1135             if (p) p++;
1136         }
1137         video_enc->rc_override_count = i;
1138         if (!video_enc->rc_initial_buffer_occupancy)
1139             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1140         video_enc->intra_dc_precision = intra_dc_precision - 8;
1141
1142         if (do_psnr)
1143             video_enc->flags|= CODEC_FLAG_PSNR;
1144
1145         /* two pass mode */
1146         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1147         if (do_pass) {
1148             if (do_pass & 1) {
1149                 video_enc->flags |= CODEC_FLAG_PASS1;
1150             }
1151             if (do_pass & 2) {
1152                 video_enc->flags |= CODEC_FLAG_PASS2;
1153             }
1154         }
1155
1156         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1157         if (ost->logfile_prefix &&
1158             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1159             exit(1);
1160
1161         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1162         if (ost->forced_keyframes)
1163             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1164
1165         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1166
1167         ost->top_field_first = -1;
1168         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1169
1170         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1171         ost->avfilter = av_strdup(filters);
1172     } else {
1173         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1174     }
1175
1176     return ost;
1177 }
1178
1179 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1180 {
1181     int n;
1182     AVStream *st;
1183     OutputStream *ost;
1184     AVCodecContext *audio_enc;
1185
1186     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1187     st  = ost->st;
1188
1189     audio_enc = st->codec;
1190     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1191
1192     if (!ost->stream_copy) {
1193         char *sample_fmt = NULL;
1194         const char *filters = "anull";
1195
1196         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1197
1198         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1199         if (sample_fmt &&
1200             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1201             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1202             exit(1);
1203         }
1204
1205         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1206
1207         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1208
1209         av_assert1(filters);
1210         ost->avfilter = av_strdup(filters);
1211
1212         /* check for channel mapping for this audio stream */
1213         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1214             AudioChannelMap *map = &o->audio_channel_maps[n];
1215             InputStream *ist = input_streams[ost->source_index];
1216             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1217                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1218                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1219                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1220                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1221                 else
1222                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1223                            ost->file_index, ost->st->index);
1224             }
1225         }
1226     }
1227
1228     return ost;
1229 }
1230
1231 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1232 {
1233     OutputStream *ost;
1234
1235     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1236     if (!ost->stream_copy) {
1237         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1238         exit(1);
1239     }
1240
1241     return ost;
1242 }
1243
1244 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1245 {
1246     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1247     ost->stream_copy = 1;
1248     return ost;
1249 }
1250
1251 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1252 {
1253     AVStream *st;
1254     OutputStream *ost;
1255     AVCodecContext *subtitle_enc;
1256
1257     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1258     st  = ost->st;
1259     subtitle_enc = st->codec;
1260
1261     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1262
1263     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1264
1265     if (!ost->stream_copy) {
1266         char *frame_size = NULL;
1267
1268         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1269         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1270             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1271             exit(1);
1272         }
1273     }
1274
1275     return ost;
1276 }
1277
1278 /* arg format is "output-stream-index:streamid-value". */
1279 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1280 {
1281     OptionsContext *o = optctx;
1282     int idx;
1283     char *p;
1284     char idx_str[16];
1285
1286     av_strlcpy(idx_str, arg, sizeof(idx_str));
1287     p = strchr(idx_str, ':');
1288     if (!p) {
1289         av_log(NULL, AV_LOG_FATAL,
1290                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1291                arg, opt);
1292         exit(1);
1293     }
1294     *p++ = '\0';
1295     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1296     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1297     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1298     return 0;
1299 }
1300
1301 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1302 {
1303     AVFormatContext *is = ifile->ctx;
1304     AVFormatContext *os = ofile->ctx;
1305     AVChapter **tmp;
1306     int i;
1307
1308     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1309     if (!tmp)
1310         return AVERROR(ENOMEM);
1311     os->chapters = tmp;
1312
1313     for (i = 0; i < is->nb_chapters; i++) {
1314         AVChapter *in_ch = is->chapters[i], *out_ch;
1315         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1316                                        AV_TIME_BASE_Q, in_ch->time_base);
1317         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1318                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1319
1320
1321         if (in_ch->end < ts_off)
1322             continue;
1323         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1324             break;
1325
1326         out_ch = av_mallocz(sizeof(AVChapter));
1327         if (!out_ch)
1328             return AVERROR(ENOMEM);
1329
1330         out_ch->id        = in_ch->id;
1331         out_ch->time_base = in_ch->time_base;
1332         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1333         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1334
1335         if (copy_metadata)
1336             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1337
1338         os->chapters[os->nb_chapters++] = out_ch;
1339     }
1340     return 0;
1341 }
1342
1343 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1344 {
1345     int i, err;
1346     AVFormatContext *ic = avformat_alloc_context();
1347
1348     ic->interrupt_callback = int_cb;
1349     err = avformat_open_input(&ic, filename, NULL, NULL);
1350     if (err < 0)
1351         return err;
1352     /* copy stream format */
1353     for(i=0;i<ic->nb_streams;i++) {
1354         AVStream *st;
1355         OutputStream *ost;
1356         AVCodec *codec;
1357         AVCodecContext *avctx;
1358
1359         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1360         ost   = new_output_stream(o, s, codec->type, -1);
1361         st    = ost->st;
1362         avctx = st->codec;
1363         ost->enc = codec;
1364
1365         // FIXME: a more elegant solution is needed
1366         memcpy(st, ic->streams[i], sizeof(AVStream));
1367         st->cur_dts = 0;
1368         st->info = av_malloc(sizeof(*st->info));
1369         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1370         st->codec= avctx;
1371         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1372
1373         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1374             choose_sample_fmt(st, codec);
1375         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1376             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1377     }
1378
1379     /* ffserver seeking with date=... needs a date reference */
1380     err = parse_option(o, "metadata", "creation_time=now", options);
1381
1382     avformat_close_input(&ic);
1383     return err;
1384 }
1385
1386 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1387                                AVFormatContext *oc)
1388 {
1389     OutputStream *ost;
1390
1391     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1392                                   ofilter->out_tmp->pad_idx)) {
1393     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1394     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1395     default:
1396         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1397                "currently.\n");
1398         exit(1);
1399     }
1400
1401     ost->source_index = -1;
1402     ost->filter       = ofilter;
1403
1404     ofilter->ost      = ost;
1405
1406     if (ost->stream_copy) {
1407         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1408                "which is fed from a complex filtergraph. Filtering and streamcopy "
1409                "cannot be used together.\n", ost->file_index, ost->index);
1410         exit(1);
1411     }
1412
1413     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1414         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1415         exit(1);
1416     }
1417     avfilter_inout_free(&ofilter->out_tmp);
1418 }
1419
1420 static int configure_complex_filters(void)
1421 {
1422     int i, ret = 0;
1423
1424     for (i = 0; i < nb_filtergraphs; i++)
1425         if (!filtergraphs[i]->graph &&
1426             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1427             return ret;
1428     return 0;
1429 }
1430
1431 void opt_output_file(void *optctx, const char *filename)
1432 {
1433     OptionsContext *o = optctx;
1434     AVFormatContext *oc;
1435     int i, j, err;
1436     AVOutputFormat *file_oformat;
1437     OutputStream *ost;
1438     InputStream  *ist;
1439
1440     if (configure_complex_filters() < 0) {
1441         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1442         exit(1);
1443     }
1444
1445     if (!strcmp(filename, "-"))
1446         filename = "pipe:";
1447
1448     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1449     if (!oc) {
1450         print_error(filename, err);
1451         exit(1);
1452     }
1453     file_oformat= oc->oformat;
1454     oc->interrupt_callback = int_cb;
1455
1456     /* create streams for all unlabeled output pads */
1457     for (i = 0; i < nb_filtergraphs; i++) {
1458         FilterGraph *fg = filtergraphs[i];
1459         for (j = 0; j < fg->nb_outputs; j++) {
1460             OutputFilter *ofilter = fg->outputs[j];
1461
1462             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1463                 continue;
1464
1465             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1466                                           ofilter->out_tmp->pad_idx)) {
1467             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1468             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1469             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1470             }
1471             init_output_filter(ofilter, o, oc);
1472         }
1473     }
1474
1475     if (!strcmp(file_oformat->name, "ffm") &&
1476         av_strstart(filename, "http:", NULL)) {
1477         int j;
1478         /* special case for files sent to ffserver: we get the stream
1479            parameters from ffserver */
1480         int err = read_ffserver_streams(o, oc, filename);
1481         if (err < 0) {
1482             print_error(filename, err);
1483             exit(1);
1484         }
1485         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1486             ost = output_streams[j];
1487             for (i = 0; i < nb_input_streams; i++) {
1488                 ist = input_streams[i];
1489                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1490                     ost->sync_ist= ist;
1491                     ost->source_index= i;
1492                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1493                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1494                     ist->discard = 0;
1495                     ist->st->discard = AVDISCARD_NONE;
1496                     break;
1497                 }
1498             }
1499             if(!ost->sync_ist){
1500                 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
1501                 exit(1);
1502             }
1503         }
1504     } else if (!o->nb_stream_maps) {
1505         char *subtitle_codec_name = NULL;
1506         /* pick the "best" stream of each type */
1507
1508         /* video: highest resolution */
1509         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1510             int area = 0, idx = -1;
1511             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1512             for (i = 0; i < nb_input_streams; i++) {
1513                 int new_area;
1514                 ist = input_streams[i];
1515                 new_area = ist->st->codec->width * ist->st->codec->height;
1516                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1517                     new_area = 1;
1518                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1519                     new_area > area) {
1520                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1521                         continue;
1522                     area = new_area;
1523                     idx = i;
1524                 }
1525             }
1526             if (idx >= 0)
1527                 new_video_stream(o, oc, idx);
1528         }
1529
1530         /* audio: most channels */
1531         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1532             int channels = 0, idx = -1;
1533             for (i = 0; i < nb_input_streams; i++) {
1534                 ist = input_streams[i];
1535                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1536                     ist->st->codec->channels > channels) {
1537                     channels = ist->st->codec->channels;
1538                     idx = i;
1539                 }
1540             }
1541             if (idx >= 0)
1542                 new_audio_stream(o, oc, idx);
1543         }
1544
1545         /* subtitles: pick first */
1546         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1547         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1548             for (i = 0; i < nb_input_streams; i++)
1549                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1550                     new_subtitle_stream(o, oc, i);
1551                     break;
1552                 }
1553         }
1554         /* do something with data? */
1555     } else {
1556         for (i = 0; i < o->nb_stream_maps; i++) {
1557             StreamMap *map = &o->stream_maps[i];
1558             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1559
1560             if (map->disabled)
1561                 continue;
1562
1563             if (map->linklabel) {
1564                 FilterGraph *fg;
1565                 OutputFilter *ofilter = NULL;
1566                 int j, k;
1567
1568                 for (j = 0; j < nb_filtergraphs; j++) {
1569                     fg = filtergraphs[j];
1570                     for (k = 0; k < fg->nb_outputs; k++) {
1571                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1572                         if (out && !strcmp(out->name, map->linklabel)) {
1573                             ofilter = fg->outputs[k];
1574                             goto loop_end;
1575                         }
1576                     }
1577                 }
1578 loop_end:
1579                 if (!ofilter) {
1580                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1581                            "in any defined filter graph.\n", map->linklabel);
1582                     exit(1);
1583                 }
1584                 init_output_filter(ofilter, o, oc);
1585             } else {
1586                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1587                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1588                     continue;
1589                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1590                     continue;
1591                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1592                     continue;
1593                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1594                     continue;
1595
1596                 switch (ist->st->codec->codec_type) {
1597                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1598                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1599                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1600                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1601                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1602                 default:
1603                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1604                            map->file_index, map->stream_index);
1605                     exit(1);
1606                 }
1607             }
1608         }
1609     }
1610
1611
1612     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1613         AVDictionaryEntry *e;
1614         ost = output_streams[i];
1615
1616         if (   ost->stream_copy
1617             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1618             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1619             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1620                 exit(1);
1621     }
1622
1623     /* handle attached files */
1624     for (i = 0; i < o->nb_attachments; i++) {
1625         AVIOContext *pb;
1626         uint8_t *attachment;
1627         const char *p;
1628         int64_t len;
1629
1630         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1631             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1632                    o->attachments[i]);
1633             exit(1);
1634         }
1635         if ((len = avio_size(pb)) <= 0) {
1636             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1637                    o->attachments[i]);
1638             exit(1);
1639         }
1640         if (!(attachment = av_malloc(len))) {
1641             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1642                    o->attachments[i]);
1643             exit(1);
1644         }
1645         avio_read(pb, attachment, len);
1646
1647         ost = new_attachment_stream(o, oc, -1);
1648         ost->stream_copy               = 0;
1649         ost->attachment_filename       = o->attachments[i];
1650         ost->st->codec->extradata      = attachment;
1651         ost->st->codec->extradata_size = len;
1652
1653         p = strrchr(o->attachments[i], '/');
1654         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1655         avio_close(pb);
1656     }
1657
1658     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1659     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1660         exit(1);
1661
1662     output_files[nb_output_files - 1]->ctx            = oc;
1663     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1664     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1665     if (o->recording_time != INT64_MAX)
1666         oc->duration = o->recording_time;
1667     output_files[nb_output_files - 1]->start_time     = o->start_time;
1668     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1669     output_files[nb_output_files - 1]->shortest       = o->shortest;
1670     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1671
1672     /* check filename in case of an image number is expected */
1673     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1674         if (!av_filename_number_test(oc->filename)) {
1675             print_error(oc->filename, AVERROR(EINVAL));
1676             exit(1);
1677         }
1678     }
1679
1680     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1681         /* test if it already exists to avoid losing precious files */
1682         assert_file_overwrite(filename);
1683
1684         /* open the file */
1685         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1686                               &oc->interrupt_callback,
1687                               &output_files[nb_output_files - 1]->opts)) < 0) {
1688             print_error(filename, err);
1689             exit(1);
1690         }
1691     }
1692
1693     if (o->mux_preload) {
1694         uint8_t buf[64];
1695         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1696         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1697     }
1698     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1699
1700     /* copy metadata */
1701     for (i = 0; i < o->nb_metadata_map; i++) {
1702         char *p;
1703         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1704
1705         if (in_file_index >= nb_input_files) {
1706             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1707             exit(1);
1708         }
1709         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
1710     }
1711
1712     /* copy chapters */
1713     if (o->chapters_input_file >= nb_input_files) {
1714         if (o->chapters_input_file == INT_MAX) {
1715             /* copy chapters from the first input file that has them*/
1716             o->chapters_input_file = -1;
1717             for (i = 0; i < nb_input_files; i++)
1718                 if (input_files[i]->ctx->nb_chapters) {
1719                     o->chapters_input_file = i;
1720                     break;
1721                 }
1722         } else {
1723             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1724                    o->chapters_input_file);
1725             exit(1);
1726         }
1727     }
1728     if (o->chapters_input_file >= 0)
1729         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1730                       !o->metadata_chapters_manual);
1731
1732     /* copy global metadata by default */
1733     if (!o->metadata_global_manual && nb_input_files){
1734         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1735                      AV_DICT_DONT_OVERWRITE);
1736         if(o->recording_time != INT64_MAX)
1737             av_dict_set(&oc->metadata, "duration", NULL, 0);
1738         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1739     }
1740     if (!o->metadata_streams_manual)
1741         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1742             InputStream *ist;
1743             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1744                 continue;
1745             ist = input_streams[output_streams[i]->source_index];
1746             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1747         }
1748
1749     /* process manually set metadata */
1750     for (i = 0; i < o->nb_metadata; i++) {
1751         AVDictionary **m;
1752         char type, *val;
1753         const char *stream_spec;
1754         int index = 0, j, ret = 0;
1755
1756         val = strchr(o->metadata[i].u.str, '=');
1757         if (!val) {
1758             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1759                    o->metadata[i].u.str);
1760             exit(1);
1761         }
1762         *val++ = 0;
1763
1764         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1765         if (type == 's') {
1766             for (j = 0; j < oc->nb_streams; j++) {
1767                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1768                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1769                 } else if (ret < 0)
1770                     exit(1);
1771             }
1772         }
1773         else {
1774             switch (type) {
1775             case 'g':
1776                 m = &oc->metadata;
1777                 break;
1778             case 'c':
1779                 if (index < 0 || index >= oc->nb_chapters) {
1780                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1781                     exit(1);
1782                 }
1783                 m = &oc->chapters[index]->metadata;
1784                 break;
1785             default:
1786                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1787                 exit(1);
1788             }
1789             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1790         }
1791     }
1792
1793     reset_options(o, 0);
1794 }
1795
1796 static int opt_target(void *optctx, const char *opt, const char *arg)
1797 {
1798     OptionsContext *o = optctx;
1799     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1800     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1801
1802     if (!strncmp(arg, "pal-", 4)) {
1803         norm = PAL;
1804         arg += 4;
1805     } else if (!strncmp(arg, "ntsc-", 5)) {
1806         norm = NTSC;
1807         arg += 5;
1808     } else if (!strncmp(arg, "film-", 5)) {
1809         norm = FILM;
1810         arg += 5;
1811     } else {
1812         /* Try to determine PAL/NTSC by peeking in the input files */
1813         if (nb_input_files) {
1814             int i, j, fr;
1815             for (j = 0; j < nb_input_files; j++) {
1816                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1817                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1818                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1819                         continue;
1820                     fr = c->time_base.den * 1000 / c->time_base.num;
1821                     if (fr == 25000) {
1822                         norm = PAL;
1823                         break;
1824                     } else if ((fr == 29970) || (fr == 23976)) {
1825                         norm = NTSC;
1826                         break;
1827                     }
1828                 }
1829                 if (norm != UNKNOWN)
1830                     break;
1831             }
1832         }
1833         if (norm != UNKNOWN)
1834             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1835     }
1836
1837     if (norm == UNKNOWN) {
1838         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1839         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1840         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1841         exit(1);
1842     }
1843
1844     if (!strcmp(arg, "vcd")) {
1845         opt_video_codec(o, "c:v", "mpeg1video");
1846         opt_audio_codec(o, "c:a", "mp2");
1847         parse_option(o, "f", "vcd", options);
1848
1849         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1850         parse_option(o, "r", frame_rates[norm], options);
1851         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1852
1853         opt_default(NULL, "b:v", "1150000");
1854         opt_default(NULL, "maxrate", "1150000");
1855         opt_default(NULL, "minrate", "1150000");
1856         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1857
1858         opt_default(NULL, "b:a", "224000");
1859         parse_option(o, "ar", "44100", options);
1860         parse_option(o, "ac", "2", options);
1861
1862         opt_default(NULL, "packetsize", "2324");
1863         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1864
1865         /* We have to offset the PTS, so that it is consistent with the SCR.
1866            SCR starts at 36000, but the first two packs contain only padding
1867            and the first pack from the other stream, respectively, may also have
1868            been written before.
1869            So the real data starts at SCR 36000+3*1200. */
1870         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1871     } else if (!strcmp(arg, "svcd")) {
1872
1873         opt_video_codec(o, "c:v", "mpeg2video");
1874         opt_audio_codec(o, "c:a", "mp2");
1875         parse_option(o, "f", "svcd", options);
1876
1877         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1878         parse_option(o, "r", frame_rates[norm], options);
1879         parse_option(o, "pix_fmt", "yuv420p", options);
1880         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1881
1882         opt_default(NULL, "b:v", "2040000");
1883         opt_default(NULL, "maxrate", "2516000");
1884         opt_default(NULL, "minrate", "0"); // 1145000;
1885         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1886         opt_default(NULL, "scan_offset", "1");
1887
1888         opt_default(NULL, "b:a", "224000");
1889         parse_option(o, "ar", "44100", options);
1890
1891         opt_default(NULL, "packetsize", "2324");
1892
1893     } else if (!strcmp(arg, "dvd")) {
1894
1895         opt_video_codec(o, "c:v", "mpeg2video");
1896         opt_audio_codec(o, "c:a", "ac3");
1897         parse_option(o, "f", "dvd", options);
1898
1899         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1900         parse_option(o, "r", frame_rates[norm], options);
1901         parse_option(o, "pix_fmt", "yuv420p", options);
1902         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1903
1904         opt_default(NULL, "b:v", "6000000");
1905         opt_default(NULL, "maxrate", "9000000");
1906         opt_default(NULL, "minrate", "0"); // 1500000;
1907         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1908
1909         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1910         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1911
1912         opt_default(NULL, "b:a", "448000");
1913         parse_option(o, "ar", "48000", options);
1914
1915     } else if (!strncmp(arg, "dv", 2)) {
1916
1917         parse_option(o, "f", "dv", options);
1918
1919         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1920         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1921                           norm == PAL ? "yuv420p" : "yuv411p", options);
1922         parse_option(o, "r", frame_rates[norm], options);
1923
1924         parse_option(o, "ar", "48000", options);
1925         parse_option(o, "ac", "2", options);
1926
1927     } else {
1928         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1929         return AVERROR(EINVAL);
1930     }
1931     return 0;
1932 }
1933
1934 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1935 {
1936     av_free (vstats_filename);
1937     vstats_filename = av_strdup (arg);
1938     return 0;
1939 }
1940
1941 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1942 {
1943     char filename[40];
1944     time_t today2 = time(NULL);
1945     struct tm *today = localtime(&today2);
1946
1947     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1948              today->tm_sec);
1949     return opt_vstats_file(NULL, opt, filename);
1950 }
1951
1952 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1953 {
1954     OptionsContext *o = optctx;
1955     return parse_option(o, "frames:v", arg, options);
1956 }
1957
1958 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1959 {
1960     OptionsContext *o = optctx;
1961     return parse_option(o, "frames:a", arg, options);
1962 }
1963
1964 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1965 {
1966     OptionsContext *o = optctx;
1967     return parse_option(o, "frames:d", arg, options);
1968 }
1969
1970 static int opt_preset(void *optctx, const char *opt, const char *arg)
1971 {
1972     OptionsContext *o = optctx;
1973     FILE *f=NULL;
1974     char filename[1000], line[1000], tmp_line[1000];
1975     const char *codec_name = NULL;
1976
1977     tmp_line[0] = *opt;
1978     tmp_line[1] = 0;
1979     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1980
1981     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1982         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1983             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1984         }else
1985             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
1986         exit(1);
1987 }
1988
1989     while (fgets(line, sizeof(line), f)) {
1990         char *key = tmp_line, *value, *endptr;
1991
1992         if (strcspn(line, "#\n\r") == 0)
1993             continue;
1994         strcpy(tmp_line, line);
1995         if (!av_strtok(key,   "=",    &value) ||
1996             !av_strtok(value, "\r\n", &endptr)) {
1997             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
1998             exit(1);
1999         }
2000         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2001
2002         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2003         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2004         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2005         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2006         else if (opt_default(NULL, key, value) < 0) {
2007             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2008                    filename, line, key, value);
2009             exit(1);
2010         }
2011     }
2012
2013     fclose(f);
2014
2015     return 0;
2016 }
2017
2018 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2019 {
2020     OptionsContext *o = optctx;
2021     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2022     int ret = parse_option(o, s, arg, options);
2023     av_free(s);
2024     return ret;
2025 }
2026
2027 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2028 {
2029     OptionsContext *o = optctx;
2030     if(!strcmp(opt, "b")){
2031         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2032         return parse_option(o, "b:v", arg, options);
2033     }
2034     return opt_default(optctx, opt, arg);
2035 }
2036
2037 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2038 {
2039     OptionsContext *o = optctx;
2040     char *s;
2041     int ret;
2042     if(!strcmp(opt, "qscale")){
2043         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2044         return parse_option(o, "q:v", arg, options);
2045     }
2046     s = av_asprintf("q%s", opt + 6);
2047     ret = parse_option(o, s, arg, options);
2048     av_free(s);
2049     return ret;
2050 }
2051
2052 static int opt_profile(void *optctx, const char *opt, const char *arg)
2053 {
2054     OptionsContext *o = optctx;
2055     if(!strcmp(opt, "profile")){
2056         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2057         return parse_option(o, "profile:v", arg, options);
2058     }
2059     return opt_default(optctx, opt, arg);
2060
2061 }
2062
2063 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2064 {
2065     OptionsContext *o = optctx;
2066     return parse_option(o, "filter:v", arg, options);
2067 }
2068
2069 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2070 {
2071     OptionsContext *o = optctx;
2072     return parse_option(o, "filter:a", arg, options);
2073 }
2074
2075 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2076 {
2077     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2078     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2079     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2080     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2081
2082     if (video_sync_method == VSYNC_AUTO)
2083         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2084     return 0;
2085 }
2086
2087 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2088 {
2089     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2090     do_deinterlace = 1;
2091     return 0;
2092 }
2093
2094 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2095 {
2096     OptionsContext *o = optctx;
2097     char *tcr = av_asprintf("timecode=%s", arg);
2098     int ret = parse_option(o, "metadata:g", tcr, options);
2099     if (ret >= 0)
2100         ret = opt_default(optctx, "gop_timecode", arg);
2101     av_free(tcr);
2102     return ret;
2103 }
2104
2105 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2106 {
2107     OptionsContext *o = optctx;
2108     char layout_str[32];
2109     char *stream_str;
2110     char *ac_str;
2111     int ret, channels, ac_str_size;
2112     uint64_t layout;
2113
2114     layout = av_get_channel_layout(arg);
2115     if (!layout) {
2116         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2117         return AVERROR(EINVAL);
2118     }
2119     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2120     ret = opt_default(NULL, opt, layout_str);
2121     if (ret < 0)
2122         return ret;
2123
2124     /* set 'ac' option based on channel layout */
2125     channels = av_get_channel_layout_nb_channels(layout);
2126     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2127     stream_str = strchr(opt, ':');
2128     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2129     ac_str = av_mallocz(ac_str_size);
2130     if (!ac_str)
2131         return AVERROR(ENOMEM);
2132     av_strlcpy(ac_str, "ac", 3);
2133     if (stream_str)
2134         av_strlcat(ac_str, stream_str, ac_str_size);
2135     ret = parse_option(o, ac_str, layout_str, options);
2136     av_free(ac_str);
2137
2138     return ret;
2139 }
2140
2141 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2142 {
2143     OptionsContext *o = optctx;
2144     return parse_option(o, "q:a", arg, options);
2145 }
2146
2147 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2148 {
2149     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2150                               &nb_filtergraphs, nb_filtergraphs + 1);
2151     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2152         return AVERROR(ENOMEM);
2153     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2154     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2155     return 0;
2156 }
2157
2158 void show_help_default(const char *opt, const char *arg)
2159 {
2160     /* per-file options have at least one of those set */
2161     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2162     int show_advanced = 0, show_avoptions = 0;
2163
2164     if (opt && *opt) {
2165         if (!strcmp(opt, "long"))
2166             show_advanced = 1;
2167         else if (!strcmp(opt, "full"))
2168             show_advanced = show_avoptions = 1;
2169         else
2170             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2171     }
2172
2173     show_usage();
2174
2175     printf("Getting help:\n"
2176            "    -h      -- print basic options\n"
2177            "    -h long -- print more options\n"
2178            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2179            "    See man %s for detailed description of the options.\n"
2180            "\n", program_name);
2181
2182     show_help_options(options, "Print help / information / capabilities:",
2183                       OPT_EXIT, 0, 0);
2184
2185     show_help_options(options, "Global options (affect whole program "
2186                       "instead of just one file:",
2187                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2188     if (show_advanced)
2189         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2190                           per_file | OPT_EXIT, 0);
2191
2192     show_help_options(options, "Per-file main options:", 0,
2193                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2194                       OPT_EXIT, per_file);
2195     if (show_advanced)
2196         show_help_options(options, "Advanced per-file options:",
2197                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2198
2199     show_help_options(options, "Video options:",
2200                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2201     if (show_advanced)
2202         show_help_options(options, "Advanced Video options:",
2203                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2204
2205     show_help_options(options, "Audio options:",
2206                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2207     if (show_advanced)
2208         show_help_options(options, "Advanced Audio options:",
2209                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2210     show_help_options(options, "Subtitle options:",
2211                       OPT_SUBTITLE, 0, 0);
2212     printf("\n");
2213
2214     if (show_avoptions) {
2215         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2216         show_help_children(avcodec_get_class(), flags);
2217         show_help_children(avformat_get_class(), flags);
2218         show_help_children(sws_get_class(), flags);
2219         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2220         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2221     }
2222 }
2223
2224 void show_usage(void)
2225 {
2226     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2227     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2228     av_log(NULL, AV_LOG_INFO, "\n");
2229 }
2230
2231
2232 static int opt_progress(void *optctx, const char *opt, const char *arg)
2233 {
2234     AVIOContext *avio = NULL;
2235     int ret;
2236
2237     if (!strcmp(arg, "-"))
2238         arg = "pipe:";
2239     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2240     if (ret < 0) {
2241         av_log(0, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2242                arg, av_err2str(ret));
2243         return ret;
2244     }
2245     progress_avio = avio;
2246     return 0;
2247 }
2248
2249 #define OFFSET(x) offsetof(OptionsContext, x)
2250 const OptionDef options[] = {
2251     /* main options */
2252 #include "cmdutils_common_opts.h"
2253     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
2254         "force format", "fmt" },
2255     { "i",              HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_input_file },
2256         "input file name", "filename" },
2257     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2258         "overwrite output files" },
2259     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2260         "do not overwrite output files" },
2261     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2262         "codec name", "codec" },
2263     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2264         "codec name", "codec" },
2265     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
2266         "preset name", "preset" },
2267     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
2268         "set input stream mapping",
2269         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2270     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map_channel },
2271         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2272     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
2273         "set metadata information of outfile from infile",
2274         "outfile[,metadata]:infile[,metadata]" },
2275     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2276         "set chapters mapping", "input_file_index" },
2277     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
2278         "record or transcode \"duration\" seconds of audio/video",
2279         "duration" },
2280     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
2281         "set the limit file size in bytes", "limit_size" },
2282     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
2283         "set the start time offset", "time_off" },
2284     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2285         "set the input ts offset", "time_off" },
2286     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2287         "set the input ts scale", "scale" },
2288     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2289         "set the recording timestamp ('now' to set the current time)", "time" },
2290     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
2291         "add metadata", "string=string" },
2292     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
2293         "set the number of data frames to record", "number" },
2294     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2295         "add timings for benchmarking" },
2296     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2297       "add timings for each task" },
2298     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2299       "write program-readable progress information", "url" },
2300     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2301       "enable or disable interaction on standard input" },
2302     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2303         "set max runtime in seconds", "limit" },
2304     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2305         "dump each input packet" },
2306     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2307         "when dumping packets, also dump the payload" },
2308     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
2309         "read input at native frame rate", "" },
2310     { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
2311         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2312         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2313     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2314         "video sync method", "" },
2315     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2316         "audio sync method", "" },
2317     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2318         "audio drift threshold", "threshold" },
2319     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2320         "copy timestamps" },
2321     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2322         "copy input stream time base when stream copying", "mode" },
2323     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2324         "finish encoding within shortest input" },
2325     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2326         "timestamp discontinuity delta threshold", "threshold" },
2327     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2328         "timestamp error delta threshold", "threshold" },
2329     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2330         "exit on error", "error" },
2331     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2332         "copy initial non-keyframes" },
2333     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC,   { .off = OFFSET(copy_prior_start) },
2334         "copy or discard frames before start time" },
2335     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2336         "set the number of frames to record", "number" },
2337     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2338         "force codec tag/fourcc", "fourcc/tag" },
2339     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2340         "use fixed quality scale (VBR)", "q" },
2341     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_qscale },
2342         "use fixed quality scale (VBR)", "q" },
2343     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_profile },
2344         "set profile", "profile" },
2345     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2346         "set stream filterchain", "filter_list" },
2347     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC,                { .off = OFFSET(reinit_filters) },
2348         "reinit filtergraph on input parameter changes", "" },
2349     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2350         "create a complex filtergraph", "graph_description" },
2351     { "stats",          OPT_BOOL,                                    { &print_stats },
2352         "print progress report during encoding", },
2353     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
2354         "add an attachment to the output file", "filename" },
2355     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2356         "extract an attachment into a file", "filename" },
2357     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2358         "print timestamp debugging info" },
2359
2360     /* video options */
2361     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
2362         "set the number of video frames to record", "number" },
2363     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2364         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2365     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2366         "set frame size (WxH or abbreviation)", "size" },
2367     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2368         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2369     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2370         "set pixel format", "format" },
2371     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2372         "set the number of bits per raw sample", "number" },
2373     { "croptop",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2374         "Removed, use the crop filter instead", "size" },
2375     { "cropbottom",   OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2376         "Removed, use the crop filter instead", "size" },
2377     { "cropleft",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2378         "Removed, use the crop filter instead", "size" },
2379     { "cropright",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2380         "Removed, use the crop filter instead", "size" },
2381     { "padtop",       OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2382         "Removed, use the pad filter instead", "size" },
2383     { "padbottom",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2384         "Removed, use the pad filter instead", "size" },
2385     { "padleft",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2386         "Removed, use the pad filter instead", "size" },
2387     { "padright",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2388         "Removed, use the pad filter instead", "size" },
2389     { "padcolor",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2390         "Removed, use the pad filter instead", "color" },
2391     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2392         "deprecated use -g 1" },
2393     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2394         "disable video" },
2395     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2396         "discard threshold", "n" },
2397     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2398         "rate control override for specific intervals", "override" },
2399     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
2400         "force video codec ('copy' to copy stream)", "codec" },
2401     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2402         "Removed" },
2403     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2404         "Removed" },
2405     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_timecode },
2406         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2407     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
2408         "select the pass number (1 to 3)", "n" },
2409     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
2410         "select two pass log file name prefix", "prefix" },
2411     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2412         "this option is deprecated, use the yadif filter instead" },
2413     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2414         "calculate PSNR of compressed frames" },
2415     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2416         "dump video coding statistics to file" },
2417     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2418         "dump video coding statistics to file", "file" },
2419     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
2420         "video filters", "filter list" },
2421     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2422         "specify intra matrix coeffs", "matrix" },
2423     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2424         "specify inter matrix coeffs", "matrix" },
2425     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2426         "top=1/bottom=0/auto=-1 field first", "" },
2427     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2428         "intra_dc_precision", "precision" },
2429     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_old2new },
2430         "force video tag/fourcc", "fourcc/tag" },
2431     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2432         "show QP histogram" },
2433     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2434         "force the selected framerate, disable the best supported framerate selection" },
2435     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2436         "set the value of an outfile streamid", "streamIndex:value" },
2437     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2438         { .off = OFFSET(forced_key_frames) },
2439         "force key frames at specified timestamps", "timestamps" },
2440     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_bitrate },
2441         "video bitrate (please use -b:v)", "bitrate" },
2442
2443     /* audio options */
2444     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2445         "set the number of audio frames to record", "number" },
2446     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2447         "set audio quality (codec-specific)", "quality", },
2448     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2449         "set audio sampling rate (in Hz)", "rate" },
2450     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2451         "set number of audio channels", "channels" },
2452     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2453         "disable audio" },
2454     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2455         "force audio codec ('copy' to copy stream)", "codec" },
2456     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_old2new },
2457         "force audio tag/fourcc", "fourcc/tag" },
2458     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2459         "change audio volume (256=normal)" , "volume" },
2460     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2461         "set sample format", "format" },
2462     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2463         "set channel layout", "layout" },
2464     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2465         "audio filters", "filter list" },
2466
2467     /* subtitle options */
2468     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2469         "disable subtitle" },
2470     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2471         "force subtitle codec ('copy' to copy stream)", "codec" },
2472     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_old2new }
2473         , "force subtitle tag/fourcc", "fourcc/tag" },
2474     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2475         "fix subtitles duration" },
2476
2477     /* grab options */
2478     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2479         "deprecated, use -channel", "channel" },
2480     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2481         "deprecated, use -standard", "standard" },
2482     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2483
2484     /* muxer options */
2485     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2486         "set the maximum demux-decode delay", "seconds" },
2487     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2488         "set the initial demux-decode delay", "seconds" },
2489
2490     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2491         "A comma-separated list of bitstream filters", "bitstream_filters" },
2492     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2493         "deprecated", "audio bitstream_filters" },
2494     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2495         "deprecated", "video bitstream_filters" },
2496
2497     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2498         "set the audio options to the indicated preset", "preset" },
2499     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2500         "set the video options to the indicated preset", "preset" },
2501     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2502         "set the subtitle options to the indicated preset", "preset" },
2503     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE,                { .func_arg = opt_preset },
2504         "set options from indicated preset file", "filename" },
2505     /* data codec support */
2506     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2507         "force data codec ('copy' to copy stream)", "codec" },
2508     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2509         "disable data" },
2510
2511     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2512         "generic catch all option", "" },
2513     { NULL, },
2514 };