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