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