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