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                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2213                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2214                 } else if (ret < 0)
2215                     exit_program(1);
2216             }
2217         }
2218         else {
2219             switch (type) {
2220             case 'g':
2221                 m = &oc->metadata;
2222                 break;
2223             case 'c':
2224                 if (index < 0 || index >= oc->nb_chapters) {
2225                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2226                     exit_program(1);
2227                 }
2228                 m = &oc->chapters[index]->metadata;
2229                 break;
2230             default:
2231                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2232                 exit_program(1);
2233             }
2234             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2235         }
2236     }
2237
2238     return 0;
2239 }
2240
2241 static int opt_target(void *optctx, const char *opt, const char *arg)
2242 {
2243     OptionsContext *o = optctx;
2244     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2245     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2246
2247     if (!strncmp(arg, "pal-", 4)) {
2248         norm = PAL;
2249         arg += 4;
2250     } else if (!strncmp(arg, "ntsc-", 5)) {
2251         norm = NTSC;
2252         arg += 5;
2253     } else if (!strncmp(arg, "film-", 5)) {
2254         norm = FILM;
2255         arg += 5;
2256     } else {
2257         /* Try to determine PAL/NTSC by peeking in the input files */
2258         if (nb_input_files) {
2259             int i, j, fr;
2260             for (j = 0; j < nb_input_files; j++) {
2261                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2262                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2263                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2264                         !c->time_base.num)
2265                         continue;
2266                     fr = c->time_base.den * 1000 / c->time_base.num;
2267                     if (fr == 25000) {
2268                         norm = PAL;
2269                         break;
2270                     } else if ((fr == 29970) || (fr == 23976)) {
2271                         norm = NTSC;
2272                         break;
2273                     }
2274                 }
2275                 if (norm != UNKNOWN)
2276                     break;
2277             }
2278         }
2279         if (norm != UNKNOWN)
2280             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2281     }
2282
2283     if (norm == UNKNOWN) {
2284         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2285         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2286         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2287         exit_program(1);
2288     }
2289
2290     if (!strcmp(arg, "vcd")) {
2291         opt_video_codec(o, "c:v", "mpeg1video");
2292         opt_audio_codec(o, "c:a", "mp2");
2293         parse_option(o, "f", "vcd", options);
2294
2295         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2296         parse_option(o, "r", frame_rates[norm], options);
2297         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2298
2299         opt_default(NULL, "b:v", "1150000");
2300         opt_default(NULL, "maxrate", "1150000");
2301         opt_default(NULL, "minrate", "1150000");
2302         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2303
2304         opt_default(NULL, "b:a", "224000");
2305         parse_option(o, "ar", "44100", options);
2306         parse_option(o, "ac", "2", options);
2307
2308         opt_default(NULL, "packetsize", "2324");
2309         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2310
2311         /* We have to offset the PTS, so that it is consistent with the SCR.
2312            SCR starts at 36000, but the first two packs contain only padding
2313            and the first pack from the other stream, respectively, may also have
2314            been written before.
2315            So the real data starts at SCR 36000+3*1200. */
2316         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2317     } else if (!strcmp(arg, "svcd")) {
2318
2319         opt_video_codec(o, "c:v", "mpeg2video");
2320         opt_audio_codec(o, "c:a", "mp2");
2321         parse_option(o, "f", "svcd", options);
2322
2323         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2324         parse_option(o, "r", frame_rates[norm], options);
2325         parse_option(o, "pix_fmt", "yuv420p", options);
2326         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2327
2328         opt_default(NULL, "b:v", "2040000");
2329         opt_default(NULL, "maxrate", "2516000");
2330         opt_default(NULL, "minrate", "0"); // 1145000;
2331         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2332         opt_default(NULL, "scan_offset", "1");
2333
2334         opt_default(NULL, "b:a", "224000");
2335         parse_option(o, "ar", "44100", options);
2336
2337         opt_default(NULL, "packetsize", "2324");
2338
2339     } else if (!strcmp(arg, "dvd")) {
2340
2341         opt_video_codec(o, "c:v", "mpeg2video");
2342         opt_audio_codec(o, "c:a", "ac3");
2343         parse_option(o, "f", "dvd", options);
2344
2345         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2346         parse_option(o, "r", frame_rates[norm], options);
2347         parse_option(o, "pix_fmt", "yuv420p", options);
2348         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2349
2350         opt_default(NULL, "b:v", "6000000");
2351         opt_default(NULL, "maxrate", "9000000");
2352         opt_default(NULL, "minrate", "0"); // 1500000;
2353         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2354
2355         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2356         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2357
2358         opt_default(NULL, "b:a", "448000");
2359         parse_option(o, "ar", "48000", options);
2360
2361     } else if (!strncmp(arg, "dv", 2)) {
2362
2363         parse_option(o, "f", "dv", options);
2364
2365         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2366         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2367                           norm == PAL ? "yuv420p" : "yuv411p", options);
2368         parse_option(o, "r", frame_rates[norm], options);
2369
2370         parse_option(o, "ar", "48000", options);
2371         parse_option(o, "ac", "2", options);
2372
2373     } else {
2374         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2375         return AVERROR(EINVAL);
2376     }
2377
2378     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2379     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2380
2381     return 0;
2382 }
2383
2384 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2385 {
2386     av_free (vstats_filename);
2387     vstats_filename = av_strdup (arg);
2388     return 0;
2389 }
2390
2391 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2392 {
2393     char filename[40];
2394     time_t today2 = time(NULL);
2395     struct tm *today = localtime(&today2);
2396
2397     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2398              today->tm_sec);
2399     return opt_vstats_file(NULL, opt, filename);
2400 }
2401
2402 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2403 {
2404     OptionsContext *o = optctx;
2405     return parse_option(o, "frames:v", arg, options);
2406 }
2407
2408 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2409 {
2410     OptionsContext *o = optctx;
2411     return parse_option(o, "frames:a", arg, options);
2412 }
2413
2414 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2415 {
2416     OptionsContext *o = optctx;
2417     return parse_option(o, "frames:d", arg, options);
2418 }
2419
2420 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2421 {
2422     int ret;
2423     AVDictionary *cbak = codec_opts;
2424     AVDictionary *fbak = format_opts;
2425     codec_opts = NULL;
2426     format_opts = NULL;
2427
2428     ret = opt_default(NULL, opt, arg);
2429
2430     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2431     av_dict_copy(&o->g->format_opts, format_opts, 0);
2432     av_dict_free(&codec_opts);
2433     av_dict_free(&format_opts);
2434     codec_opts = cbak;
2435     format_opts = fbak;
2436
2437     return ret;
2438 }
2439
2440 static int opt_preset(void *optctx, const char *opt, const char *arg)
2441 {
2442     OptionsContext *o = optctx;
2443     FILE *f=NULL;
2444     char filename[1000], line[1000], tmp_line[1000];
2445     const char *codec_name = NULL;
2446
2447     tmp_line[0] = *opt;
2448     tmp_line[1] = 0;
2449     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2450
2451     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2452         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2453             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2454         }else
2455             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2456         exit_program(1);
2457     }
2458
2459     while (fgets(line, sizeof(line), f)) {
2460         char *key = tmp_line, *value, *endptr;
2461
2462         if (strcspn(line, "#\n\r") == 0)
2463             continue;
2464         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2465         if (!av_strtok(key,   "=",    &value) ||
2466             !av_strtok(value, "\r\n", &endptr)) {
2467             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2468             exit_program(1);
2469         }
2470         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2471
2472         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2473         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2474         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2475         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2476         else if (opt_default_new(o, key, value) < 0) {
2477             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2478                    filename, line, key, value);
2479             exit_program(1);
2480         }
2481     }
2482
2483     fclose(f);
2484
2485     return 0;
2486 }
2487
2488 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2489 {
2490     OptionsContext *o = optctx;
2491     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2492     int ret = parse_option(o, s, arg, options);
2493     av_free(s);
2494     return ret;
2495 }
2496
2497 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2498 {
2499     OptionsContext *o = optctx;
2500
2501     if(!strcmp(opt, "ab")){
2502         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2503         return 0;
2504     } else if(!strcmp(opt, "b")){
2505         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2506         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2507         return 0;
2508     }
2509     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2510     return 0;
2511 }
2512
2513 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2514 {
2515     OptionsContext *o = optctx;
2516     char *s;
2517     int ret;
2518     if(!strcmp(opt, "qscale")){
2519         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2520         return parse_option(o, "q:v", arg, options);
2521     }
2522     s = av_asprintf("q%s", opt + 6);
2523     ret = parse_option(o, s, arg, options);
2524     av_free(s);
2525     return ret;
2526 }
2527
2528 static int opt_profile(void *optctx, const char *opt, const char *arg)
2529 {
2530     OptionsContext *o = optctx;
2531     if(!strcmp(opt, "profile")){
2532         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2533         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2534         return 0;
2535     }
2536     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2537     return 0;
2538 }
2539
2540 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2541 {
2542     OptionsContext *o = optctx;
2543     return parse_option(o, "filter:v", arg, options);
2544 }
2545
2546 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2547 {
2548     OptionsContext *o = optctx;
2549     return parse_option(o, "filter:a", arg, options);
2550 }
2551
2552 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2553 {
2554     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2555     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2556     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2557     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2558
2559     if (video_sync_method == VSYNC_AUTO)
2560         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2561     return 0;
2562 }
2563
2564 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2565 {
2566     OptionsContext *o = optctx;
2567     char *tcr = av_asprintf("timecode=%s", arg);
2568     int ret = parse_option(o, "metadata:g", tcr, options);
2569     if (ret >= 0)
2570         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2571     av_free(tcr);
2572     return 0;
2573 }
2574
2575 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2576 {
2577     OptionsContext *o = optctx;
2578     char layout_str[32];
2579     char *stream_str;
2580     char *ac_str;
2581     int ret, channels, ac_str_size;
2582     uint64_t layout;
2583
2584     layout = av_get_channel_layout(arg);
2585     if (!layout) {
2586         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2587         return AVERROR(EINVAL);
2588     }
2589     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2590     ret = opt_default_new(o, opt, layout_str);
2591     if (ret < 0)
2592         return ret;
2593
2594     /* set 'ac' option based on channel layout */
2595     channels = av_get_channel_layout_nb_channels(layout);
2596     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2597     stream_str = strchr(opt, ':');
2598     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2599     ac_str = av_mallocz(ac_str_size);
2600     if (!ac_str)
2601         return AVERROR(ENOMEM);
2602     av_strlcpy(ac_str, "ac", 3);
2603     if (stream_str)
2604         av_strlcat(ac_str, stream_str, ac_str_size);
2605     ret = parse_option(o, ac_str, layout_str, options);
2606     av_free(ac_str);
2607
2608     return ret;
2609 }
2610
2611 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2612 {
2613     OptionsContext *o = optctx;
2614     return parse_option(o, "q:a", arg, options);
2615 }
2616
2617 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2618 {
2619     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2620     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2621         return AVERROR(ENOMEM);
2622     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2623     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2624     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2625         return AVERROR(ENOMEM);
2626
2627     input_stream_potentially_available = 1;
2628
2629     return 0;
2630 }
2631
2632 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2633 {
2634     uint8_t *graph_desc = read_file(arg);
2635     if (!graph_desc)
2636         return AVERROR(EINVAL);
2637
2638     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2639     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2640         return AVERROR(ENOMEM);
2641     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2642     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2643
2644     input_stream_potentially_available = 1;
2645
2646     return 0;
2647 }
2648
2649 void show_help_default(const char *opt, const char *arg)
2650 {
2651     /* per-file options have at least one of those set */
2652     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2653     int show_advanced = 0, show_avoptions = 0;
2654
2655     if (opt && *opt) {
2656         if (!strcmp(opt, "long"))
2657             show_advanced = 1;
2658         else if (!strcmp(opt, "full"))
2659             show_advanced = show_avoptions = 1;
2660         else
2661             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2662     }
2663
2664     show_usage();
2665
2666     printf("Getting help:\n"
2667            "    -h      -- print basic options\n"
2668            "    -h long -- print more options\n"
2669            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2670            "    See man %s for detailed description of the options.\n"
2671            "\n", program_name);
2672
2673     show_help_options(options, "Print help / information / capabilities:",
2674                       OPT_EXIT, 0, 0);
2675
2676     show_help_options(options, "Global options (affect whole program "
2677                       "instead of just one file:",
2678                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2679     if (show_advanced)
2680         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2681                           per_file | OPT_EXIT, 0);
2682
2683     show_help_options(options, "Per-file main options:", 0,
2684                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2685                       OPT_EXIT, per_file);
2686     if (show_advanced)
2687         show_help_options(options, "Advanced per-file options:",
2688                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2689
2690     show_help_options(options, "Video options:",
2691                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2692     if (show_advanced)
2693         show_help_options(options, "Advanced Video options:",
2694                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2695
2696     show_help_options(options, "Audio options:",
2697                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2698     if (show_advanced)
2699         show_help_options(options, "Advanced Audio options:",
2700                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2701     show_help_options(options, "Subtitle options:",
2702                       OPT_SUBTITLE, 0, 0);
2703     printf("\n");
2704
2705     if (show_avoptions) {
2706         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2707         show_help_children(avcodec_get_class(), flags);
2708         show_help_children(avformat_get_class(), flags);
2709 #if CONFIG_SWSCALE
2710         show_help_children(sws_get_class(), flags);
2711 #endif
2712         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2713         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2714     }
2715 }
2716
2717 void show_usage(void)
2718 {
2719     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2720     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2721     av_log(NULL, AV_LOG_INFO, "\n");
2722 }
2723
2724 enum OptGroup {
2725     GROUP_OUTFILE,
2726     GROUP_INFILE,
2727 };
2728
2729 static const OptionGroupDef groups[] = {
2730     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2731     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2732 };
2733
2734 static int open_files(OptionGroupList *l, const char *inout,
2735                       int (*open_file)(OptionsContext*, const char*))
2736 {
2737     int i, ret;
2738
2739     for (i = 0; i < l->nb_groups; i++) {
2740         OptionGroup *g = &l->groups[i];
2741         OptionsContext o;
2742
2743         init_options(&o);
2744         o.g = g;
2745
2746         ret = parse_optgroup(&o, g);
2747         if (ret < 0) {
2748             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2749                    "%s.\n", inout, g->arg);
2750             return ret;
2751         }
2752
2753         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2754         ret = open_file(&o, g->arg);
2755         uninit_options(&o);
2756         if (ret < 0) {
2757             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2758                    inout, g->arg);
2759             return ret;
2760         }
2761         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2762     }
2763
2764     return 0;
2765 }
2766
2767 int ffmpeg_parse_options(int argc, char **argv)
2768 {
2769     OptionParseContext octx;
2770     uint8_t error[128];
2771     int ret;
2772
2773     memset(&octx, 0, sizeof(octx));
2774
2775     /* split the commandline into an internal representation */
2776     ret = split_commandline(&octx, argc, argv, options, groups,
2777                             FF_ARRAY_ELEMS(groups));
2778     if (ret < 0) {
2779         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2780         goto fail;
2781     }
2782
2783     /* apply global options */
2784     ret = parse_optgroup(NULL, &octx.global_opts);
2785     if (ret < 0) {
2786         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2787         goto fail;
2788     }
2789
2790     /* open input files */
2791     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2792     if (ret < 0) {
2793         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2794         goto fail;
2795     }
2796
2797     /* open output files */
2798     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2799     if (ret < 0) {
2800         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2801         goto fail;
2802     }
2803
2804 fail:
2805     uninit_parse_context(&octx);
2806     if (ret < 0) {
2807         av_strerror(ret, error, sizeof(error));
2808         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2809     }
2810     return ret;
2811 }
2812
2813 static int opt_progress(void *optctx, const char *opt, const char *arg)
2814 {
2815     AVIOContext *avio = NULL;
2816     int ret;
2817
2818     if (!strcmp(arg, "-"))
2819         arg = "pipe:";
2820     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2821     if (ret < 0) {
2822         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2823                arg, av_err2str(ret));
2824         return ret;
2825     }
2826     progress_avio = avio;
2827     return 0;
2828 }
2829
2830 #define OFFSET(x) offsetof(OptionsContext, x)
2831 const OptionDef options[] = {
2832     /* main options */
2833 #include "cmdutils_common_opts.h"
2834     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2835                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2836         "force format", "fmt" },
2837     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2838         "overwrite output files" },
2839     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2840         "never overwrite output files" },
2841     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2842                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2843         "codec name", "codec" },
2844     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2845                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2846         "codec name", "codec" },
2847     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2848                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2849         "preset name", "preset" },
2850     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2851                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2852         "set input stream mapping",
2853         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2854     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
2855         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
2856     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2857                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2858         "set metadata information of outfile from infile",
2859         "outfile[,metadata]:infile[,metadata]" },
2860     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2861                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2862         "set chapters mapping", "input_file_index" },
2863     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2864                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2865         "record or transcode \"duration\" seconds of audio/video",
2866         "duration" },
2867     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
2868         "record or transcode stop time", "time_stop" },
2869     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2870         "set the limit file size in bytes", "limit_size" },
2871     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2872                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2873         "set the start time offset", "time_off" },
2874     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
2875                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
2876         "enable/disable seeking by timestamp with -ss" },
2877     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2878                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2879         "enable/disable accurate seeking with -ss" },
2880     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2881                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2882         "set the input ts offset", "time_off" },
2883     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2884                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2885         "set the input ts scale", "scale" },
2886     { "timestamp",      HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_recording_timestamp },
2887         "set the recording timestamp ('now' to set the current time)", "time" },
2888     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2889         "add metadata", "string=string" },
2890     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2891                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2892         "set the number of data frames to output", "number" },
2893     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2894         "add timings for benchmarking" },
2895     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
2896       "add timings for each task" },
2897     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
2898       "write program-readable progress information", "url" },
2899     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
2900       "enable or disable interaction on standard input" },
2901     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2902         "set max runtime in seconds", "limit" },
2903     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2904         "dump each input packet" },
2905     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2906         "when dumping packets, also dump the payload" },
2907     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2908                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2909         "read input at native frame rate", "" },
2910     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2911         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2912         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2913     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2914         "video sync method", "" },
2915     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
2916         "frame drop threshold", "" },
2917     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2918         "audio sync method", "" },
2919     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2920         "audio drift threshold", "threshold" },
2921     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2922         "copy timestamps" },
2923     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
2924         "shift input timestamps to start at 0 when using copyts" },
2925     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
2926         "copy input stream time base when stream copying", "mode" },
2927     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2928                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2929         "finish encoding within shortest input" },
2930     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
2931                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
2932         "audio pad", "" },
2933     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2934         "timestamp discontinuity delta threshold", "threshold" },
2935     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
2936         "timestamp error delta threshold", "threshold" },
2937     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2938         "exit on error", "error" },
2939     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2940                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2941         "copy initial non-keyframes" },
2942     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
2943         "copy or discard frames before start time" },
2944     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2945         "set the number of frames to output", "number" },
2946     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2947                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2948         "force codec tag/fourcc", "fourcc/tag" },
2949     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2950                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2951         "use fixed quality scale (VBR)", "q" },
2952     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2953                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
2954         "use fixed quality scale (VBR)", "q" },
2955     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
2956         "set profile", "profile" },
2957     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2958         "set stream filtergraph", "filter_graph" },
2959     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2960         "read stream filtergraph description from a file", "filename" },
2961     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
2962         "reinit filtergraph on input parameter changes", "" },
2963     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2964         "create a complex filtergraph", "graph_description" },
2965     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2966         "create a complex filtergraph", "graph_description" },
2967     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2968         "read complex filtergraph description from a file", "filename" },
2969     { "stats",          OPT_BOOL,                                    { &print_stats },
2970         "print progress report during encoding", },
2971     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2972                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2973         "add an attachment to the output file", "filename" },
2974     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2975                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2976         "extract an attachment into a file", "filename" },
2977     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
2978         "print timestamp debugging info" },
2979     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
2980         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
2981     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
2982                         OPT_INPUT,                                   { .off = OFFSET(discard) },
2983         "discard", "" },
2984     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
2985                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
2986         "disposition", "" },
2987     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
2988                                                                      { .off = OFFSET(thread_queue_size) },
2989         "set the maximum number of queued packets from the demuxer" },
2990
2991     /* video options */
2992     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2993         "set the number of video frames to output", "number" },
2994     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2995                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2996         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2997     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
2998                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2999         "set frame size (WxH or abbreviation)", "size" },
3000     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3001                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3002         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3003     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3004                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3005         "set pixel format", "format" },
3006     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3007         "set the number of bits per raw sample", "number" },
3008     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3009         "deprecated use -g 1" },
3010     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3011         "disable video" },
3012     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3013                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3014         "rate control override for specific intervals", "override" },
3015     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3016                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3017         "force video codec ('copy' to copy stream)", "codec" },
3018     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3019         "Removed" },
3020     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3021         "Removed" },
3022     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3023         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3024     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3025         "select the pass number (1 to 3)", "n" },
3026     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3027                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3028         "select two pass log file name prefix", "prefix" },
3029     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3030         "this option is deprecated, use the yadif filter instead" },
3031     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3032         "calculate PSNR of compressed frames" },
3033     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
3034         "dump video coding statistics to file" },
3035     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
3036         "dump video coding statistics to file", "file" },
3037     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3038         "set video filters", "filter_graph" },
3039     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3040                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3041         "specify intra matrix coeffs", "matrix" },
3042     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3043                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3044         "specify inter matrix coeffs", "matrix" },
3045     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3046                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3047         "specify intra matrix coeffs", "matrix" },
3048     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3049                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3050         "top=1/bottom=0/auto=-1 field first", "" },
3051     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3052                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3053         "force video tag/fourcc", "fourcc/tag" },
3054     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3055         "show QP histogram" },
3056     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3057                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3058         "force the selected framerate, disable the best supported framerate selection" },
3059     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3060                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3061         "set the value of an outfile streamid", "streamIndex:value" },
3062     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3063                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3064         "force key frames at specified timestamps", "timestamps" },
3065     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3066         "audio bitrate (please use -b:a)", "bitrate" },
3067     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3068         "video bitrate (please use -b:v)", "bitrate" },
3069     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3070                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3071         "use HW accelerated decoding", "hwaccel name" },
3072     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3073                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3074         "select a device for HW acceleration" "devicename" },
3075 #if HAVE_VDPAU_X11
3076     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3077 #endif
3078     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3079                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3080         "automatically insert correct rotate filters" },
3081
3082     /* audio options */
3083     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3084         "set the number of audio frames to output", "number" },
3085     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3086         "set audio quality (codec-specific)", "quality", },
3087     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3088                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3089         "set audio sampling rate (in Hz)", "rate" },
3090     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3091                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3092         "set number of audio channels", "channels" },
3093     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3094         "disable audio" },
3095     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3096                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3097         "force audio codec ('copy' to copy stream)", "codec" },
3098     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3099                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3100         "force audio tag/fourcc", "fourcc/tag" },
3101     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3102         "change audio volume (256=normal)" , "volume" },
3103     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3104                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3105         "set sample format", "format" },
3106     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3107                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3108         "set channel layout", "layout" },
3109     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3110         "set audio filters", "filter_graph" },
3111     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3112       "set the maximum number of channels to try to guess the channel layout" },
3113
3114     /* subtitle options */
3115     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3116         "disable subtitle" },
3117     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3118         "force subtitle codec ('copy' to copy stream)", "codec" },
3119     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3120         , "force subtitle tag/fourcc", "fourcc/tag" },
3121     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3122         "fix subtitles duration" },
3123     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3124         "set canvas size (WxH or abbreviation)", "size" },
3125
3126     /* grab options */
3127     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3128         "deprecated, use -channel", "channel" },
3129     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3130         "deprecated, use -standard", "standard" },
3131     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3132
3133     /* muxer options */
3134     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3135         "set the maximum demux-decode delay", "seconds" },
3136     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3137         "set the initial demux-decode delay", "seconds" },
3138     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3139         "override the options from ffserver", "" },
3140     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3141         "specify a file in which to print sdp information", "file" },
3142
3143     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3144         "A comma-separated list of bitstream filters", "bitstream_filters" },
3145     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3146         "deprecated", "audio bitstream_filters" },
3147     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3148         "deprecated", "video bitstream_filters" },
3149
3150     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3151         "set the audio options to the indicated preset", "preset" },
3152     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3153         "set the video options to the indicated preset", "preset" },
3154     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3155         "set the subtitle options to the indicated preset", "preset" },
3156     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3157         "set options from indicated preset file", "filename" },
3158     /* data codec support */
3159     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3160         "force data codec ('copy' to copy stream)", "codec" },
3161     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3162         "disable data" },
3163
3164     { NULL, },
3165 };