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