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