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