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         case 's':\
 460             break; /* handled separately below */ \
 461         default: av_assert0(0);\
 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 = avformat_seek_file(ic, -1, INT64_MIN, timestamp, timestamp, 0);
 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, "filter_type"  , 0, &ost->swr_filter_type);
1019     av_opt_get_int   (swr_opts, "dither_method", 0, &ost->swr_dither_method);
1020     av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
1021
1022     ost->source_index = source_index;
1023     if (source_index >= 0) {
1024         ost->sync_ist = input_streams[source_index];
1025         input_streams[source_index]->discard = 0;
1026         input_streams[source_index]->st->discard = AVDISCARD_NONE;
1027     }
1028
1029     return ost;
1030 }
1031
1032 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1033 {
1034     int i;
1035     const char *p = str;
1036     for (i = 0;; i++) {
1037         dest[i] = atoi(p);
1038         if (i == 63)
1039             break;
1040         p = strchr(p, ',');
1041         if (!p) {
1042             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1043             exit(1);
1044         }
1045         p++;
1046     }
1047 }
1048
1049 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1050 {
1051     AVStream *st;
1052     OutputStream *ost;
1053     AVCodecContext *video_enc;
1054     char *frame_rate = NULL;
1055
1056     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1057     st  = ost->st;
1058     video_enc = st->codec;
1059
1060     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1061     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1062         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1063         exit(1);
1064     }
1065
1066     if (!ost->stream_copy) {
1067         const char *p = NULL;
1068         char *frame_size = NULL;
1069         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
1070         char *intra_matrix = NULL, *inter_matrix = NULL;
1071         const char *filters = "null";
1072         int do_pass = 0;
1073         int i;
1074
1075         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1076         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1077             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1078             exit(1);
1079         }
1080
1081         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1082         if (frame_aspect_ratio) {
1083             AVRational q;
1084             if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1085                 q.num <= 0 || q.den <= 0) {
1086                 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1087                 exit(1);
1088             }
1089             ost->frame_aspect_ratio = av_q2d(q);
1090         }
1091
1092         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1093         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1094         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1095             ost->keep_pix_fmt = 1;
1096             if (!*++frame_pix_fmt)
1097                 frame_pix_fmt = NULL;
1098         }
1099         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1100             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1101             exit(1);
1102         }
1103         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1104
1105         if (intra_only)
1106             video_enc->gop_size = 0;
1107         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1108         if (intra_matrix) {
1109             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1110                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1111                 exit(1);
1112             }
1113             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1114         }
1115         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1116         if (inter_matrix) {
1117             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1118                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1119                 exit(1);
1120             }
1121             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1122         }
1123
1124         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1125         for (i = 0; p; i++) {
1126             int start, end, q;
1127             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1128             if (e != 3) {
1129                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1130                 exit(1);
1131             }
1132             /* FIXME realloc failure */
1133             video_enc->rc_override =
1134                 av_realloc(video_enc->rc_override,
1135                            sizeof(RcOverride) * (i + 1));
1136             video_enc->rc_override[i].start_frame = start;
1137             video_enc->rc_override[i].end_frame   = end;
1138             if (q > 0) {
1139                 video_enc->rc_override[i].qscale         = q;
1140                 video_enc->rc_override[i].quality_factor = 1.0;
1141             }
1142             else {
1143                 video_enc->rc_override[i].qscale         = 0;
1144                 video_enc->rc_override[i].quality_factor = -q/100.0;
1145             }
1146             p = strchr(p, '/');
1147             if (p) p++;
1148         }
1149         video_enc->rc_override_count = i;
1150         if (!video_enc->rc_initial_buffer_occupancy)
1151             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
1152         video_enc->intra_dc_precision = intra_dc_precision - 8;
1153
1154         if (do_psnr)
1155             video_enc->flags|= CODEC_FLAG_PSNR;
1156
1157         /* two pass mode */
1158         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1159         if (do_pass) {
1160             if (do_pass & 1) {
1161                 video_enc->flags |= CODEC_FLAG_PASS1;
1162             }
1163             if (do_pass & 2) {
1164                 video_enc->flags |= CODEC_FLAG_PASS2;
1165             }
1166         }
1167
1168         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1169         if (ost->logfile_prefix &&
1170             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1171             exit(1);
1172
1173         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1174         if (ost->forced_keyframes)
1175             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1176
1177         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1178
1179         ost->top_field_first = -1;
1180         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1181
1182         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1183         ost->avfilter = av_strdup(filters);
1184     } else {
1185         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1186     }
1187
1188     return ost;
1189 }
1190
1191 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1192 {
1193     int n;
1194     AVStream *st;
1195     OutputStream *ost;
1196     AVCodecContext *audio_enc;
1197
1198     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1199     st  = ost->st;
1200
1201     audio_enc = st->codec;
1202     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1203
1204     if (!ost->stream_copy) {
1205         char *sample_fmt = NULL;
1206         const char *filters = "anull";
1207
1208         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1209
1210         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1211         if (sample_fmt &&
1212             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1213             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1214             exit(1);
1215         }
1216
1217         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1218
1219         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1220
1221         av_assert1(filters);
1222         ost->avfilter = av_strdup(filters);
1223
1224         /* check for channel mapping for this audio stream */
1225         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1226             AudioChannelMap *map = &o->audio_channel_maps[n];
1227             InputStream *ist = input_streams[ost->source_index];
1228             if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
1229                 (map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1230                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1231                 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
1232                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1233                 else
1234                     av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
1235                            ost->file_index, ost->st->index);
1236             }
1237         }
1238     }
1239
1240     return ost;
1241 }
1242
1243 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1244 {
1245     OutputStream *ost;
1246
1247     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1248     if (!ost->stream_copy) {
1249         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1250         exit(1);
1251     }
1252
1253     return ost;
1254 }
1255
1256 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1257 {
1258     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1259     ost->stream_copy = 1;
1260     return ost;
1261 }
1262
1263 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1264 {
1265     AVStream *st;
1266     OutputStream *ost;
1267     AVCodecContext *subtitle_enc;
1268
1269     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1270     st  = ost->st;
1271     subtitle_enc = st->codec;
1272
1273     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1274
1275     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1276
1277     if (!ost->stream_copy) {
1278         char *frame_size = NULL;
1279
1280         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1281         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1282             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1283             exit(1);
1284         }
1285     }
1286
1287     return ost;
1288 }
1289
1290 /* arg format is "output-stream-index:streamid-value". */
1291 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1292 {
1293     OptionsContext *o = optctx;
1294     int idx;
1295     char *p;
1296     char idx_str[16];
1297
1298     av_strlcpy(idx_str, arg, sizeof(idx_str));
1299     p = strchr(idx_str, ':');
1300     if (!p) {
1301         av_log(NULL, AV_LOG_FATAL,
1302                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1303                arg, opt);
1304         exit(1);
1305     }
1306     *p++ = '\0';
1307     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1308     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1309     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1310     return 0;
1311 }
1312
1313 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1314 {
1315     AVFormatContext *is = ifile->ctx;
1316     AVFormatContext *os = ofile->ctx;
1317     AVChapter **tmp;
1318     int i;
1319
1320     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1321     if (!tmp)
1322         return AVERROR(ENOMEM);
1323     os->chapters = tmp;
1324
1325     for (i = 0; i < is->nb_chapters; i++) {
1326         AVChapter *in_ch = is->chapters[i], *out_ch;
1327         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1328                                        AV_TIME_BASE_Q, in_ch->time_base);
1329         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1330                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1331
1332
1333         if (in_ch->end < ts_off)
1334             continue;
1335         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1336             break;
1337
1338         out_ch = av_mallocz(sizeof(AVChapter));
1339         if (!out_ch)
1340             return AVERROR(ENOMEM);
1341
1342         out_ch->id        = in_ch->id;
1343         out_ch->time_base = in_ch->time_base;
1344         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1345         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1346
1347         if (copy_metadata)
1348             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1349
1350         os->chapters[os->nb_chapters++] = out_ch;
1351     }
1352     return 0;
1353 }
1354
1355 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1356 {
1357     int i, err;
1358     AVFormatContext *ic = avformat_alloc_context();
1359
1360     ic->interrupt_callback = int_cb;
1361     err = avformat_open_input(&ic, filename, NULL, NULL);
1362     if (err < 0)
1363         return err;
1364     /* copy stream format */
1365     for(i=0;i<ic->nb_streams;i++) {
1366         AVStream *st;
1367         OutputStream *ost;
1368         AVCodec *codec;
1369         AVCodecContext *avctx;
1370
1371         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1372         ost   = new_output_stream(o, s, codec->type, -1);
1373         st    = ost->st;
1374         avctx = st->codec;
1375         ost->enc = codec;
1376
1377         // FIXME: a more elegant solution is needed
1378         memcpy(st, ic->streams[i], sizeof(AVStream));
1379         st->cur_dts = 0;
1380         st->info = av_malloc(sizeof(*st->info));
1381         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
1382         st->codec= avctx;
1383         avcodec_copy_context(st->codec, ic->streams[i]->codec);
1384
1385         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1386             choose_sample_fmt(st, codec);
1387         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1388             choose_pixel_fmt(st, codec, st->codec->pix_fmt);
1389     }
1390
1391     /* ffserver seeking with date=... needs a date reference */
1392     err = parse_option(o, "metadata", "creation_time=now", options);
1393
1394     avformat_close_input(&ic);
1395     return err;
1396 }
1397
1398 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1399                                AVFormatContext *oc)
1400 {
1401     OutputStream *ost;
1402
1403     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1404                                   ofilter->out_tmp->pad_idx)) {
1405     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1406     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1407     default:
1408         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1409                "currently.\n");
1410         exit(1);
1411     }
1412
1413     ost->source_index = -1;
1414     ost->filter       = ofilter;
1415
1416     ofilter->ost      = ost;
1417
1418     if (ost->stream_copy) {
1419         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1420                "which is fed from a complex filtergraph. Filtering and streamcopy "
1421                "cannot be used together.\n", ost->file_index, ost->index);
1422         exit(1);
1423     }
1424
1425     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1426         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1427         exit(1);
1428     }
1429     avfilter_inout_free(&ofilter->out_tmp);
1430 }
1431
1432 static int configure_complex_filters(void)
1433 {
1434     int i, ret = 0;
1435
1436     for (i = 0; i < nb_filtergraphs; i++)
1437         if (!filtergraphs[i]->graph &&
1438             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1439             return ret;
1440     return 0;
1441 }
1442
1443 void opt_output_file(void *optctx, const char *filename)
1444 {
1445     OptionsContext *o = optctx;
1446     AVFormatContext *oc;
1447     int i, j, err;
1448     AVOutputFormat *file_oformat;
1449     OutputStream *ost;
1450     InputStream  *ist;
1451
1452     if (configure_complex_filters() < 0) {
1453         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1454         exit(1);
1455     }
1456
1457     if (!strcmp(filename, "-"))
1458         filename = "pipe:";
1459
1460     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1461     if (!oc) {
1462         print_error(filename, err);
1463         exit(1);
1464     }
1465     file_oformat= oc->oformat;
1466     oc->interrupt_callback = int_cb;
1467
1468     /* create streams for all unlabeled output pads */
1469     for (i = 0; i < nb_filtergraphs; i++) {
1470         FilterGraph *fg = filtergraphs[i];
1471         for (j = 0; j < fg->nb_outputs; j++) {
1472             OutputFilter *ofilter = fg->outputs[j];
1473
1474             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1475                 continue;
1476
1477             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1478                                           ofilter->out_tmp->pad_idx)) {
1479             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1480             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1481             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1482             }
1483             init_output_filter(ofilter, o, oc);
1484         }
1485     }
1486
1487     if (!strcmp(file_oformat->name, "ffm") &&
1488         av_strstart(filename, "http:", NULL)) {
1489         int j;
1490         /* special case for files sent to ffserver: we get the stream
1491            parameters from ffserver */
1492         int err = read_ffserver_streams(o, oc, filename);
1493         if (err < 0) {
1494             print_error(filename, err);
1495             exit(1);
1496         }
1497         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1498             ost = output_streams[j];
1499             for (i = 0; i < nb_input_streams; i++) {
1500                 ist = input_streams[i];
1501                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1502                     ost->sync_ist= ist;
1503                     ost->source_index= i;
1504                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1505                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1506                     ist->discard = 0;
1507                     ist->st->discard = AVDISCARD_NONE;
1508                     break;
1509                 }
1510             }
1511             if(!ost->sync_ist){
1512                 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));
1513                 exit(1);
1514             }
1515         }
1516     } else if (!o->nb_stream_maps) {
1517         char *subtitle_codec_name = NULL;
1518         /* pick the "best" stream of each type */
1519
1520         /* video: highest resolution */
1521         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1522             int area = 0, idx = -1;
1523             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1524             for (i = 0; i < nb_input_streams; i++) {
1525                 int new_area;
1526                 ist = input_streams[i];
1527                 new_area = ist->st->codec->width * ist->st->codec->height;
1528                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1529                     new_area = 1;
1530                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1531                     new_area > area) {
1532                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1533                         continue;
1534                     area = new_area;
1535                     idx = i;
1536                 }
1537             }
1538             if (idx >= 0)
1539                 new_video_stream(o, oc, idx);
1540         }
1541
1542         /* audio: most channels */
1543         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1544             int channels = 0, idx = -1;
1545             for (i = 0; i < nb_input_streams; i++) {
1546                 ist = input_streams[i];
1547                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1548                     ist->st->codec->channels > channels) {
1549                     channels = ist->st->codec->channels;
1550                     idx = i;
1551                 }
1552             }
1553             if (idx >= 0)
1554                 new_audio_stream(o, oc, idx);
1555         }
1556
1557         /* subtitles: pick first */
1558         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
1559         if (!o->subtitle_disable && (oc->oformat->subtitle_codec != AV_CODEC_ID_NONE || subtitle_codec_name)) {
1560             for (i = 0; i < nb_input_streams; i++)
1561                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1562                     new_subtitle_stream(o, oc, i);
1563                     break;
1564                 }
1565         }
1566         /* do something with data? */
1567     } else {
1568         for (i = 0; i < o->nb_stream_maps; i++) {
1569             StreamMap *map = &o->stream_maps[i];
1570             int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
1571
1572             if (map->disabled)
1573                 continue;
1574
1575             if (map->linklabel) {
1576                 FilterGraph *fg;
1577                 OutputFilter *ofilter = NULL;
1578                 int j, k;
1579
1580                 for (j = 0; j < nb_filtergraphs; j++) {
1581                     fg = filtergraphs[j];
1582                     for (k = 0; k < fg->nb_outputs; k++) {
1583                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1584                         if (out && !strcmp(out->name, map->linklabel)) {
1585                             ofilter = fg->outputs[k];
1586                             goto loop_end;
1587                         }
1588                     }
1589                 }
1590 loop_end:
1591                 if (!ofilter) {
1592                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1593                            "in any defined filter graph.\n", map->linklabel);
1594                     exit(1);
1595                 }
1596                 init_output_filter(ofilter, o, oc);
1597             } else {
1598                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1599                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
1600                     continue;
1601                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1602                     continue;
1603                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1604                     continue;
1605                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
1606                     continue;
1607
1608                 switch (ist->st->codec->codec_type) {
1609                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
1610                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
1611                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
1612                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
1613                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
1614                 default:
1615                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1616                            map->file_index, map->stream_index);
1617                     exit(1);
1618                 }
1619             }
1620         }
1621     }
1622
1623
1624     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
1625         AVDictionaryEntry *e;
1626         ost = output_streams[i];
1627
1628         if (   ost->stream_copy
1629             && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
1630             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
1631             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
1632                 exit(1);
1633     }
1634
1635     /* handle attached files */
1636     for (i = 0; i < o->nb_attachments; i++) {
1637         AVIOContext *pb;
1638         uint8_t *attachment;
1639         const char *p;
1640         int64_t len;
1641
1642         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1643             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1644                    o->attachments[i]);
1645             exit(1);
1646         }
1647         if ((len = avio_size(pb)) <= 0) {
1648             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1649                    o->attachments[i]);
1650             exit(1);
1651         }
1652         if (!(attachment = av_malloc(len))) {
1653             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1654                    o->attachments[i]);
1655             exit(1);
1656         }
1657         avio_read(pb, attachment, len);
1658
1659         ost = new_attachment_stream(o, oc, -1);
1660         ost->stream_copy               = 0;
1661         ost->attachment_filename       = o->attachments[i];
1662         ost->st->codec->extradata      = attachment;
1663         ost->st->codec->extradata_size = len;
1664
1665         p = strrchr(o->attachments[i], '/');
1666         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1667         avio_close(pb);
1668     }
1669
1670     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
1671     if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
1672         exit(1);
1673
1674     output_files[nb_output_files - 1]->ctx            = oc;
1675     output_files[nb_output_files - 1]->ost_index      = nb_output_streams - oc->nb_streams;
1676     output_files[nb_output_files - 1]->recording_time = o->recording_time;
1677     if (o->recording_time != INT64_MAX)
1678         oc->duration = o->recording_time;
1679     output_files[nb_output_files - 1]->start_time     = o->start_time;
1680     output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
1681     output_files[nb_output_files - 1]->shortest       = o->shortest;
1682     av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
1683
1684     /* check filename in case of an image number is expected */
1685     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1686         if (!av_filename_number_test(oc->filename)) {
1687             print_error(oc->filename, AVERROR(EINVAL));
1688             exit(1);
1689         }
1690     }
1691
1692     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1693         /* test if it already exists to avoid losing precious files */
1694         assert_file_overwrite(filename);
1695
1696         /* open the file */
1697         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1698                               &oc->interrupt_callback,
1699                               &output_files[nb_output_files - 1]->opts)) < 0) {
1700             print_error(filename, err);
1701             exit(1);
1702         }
1703     }
1704
1705     if (o->mux_preload) {
1706         uint8_t buf[64];
1707         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1708         av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
1709     }
1710     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1711
1712     /* copy metadata */
1713     for (i = 0; i < o->nb_metadata_map; i++) {
1714         char *p;
1715         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1716
1717         if (in_file_index >= nb_input_files) {
1718             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1719             exit(1);
1720         }
1721         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1722                       in_file_index >= 0 ?
1723                       input_files[in_file_index]->ctx : NULL, o);
1724     }
1725
1726     /* copy chapters */
1727     if (o->chapters_input_file >= nb_input_files) {
1728         if (o->chapters_input_file == INT_MAX) {
1729             /* copy chapters from the first input file that has them*/
1730             o->chapters_input_file = -1;
1731             for (i = 0; i < nb_input_files; i++)
1732                 if (input_files[i]->ctx->nb_chapters) {
1733                     o->chapters_input_file = i;
1734                     break;
1735                 }
1736         } else {
1737             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1738                    o->chapters_input_file);
1739             exit(1);
1740         }
1741     }
1742     if (o->chapters_input_file >= 0)
1743         copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
1744                       !o->metadata_chapters_manual);
1745
1746     /* copy global metadata by default */
1747     if (!o->metadata_global_manual && nb_input_files){
1748         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1749                      AV_DICT_DONT_OVERWRITE);
1750         if(o->recording_time != INT64_MAX)
1751             av_dict_set(&oc->metadata, "duration", NULL, 0);
1752         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
1753     }
1754     if (!o->metadata_streams_manual)
1755         for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
1756             InputStream *ist;
1757             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1758                 continue;
1759             ist = input_streams[output_streams[i]->source_index];
1760             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1761         }
1762
1763     /* process manually set metadata */
1764     for (i = 0; i < o->nb_metadata; i++) {
1765         AVDictionary **m;
1766         char type, *val;
1767         const char *stream_spec;
1768         int index = 0, j, ret = 0;
1769
1770         val = strchr(o->metadata[i].u.str, '=');
1771         if (!val) {
1772             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1773                    o->metadata[i].u.str);
1774             exit(1);
1775         }
1776         *val++ = 0;
1777
1778         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1779         if (type == 's') {
1780             for (j = 0; j < oc->nb_streams; j++) {
1781                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1782                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1783                 } else if (ret < 0)
1784                     exit(1);
1785             }
1786         }
1787         else {
1788             switch (type) {
1789             case 'g':
1790                 m = &oc->metadata;
1791                 break;
1792             case 'c':
1793                 if (index < 0 || index >= oc->nb_chapters) {
1794                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1795                     exit(1);
1796                 }
1797                 m = &oc->chapters[index]->metadata;
1798                 break;
1799             default:
1800                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1801                 exit(1);
1802             }
1803             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1804         }
1805     }
1806
1807     reset_options(o, 0);
1808 }
1809
1810 static int opt_target(void *optctx, const char *opt, const char *arg)
1811 {
1812     OptionsContext *o = optctx;
1813     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1814     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1815
1816     if (!strncmp(arg, "pal-", 4)) {
1817         norm = PAL;
1818         arg += 4;
1819     } else if (!strncmp(arg, "ntsc-", 5)) {
1820         norm = NTSC;
1821         arg += 5;
1822     } else if (!strncmp(arg, "film-", 5)) {
1823         norm = FILM;
1824         arg += 5;
1825     } else {
1826         /* Try to determine PAL/NTSC by peeking in the input files */
1827         if (nb_input_files) {
1828             int i, j, fr;
1829             for (j = 0; j < nb_input_files; j++) {
1830                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1831                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1832                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1833                         continue;
1834                     fr = c->time_base.den * 1000 / c->time_base.num;
1835                     if (fr == 25000) {
1836                         norm = PAL;
1837                         break;
1838                     } else if ((fr == 29970) || (fr == 23976)) {
1839                         norm = NTSC;
1840                         break;
1841                     }
1842                 }
1843                 if (norm != UNKNOWN)
1844                     break;
1845             }
1846         }
1847         if (norm != UNKNOWN)
1848             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1849     }
1850
1851     if (norm == UNKNOWN) {
1852         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1853         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1854         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1855         exit(1);
1856     }
1857
1858     if (!strcmp(arg, "vcd")) {
1859         opt_video_codec(o, "c:v", "mpeg1video");
1860         opt_audio_codec(o, "c:a", "mp2");
1861         parse_option(o, "f", "vcd", options);
1862
1863         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1864         parse_option(o, "r", frame_rates[norm], options);
1865         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1866
1867         opt_default(NULL, "b:v", "1150000");
1868         opt_default(NULL, "maxrate", "1150000");
1869         opt_default(NULL, "minrate", "1150000");
1870         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1871
1872         opt_default(NULL, "b:a", "224000");
1873         parse_option(o, "ar", "44100", options);
1874         parse_option(o, "ac", "2", options);
1875
1876         opt_default(NULL, "packetsize", "2324");
1877         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1878
1879         /* We have to offset the PTS, so that it is consistent with the SCR.
1880            SCR starts at 36000, but the first two packs contain only padding
1881            and the first pack from the other stream, respectively, may also have
1882            been written before.
1883            So the real data starts at SCR 36000+3*1200. */
1884         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1885     } else if (!strcmp(arg, "svcd")) {
1886
1887         opt_video_codec(o, "c:v", "mpeg2video");
1888         opt_audio_codec(o, "c:a", "mp2");
1889         parse_option(o, "f", "svcd", options);
1890
1891         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1892         parse_option(o, "r", frame_rates[norm], options);
1893         parse_option(o, "pix_fmt", "yuv420p", options);
1894         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1895
1896         opt_default(NULL, "b:v", "2040000");
1897         opt_default(NULL, "maxrate", "2516000");
1898         opt_default(NULL, "minrate", "0"); // 1145000;
1899         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1900         opt_default(NULL, "scan_offset", "1");
1901
1902         opt_default(NULL, "b:a", "224000");
1903         parse_option(o, "ar", "44100", options);
1904
1905         opt_default(NULL, "packetsize", "2324");
1906
1907     } else if (!strcmp(arg, "dvd")) {
1908
1909         opt_video_codec(o, "c:v", "mpeg2video");
1910         opt_audio_codec(o, "c:a", "ac3");
1911         parse_option(o, "f", "dvd", options);
1912
1913         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1914         parse_option(o, "r", frame_rates[norm], options);
1915         parse_option(o, "pix_fmt", "yuv420p", options);
1916         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1917
1918         opt_default(NULL, "b:v", "6000000");
1919         opt_default(NULL, "maxrate", "9000000");
1920         opt_default(NULL, "minrate", "0"); // 1500000;
1921         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1922
1923         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1924         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1925
1926         opt_default(NULL, "b:a", "448000");
1927         parse_option(o, "ar", "48000", options);
1928
1929     } else if (!strncmp(arg, "dv", 2)) {
1930
1931         parse_option(o, "f", "dv", options);
1932
1933         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1934         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1935                           norm == PAL ? "yuv420p" : "yuv411p", options);
1936         parse_option(o, "r", frame_rates[norm], options);
1937
1938         parse_option(o, "ar", "48000", options);
1939         parse_option(o, "ac", "2", options);
1940
1941     } else {
1942         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1943         return AVERROR(EINVAL);
1944     }
1945     return 0;
1946 }
1947
1948 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1949 {
1950     av_free (vstats_filename);
1951     vstats_filename = av_strdup (arg);
1952     return 0;
1953 }
1954
1955 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1956 {
1957     char filename[40];
1958     time_t today2 = time(NULL);
1959     struct tm *today = localtime(&today2);
1960
1961     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1962              today->tm_sec);
1963     return opt_vstats_file(NULL, opt, filename);
1964 }
1965
1966 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1967 {
1968     OptionsContext *o = optctx;
1969     return parse_option(o, "frames:v", arg, options);
1970 }
1971
1972 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1973 {
1974     OptionsContext *o = optctx;
1975     return parse_option(o, "frames:a", arg, options);
1976 }
1977
1978 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1979 {
1980     OptionsContext *o = optctx;
1981     return parse_option(o, "frames:d", arg, options);
1982 }
1983
1984 static int opt_preset(void *optctx, const char *opt, const char *arg)
1985 {
1986     OptionsContext *o = optctx;
1987     FILE *f=NULL;
1988     char filename[1000], line[1000], tmp_line[1000];
1989     const char *codec_name = NULL;
1990
1991     tmp_line[0] = *opt;
1992     tmp_line[1] = 0;
1993     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
1994
1995     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
1996         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
1997             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
1998         }else
1999             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2000         exit(1);
2001 }
2002
2003     while (fgets(line, sizeof(line), f)) {
2004         char *key = tmp_line, *value, *endptr;
2005
2006         if (strcspn(line, "#\n\r") == 0)
2007             continue;
2008         strcpy(tmp_line, line);
2009         if (!av_strtok(key,   "=",    &value) ||
2010             !av_strtok(value, "\r\n", &endptr)) {
2011             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2012             exit(1);
2013         }
2014         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2015
2016         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2017         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2018         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2019         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2020         else if (opt_default(NULL, key, value) < 0) {
2021             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2022                    filename, line, key, value);
2023             exit(1);
2024         }
2025     }
2026
2027     fclose(f);
2028
2029     return 0;
2030 }
2031
2032 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2033 {
2034     OptionsContext *o = optctx;
2035     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2036     int ret = parse_option(o, s, arg, options);
2037     av_free(s);
2038     return ret;
2039 }
2040
2041 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2042 {
2043     OptionsContext *o = optctx;
2044     if(!strcmp(opt, "b")){
2045         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2046         return parse_option(o, "b:v", arg, options);
2047     }
2048     return opt_default(optctx, opt, arg);
2049 }
2050
2051 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2052 {
2053     OptionsContext *o = optctx;
2054     char *s;
2055     int ret;
2056     if(!strcmp(opt, "qscale")){
2057         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2058         return parse_option(o, "q:v", arg, options);
2059     }
2060     s = av_asprintf("q%s", opt + 6);
2061     ret = parse_option(o, s, arg, options);
2062     av_free(s);
2063     return ret;
2064 }
2065
2066 static int opt_profile(void *optctx, const char *opt, const char *arg)
2067 {
2068     OptionsContext *o = optctx;
2069     if(!strcmp(opt, "profile")){
2070         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2071         return parse_option(o, "profile:v", arg, options);
2072     }
2073     return opt_default(optctx, opt, arg);
2074
2075 }
2076
2077 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2078 {
2079     OptionsContext *o = optctx;
2080     return parse_option(o, "filter:v", arg, options);
2081 }
2082
2083 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2084 {
2085     OptionsContext *o = optctx;
2086     return parse_option(o, "filter:a", arg, options);
2087 }
2088
2089 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2090 {
2091     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2092     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2093     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2094     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2095
2096     if (video_sync_method == VSYNC_AUTO)
2097         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2098     return 0;
2099 }
2100
2101 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
2102 {
2103     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
2104     do_deinterlace = 1;
2105     return 0;
2106 }
2107
2108 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2109 {
2110     OptionsContext *o = optctx;
2111     char *tcr = av_asprintf("timecode=%s", arg);
2112     int ret = parse_option(o, "metadata:g", tcr, options);
2113     if (ret >= 0)
2114         ret = opt_default(optctx, "gop_timecode", arg);
2115     av_free(tcr);
2116     return ret;
2117 }
2118
2119 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2120 {
2121     OptionsContext *o = optctx;
2122     char layout_str[32];
2123     char *stream_str;
2124     char *ac_str;
2125     int ret, channels, ac_str_size;
2126     uint64_t layout;
2127
2128     layout = av_get_channel_layout(arg);
2129     if (!layout) {
2130         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2131         return AVERROR(EINVAL);
2132     }
2133     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2134     ret = opt_default(NULL, opt, layout_str);
2135     if (ret < 0)
2136         return ret;
2137
2138     /* set 'ac' option based on channel layout */
2139     channels = av_get_channel_layout_nb_channels(layout);
2140     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2141     stream_str = strchr(opt, ':');
2142     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2143     ac_str = av_mallocz(ac_str_size);
2144     if (!ac_str)
2145         return AVERROR(ENOMEM);
2146     av_strlcpy(ac_str, "ac", 3);
2147     if (stream_str)
2148         av_strlcat(ac_str, stream_str, ac_str_size);
2149     ret = parse_option(o, ac_str, layout_str, options);
2150     av_free(ac_str);
2151
2152     return ret;
2153 }
2154
2155 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2156 {
2157     OptionsContext *o = optctx;
2158     return parse_option(o, "q:a", arg, options);
2159 }
2160
2161 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2162 {
2163     filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
2164                               &nb_filtergraphs, nb_filtergraphs + 1);
2165     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2166         return AVERROR(ENOMEM);
2167     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
2168     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
2169     return 0;
2170 }
2171
2172 void show_help_default(const char *opt, const char *arg)
2173 {
2174     /* per-file options have at least one of those set */
2175     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2176     int show_advanced = 0, show_avoptions = 0;
2177
2178     if (opt && *opt) {
2179         if (!strcmp(opt, "long"))
2180             show_advanced = 1;
2181         else if (!strcmp(opt, "full"))
2182             show_advanced = show_avoptions = 1;
2183         else
2184             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2185     }
2186
2187     show_usage();
2188
2189     printf("Getting help:\n"
2190            "    -h      -- print basic options\n"
2191            "    -h long -- print more options\n"
2192            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2193            "    See man %s for detailed description of the options.\n"
2194            "\n", program_name);
2195
2196     show_help_options(options, "Print help / information / capabilities:",
2197                       OPT_EXIT, 0, 0);
2198
2199     show_help_options(options, "Global options (affect whole program "
2200                       "instead of just one file:",
2201                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2202     if (show_advanced)
2203         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2204                           per_file | OPT_EXIT, 0);
2205
2206     show_help_options(options, "Per-file main options:", 0,
2207                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2208                       OPT_EXIT, per_file);
2209     if (show_advanced)
2210         show_help_options(options, "Advanced per-file options:",
2211                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2212
2213     show_help_options(options, "Video options:",
2214                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2215     if (show_advanced)
2216         show_help_options(options, "Advanced Video options:",
2217                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2218
2219     show_help_options(options, "Audio options:",
2220                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2221     if (show_advanced)
2222         show_help_options(options, "Advanced Audio options:",
2223                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2224     show_help_options(options, "Subtitle options:",
2225                       OPT_SUBTITLE, 0, 0);
2226     printf("\n");
2227
2228     if (show_avoptions) {
2229         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2230         show_help_children(avcodec_get_class(), flags);
2231         show_help_children(avformat_get_class(), flags);
2232         show_help_children(sws_get_class(), flags);
2233         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2234         show_help_children(avfilter_get_class(), AV_OPT_FLAG_FILTERING_PARAM);
2235     }
2236 }
2237
2238 void show_usage(void)
2239 {
2240     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2241     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2242     av_log(NULL, AV_LOG_INFO, "\n");
2243 }
2244
2245
2246 static int opt_progress(void *optctx, const char *opt, const char *arg)
2247 {
2248     AVIOContext *avio = NULL;
2249     int ret;
2250
2251     if (!strcmp(arg, "-"))
2252         arg = "pipe:";
2253     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2254     if (ret < 0) {
2255         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2256                arg, av_err2str(ret));
2257         return ret;
2258     }
2259     progress_avio = avio;
2260     return 0;
2261 }
2262
2263 #define OFFSET(x) offsetof(OptionsContext, x)
2264 const OptionDef options[] = {
2265     /* main options */
2266 #include "cmdutils_common_opts.h"
2267     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
2268         "force format", "fmt" },
2269     { "i",              HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_input_file },
2270         "input file name", "filename" },
2271     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2272         "overwrite output files" },
2273     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2274         "do not overwrite output files" },
2275     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2276         "codec name", "codec" },
2277     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
2278         "codec name", "codec" },
2279     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
2280         "preset name", "preset" },
2281     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
2282         "set input stream mapping",
2283         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2284     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map_channel },
2285         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2286     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
2287         "set metadata information of outfile from infile",
2288         "outfile[,metadata]:infile[,metadata]" },
2289     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
2290         "set chapters mapping", "input_file_index" },
2291     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
2292         "record or transcode \"duration\" seconds of audio/video",
2293         "duration" },
2294     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
2295         "set the limit file size in bytes", "limit_size" },
2296     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
2297         "set the start time offset", "time_off" },
2298     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
2299         "set the input ts offset", "time_off" },
2300     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
2301         "set the input ts scale", "scale" },
2302     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2303         "set the recording timestamp ('now' to set the current time)", "time" },
2304     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
2305         "add metadata", "string=string" },
2306     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
2307         "set the number of data frames to record", "number" },
2308     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2309         "add timings for benchmarking" },
2310     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2311       "add timings for each task" },
2312     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2313       "write program-readable progress information", "url" },
2314     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2315       "enable or disable interaction on standard input" },
2316     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2317         "set max runtime in seconds", "limit" },
2318     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2319         "dump each input packet" },
2320     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2321         "when dumping packets, also dump the payload" },
2322     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
2323         "read input at native frame rate", "" },
2324     { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
2325         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2326         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2327     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2328         "video sync method", "" },
2329     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2330         "audio sync method", "" },
2331     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2332         "audio drift threshold", "threshold" },
2333     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2334         "copy timestamps" },
2335     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2336         "copy input stream time base when stream copying", "mode" },
2337     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2338         "finish encoding within shortest input" },
2339     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2340         "timestamp discontinuity delta threshold", "threshold" },
2341     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2342         "timestamp error delta threshold", "threshold" },
2343     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2344         "exit on error", "error" },
2345     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2346         "copy initial non-keyframes" },
2347     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC,   { .off = OFFSET(copy_prior_start) },
2348         "copy or discard frames before start time" },
2349     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2350         "set the number of frames to record", "number" },
2351     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2352         "force codec tag/fourcc", "fourcc/tag" },
2353     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2354         "use fixed quality scale (VBR)", "q" },
2355     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_qscale },
2356         "use fixed quality scale (VBR)", "q" },
2357     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_profile },
2358         "set profile", "profile" },
2359     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2360         "set stream filterchain", "filter_list" },
2361     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC,                { .off = OFFSET(reinit_filters) },
2362         "reinit filtergraph on input parameter changes", "" },
2363     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2364         "create a complex filtergraph", "graph_description" },
2365     { "stats",          OPT_BOOL,                                    { &print_stats },
2366         "print progress report during encoding", },
2367     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
2368         "add an attachment to the output file", "filename" },
2369     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2370         "extract an attachment into a file", "filename" },
2371     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2372         "print timestamp debugging info" },
2373
2374     /* video options */
2375     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
2376         "set the number of video frames to record", "number" },
2377     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2378         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2379     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC,{ .off = OFFSET(frame_sizes) },
2380         "set frame size (WxH or abbreviation)", "size" },
2381     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2382         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2383     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2384         "set pixel format", "format" },
2385     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
2386         "set the number of bits per raw sample", "number" },
2387     { "croptop",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2388         "Removed, use the crop filter instead", "size" },
2389     { "cropbottom",   OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2390         "Removed, use the crop filter instead", "size" },
2391     { "cropleft",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2392         "Removed, use the crop filter instead", "size" },
2393     { "cropright",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_frame_crop },
2394         "Removed, use the crop filter instead", "size" },
2395     { "padtop",       OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2396         "Removed, use the pad filter instead", "size" },
2397     { "padbottom",    OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2398         "Removed, use the pad filter instead", "size" },
2399     { "padleft",      OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2400         "Removed, use the pad filter instead", "size" },
2401     { "padright",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2402         "Removed, use the pad filter instead", "size" },
2403     { "padcolor",     OPT_VIDEO | HAS_ARG,                                       { .func_arg = opt_pad },
2404         "Removed, use the pad filter instead", "color" },
2405     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
2406         "deprecated use -g 1" },
2407     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2408         "disable video" },
2409     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2410         "discard threshold", "n" },
2411     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2412         "rate control override for specific intervals", "override" },
2413     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
2414         "force video codec ('copy' to copy stream)", "codec" },
2415     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2416         "Removed" },
2417     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
2418         "Removed" },
2419     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_timecode },
2420         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
2421     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
2422         "select the pass number (1 to 3)", "n" },
2423     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
2424         "select two pass log file name prefix", "prefix" },
2425     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2426         "this option is deprecated, use the yadif filter instead" },
2427     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
2428         "calculate PSNR of compressed frames" },
2429     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2430         "dump video coding statistics to file" },
2431     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2432         "dump video coding statistics to file", "file" },
2433     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
2434         "video filters", "filter list" },
2435     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2436         "specify intra matrix coeffs", "matrix" },
2437     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2438         "specify inter matrix coeffs", "matrix" },
2439     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2440         "top=1/bottom=0/auto=-1 field first", "" },
2441     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2442         "intra_dc_precision", "precision" },
2443     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_old2new },
2444         "force video tag/fourcc", "fourcc/tag" },
2445     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2446         "show QP histogram" },
2447     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2448         "force the selected framerate, disable the best supported framerate selection" },
2449     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2450         "set the value of an outfile streamid", "streamIndex:value" },
2451     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2452         { .off = OFFSET(forced_key_frames) },
2453         "force key frames at specified timestamps", "timestamps" },
2454     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE,                         { .func_arg = opt_bitrate },
2455         "video bitrate (please use -b:v)", "bitrate" },
2456
2457     /* audio options */
2458     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2459         "set the number of audio frames to record", "number" },
2460     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2461         "set audio quality (codec-specific)", "quality", },
2462     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2463         "set audio sampling rate (in Hz)", "rate" },
2464     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2465         "set number of audio channels", "channels" },
2466     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2467         "disable audio" },
2468     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2469         "force audio codec ('copy' to copy stream)", "codec" },
2470     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_old2new },
2471         "force audio tag/fourcc", "fourcc/tag" },
2472     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2473         "change audio volume (256=normal)" , "volume" },
2474     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2475         "set sample format", "format" },
2476     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2477         "set channel layout", "layout" },
2478     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2479         "audio filters", "filter list" },
2480
2481     /* subtitle options */
2482     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2483         "disable subtitle" },
2484     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2485         "force subtitle codec ('copy' to copy stream)", "codec" },
2486     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_old2new }
2487         , "force subtitle tag/fourcc", "fourcc/tag" },
2488     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC, { .off = OFFSET(fix_sub_duration) },
2489         "fix subtitles duration" },
2490
2491     /* grab options */
2492     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
2493         "deprecated, use -channel", "channel" },
2494     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
2495         "deprecated, use -standard", "standard" },
2496     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2497
2498     /* muxer options */
2499     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2500         "set the maximum demux-decode delay", "seconds" },
2501     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2502         "set the initial demux-decode delay", "seconds" },
2503
2504     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2505         "A comma-separated list of bitstream filters", "bitstream_filters" },
2506     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2507         "deprecated", "audio bitstream_filters" },
2508     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_old2new },
2509         "deprecated", "video bitstream_filters" },
2510
2511     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2512         "set the audio options to the indicated preset", "preset" },
2513     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE,    { .func_arg = opt_preset },
2514         "set the video options to the indicated preset", "preset" },
2515     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE, { .func_arg = opt_preset },
2516         "set the subtitle options to the indicated preset", "preset" },
2517     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE,                { .func_arg = opt_preset },
2518         "set options from indicated preset file", "filename" },
2519     /* data codec support */
2520     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2521         "force data codec ('copy' to copy stream)", "codec" },
2522     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, { .off = OFFSET(data_disable) },
2523         "disable data" },
2524
2525     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, { .func_arg = opt_default },
2526         "generic catch all option", "" },
2527     { NULL, },
2528 };