git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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