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

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