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

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