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