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