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 (ofilter->type) {
1786     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1787     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1788     default:
1789         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1790                "currently.\n");
1791         exit_program(1);
1792     }
1793
1794     ost->source_index = -1;
1795     ost->filter       = ofilter;
1796
1797     ofilter->ost      = ost;
1798
1799     if (ost->stream_copy) {
1800         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1801                "which is fed from a complex filtergraph. Filtering and streamcopy "
1802                "cannot be used together.\n", ost->file_index, ost->index);
1803         exit_program(1);
1804     }
1805
1806     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1807         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1808         av_log(NULL, AV_LOG_ERROR,
1809                "%s '%s' was specified through the %s option "
1810                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1811                "%s and -filter_complex cannot be used together for the same stream.\n",
1812                ost->filters ? "Filtergraph" : "Filtergraph script",
1813                ost->filters ? ost->filters : ost->filters_script,
1814                opt, ost->file_index, ost->index, opt);
1815         exit_program(1);
1816     }
1817
1818     avfilter_inout_free(&ofilter->out_tmp);
1819 }
1820
1821 static int init_complex_filters(void)
1822 {
1823     int i, ret = 0;
1824
1825     for (i = 0; i < nb_filtergraphs; i++) {
1826         ret = init_complex_filtergraph(filtergraphs[i]);
1827         if (ret < 0)
1828             return ret;
1829     }
1830     return 0;
1831 }
1832
1833 static int configure_complex_filters(void)
1834 {
1835     int i, ret = 0;
1836
1837     for (i = 0; i < nb_filtergraphs; i++)
1838         if (!filtergraphs[i]->graph &&
1839             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1840             return ret;
1841     return 0;
1842 }
1843
1844 static int open_output_file(OptionsContext *o, const char *filename)
1845 {
1846     AVFormatContext *oc;
1847     int i, j, err;
1848     AVOutputFormat *file_oformat;
1849     OutputFile *of;
1850     OutputStream *ost;
1851     InputStream  *ist;
1852     AVDictionary *unused_opts = NULL;
1853     AVDictionaryEntry *e = NULL;
1854
1855
1856     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1857         o->stop_time = INT64_MAX;
1858         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1859     }
1860
1861     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1862         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1863         if (o->stop_time <= start_time) {
1864             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1865             exit_program(1);
1866         } else {
1867             o->recording_time = o->stop_time - start_time;
1868         }
1869     }
1870
1871     GROW_ARRAY(output_files, nb_output_files);
1872     of = av_mallocz(sizeof(*of));
1873     if (!of)
1874         exit_program(1);
1875     output_files[nb_output_files - 1] = of;
1876
1877     of->ost_index      = nb_output_streams;
1878     of->recording_time = o->recording_time;
1879     of->start_time     = o->start_time;
1880     of->limit_filesize = o->limit_filesize;
1881     of->shortest       = o->shortest;
1882     av_dict_copy(&of->opts, o->g->format_opts, 0);
1883
1884     if (!strcmp(filename, "-"))
1885         filename = "pipe:";
1886
1887     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1888     if (!oc) {
1889         print_error(filename, err);
1890         exit_program(1);
1891     }
1892
1893     of->ctx = oc;
1894     if (o->recording_time != INT64_MAX)
1895         oc->duration = o->recording_time;
1896
1897     file_oformat= oc->oformat;
1898     oc->interrupt_callback = int_cb;
1899
1900     /* create streams for all unlabeled output pads */
1901     for (i = 0; i < nb_filtergraphs; i++) {
1902         FilterGraph *fg = filtergraphs[i];
1903         for (j = 0; j < fg->nb_outputs; j++) {
1904             OutputFilter *ofilter = fg->outputs[j];
1905
1906             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1907                 continue;
1908
1909             switch (ofilter->type) {
1910             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1911             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1912             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1913             }
1914             init_output_filter(ofilter, o, oc);
1915         }
1916     }
1917
1918     /* ffserver seeking with date=... needs a date reference */
1919     if (!strcmp(file_oformat->name, "ffm") &&
1920         av_strstart(filename, "http:", NULL)) {
1921         int err = parse_option(o, "metadata", "creation_time=now", options);
1922         if (err < 0) {
1923             print_error(filename, err);
1924             exit_program(1);
1925         }
1926     }
1927
1928     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1929         av_strstart(filename, "http:", NULL)) {
1930         int j;
1931         /* special case for files sent to ffserver: we get the stream
1932            parameters from ffserver */
1933         int err = read_ffserver_streams(o, oc, filename);
1934         if (err < 0) {
1935             print_error(filename, err);
1936             exit_program(1);
1937         }
1938         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1939             ost = output_streams[j];
1940             for (i = 0; i < nb_input_streams; i++) {
1941                 ist = input_streams[i];
1942                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1943                     ost->sync_ist= ist;
1944                     ost->source_index= i;
1945                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1946                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1947                     ist->discard = 0;
1948                     ist->st->discard = ist->user_set_discard;
1949                     break;
1950                 }
1951             }
1952             if(!ost->sync_ist){
1953                 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));
1954                 exit_program(1);
1955             }
1956         }
1957     } else if (!o->nb_stream_maps) {
1958         char *subtitle_codec_name = NULL;
1959         /* pick the "best" stream of each type */
1960
1961         /* video: highest resolution */
1962         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
1963             int area = 0, idx = -1;
1964             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
1965             for (i = 0; i < nb_input_streams; i++) {
1966                 int new_area;
1967                 ist = input_streams[i];
1968                 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
1969                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1970                     new_area = 1;
1971                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1972                     new_area > area) {
1973                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
1974                         continue;
1975                     area = new_area;
1976                     idx = i;
1977                 }
1978             }
1979             if (idx >= 0)
1980                 new_video_stream(o, oc, idx);
1981         }
1982
1983         /* audio: most channels */
1984         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
1985             int channels = 0, idx = -1;
1986             for (i = 0; i < nb_input_streams; i++) {
1987                 ist = input_streams[i];
1988                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1989                     ist->st->codec->channels > channels) {
1990                     channels = ist->st->codec->channels;
1991                     idx = i;
1992                 }
1993             }
1994             if (idx >= 0)
1995                 new_audio_stream(o, oc, idx);
1996         }
1997
1998         /* subtitles: pick first */
1999         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2000         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2001             for (i = 0; i < nb_input_streams; i++)
2002                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2003                     AVCodecDescriptor const *input_descriptor =
2004                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2005                     AVCodecDescriptor const *output_descriptor = NULL;
2006                     AVCodec const *output_codec =
2007                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2008                     int input_props = 0, output_props = 0;
2009                     if (output_codec)
2010                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2011                     if (input_descriptor)
2012                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2013                     if (output_descriptor)
2014                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2015                     if (subtitle_codec_name ||
2016                         input_props & output_props ||
2017                         // Map dvb teletext which has neither property to any output subtitle encoder
2018                         input_descriptor && output_descriptor &&
2019                         (!input_descriptor->props ||
2020                          !output_descriptor->props)) {
2021                         new_subtitle_stream(o, oc, i);
2022                         break;
2023                     }
2024                 }
2025         }
2026         /* Data only if codec id match */
2027         if (!o->data_disable ) {
2028             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2029             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2030                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2031                     && input_streams[i]->st->codec->codec_id == codec_id )
2032                     new_data_stream(o, oc, i);
2033             }
2034         }
2035     } else {
2036         for (i = 0; i < o->nb_stream_maps; i++) {
2037             StreamMap *map = &o->stream_maps[i];
2038
2039             if (map->disabled)
2040                 continue;
2041
2042             if (map->linklabel) {
2043                 FilterGraph *fg;
2044                 OutputFilter *ofilter = NULL;
2045                 int j, k;
2046
2047                 for (j = 0; j < nb_filtergraphs; j++) {
2048                     fg = filtergraphs[j];
2049                     for (k = 0; k < fg->nb_outputs; k++) {
2050                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2051                         if (out && !strcmp(out->name, map->linklabel)) {
2052                             ofilter = fg->outputs[k];
2053                             goto loop_end;
2054                         }
2055                     }
2056                 }
2057 loop_end:
2058                 if (!ofilter) {
2059                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2060                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2061                     exit_program(1);
2062                 }
2063                 init_output_filter(ofilter, o, oc);
2064             } else {
2065                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2066
2067                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2068                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2069                     continue;
2070                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2071                     continue;
2072                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2073                     continue;
2074                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2075                     continue;
2076
2077                 ost = NULL;
2078                 switch (ist->st->codec->codec_type) {
2079                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2080                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2081                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2082                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2083                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2084                 case AVMEDIA_TYPE_UNKNOWN:
2085                     if (copy_unknown_streams) {
2086                         ost = new_unknown_stream   (o, oc, src_idx);
2087                         break;
2088                     }
2089                 default:
2090                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2091                            "Cannot map stream #%d:%d - unsupported type.\n",
2092                            map->file_index, map->stream_index);
2093                     if (!ignore_unknown_streams) {
2094                         av_log(NULL, AV_LOG_FATAL,
2095                                "If you want unsupported types ignored instead "
2096                                "of failing, please use the -ignore_unknown option\n"
2097                                "If you want them copied, please use -copy_unknown\n");
2098                         exit_program(1);
2099                     }
2100                 }
2101                 if (ost)
2102                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2103                                                   + map->sync_stream_index];
2104             }
2105         }
2106     }
2107
2108     /* handle attached files */
2109     for (i = 0; i < o->nb_attachments; i++) {
2110         AVIOContext *pb;
2111         uint8_t *attachment;
2112         const char *p;
2113         int64_t len;
2114
2115         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2116             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2117                    o->attachments[i]);
2118             exit_program(1);
2119         }
2120         if ((len = avio_size(pb)) <= 0) {
2121             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2122                    o->attachments[i]);
2123             exit_program(1);
2124         }
2125         if (!(attachment = av_malloc(len))) {
2126             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2127                    o->attachments[i]);
2128             exit_program(1);
2129         }
2130         avio_read(pb, attachment, len);
2131
2132         ost = new_attachment_stream(o, oc, -1);
2133         ost->stream_copy               = 1;
2134         ost->attachment_filename       = o->attachments[i];
2135         ost->finished                  = 1;
2136         ost->st->codec->extradata      = attachment;
2137         ost->st->codec->extradata_size = len;
2138
2139         p = strrchr(o->attachments[i], '/');
2140         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2141         avio_closep(&pb);
2142     }
2143
2144     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2145         AVDictionaryEntry *e;
2146         ost = output_streams[i];
2147
2148         if ((ost->stream_copy || ost->attachment_filename)
2149             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2150             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2151             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2152                 exit_program(1);
2153     }
2154
2155     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2156         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2157         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2158         exit_program(1);
2159     }
2160
2161     /* check if all codec options have been used */
2162     unused_opts = strip_specifiers(o->g->codec_opts);
2163     for (i = of->ost_index; i < nb_output_streams; i++) {
2164         e = NULL;
2165         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2166                                 AV_DICT_IGNORE_SUFFIX)))
2167             av_dict_set(&unused_opts, e->key, NULL, 0);
2168     }
2169
2170     e = NULL;
2171     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2172         const AVClass *class = avcodec_get_class();
2173         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2174                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2175         const AVClass *fclass = avformat_get_class();
2176         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2177                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2178         if (!option || foption)
2179             continue;
2180
2181
2182         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2183             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2184                    "output file #%d (%s) is not an encoding option.\n", e->key,
2185                    option->help ? option->help : "", nb_output_files - 1,
2186                    filename);
2187             exit_program(1);
2188         }
2189
2190         // gop_timecode is injected by generic code but not always used
2191         if (!strcmp(e->key, "gop_timecode"))
2192             continue;
2193
2194         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2195                "output file #%d (%s) has not been used for any stream. The most "
2196                "likely reason is either wrong type (e.g. a video option with "
2197                "no video streams) or that it is a private option of some encoder "
2198                "which was not actually used for any stream.\n", e->key,
2199                option->help ? option->help : "", nb_output_files - 1, filename);
2200     }
2201     av_dict_free(&unused_opts);
2202
2203     /* set the encoding/decoding_needed flags */
2204     for (i = of->ost_index; i < nb_output_streams; i++) {
2205         OutputStream *ost = output_streams[i];
2206
2207         ost->encoding_needed = !ost->stream_copy;
2208         if (ost->encoding_needed && ost->source_index >= 0) {
2209             InputStream *ist = input_streams[ost->source_index];
2210             ist->decoding_needed |= DECODING_FOR_OST;
2211         }
2212     }
2213
2214     /* check filename in case of an image number is expected */
2215     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2216         if (!av_filename_number_test(oc->filename)) {
2217             print_error(oc->filename, AVERROR(EINVAL));
2218             exit_program(1);
2219         }
2220     }
2221
2222     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2223         av_log(NULL, AV_LOG_ERROR,
2224                "No input streams but output needs an input stream\n");
2225         exit_program(1);
2226     }
2227
2228     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2229         /* test if it already exists to avoid losing precious files */
2230         assert_file_overwrite(filename);
2231
2232         /* open the file */
2233         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2234                               &oc->interrupt_callback,
2235                               &of->opts)) < 0) {
2236             print_error(filename, err);
2237             exit_program(1);
2238         }
2239     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2240         assert_file_overwrite(filename);
2241
2242     if (o->mux_preload) {
2243         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2244     }
2245     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2246
2247     /* copy metadata */
2248     for (i = 0; i < o->nb_metadata_map; i++) {
2249         char *p;
2250         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2251
2252         if (in_file_index >= nb_input_files) {
2253             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2254             exit_program(1);
2255         }
2256         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2257                       in_file_index >= 0 ?
2258                       input_files[in_file_index]->ctx : NULL, o);
2259     }
2260
2261     /* copy chapters */
2262     if (o->chapters_input_file >= nb_input_files) {
2263         if (o->chapters_input_file == INT_MAX) {
2264             /* copy chapters from the first input file that has them*/
2265             o->chapters_input_file = -1;
2266             for (i = 0; i < nb_input_files; i++)
2267                 if (input_files[i]->ctx->nb_chapters) {
2268                     o->chapters_input_file = i;
2269                     break;
2270                 }
2271         } else {
2272             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2273                    o->chapters_input_file);
2274             exit_program(1);
2275         }
2276     }
2277     if (o->chapters_input_file >= 0)
2278         copy_chapters(input_files[o->chapters_input_file], of,
2279                       !o->metadata_chapters_manual);
2280
2281     /* copy global metadata by default */
2282     if (!o->metadata_global_manual && nb_input_files){
2283         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2284                      AV_DICT_DONT_OVERWRITE);
2285         if(o->recording_time != INT64_MAX)
2286             av_dict_set(&oc->metadata, "duration", NULL, 0);
2287         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2288     }
2289     if (!o->metadata_streams_manual)
2290         for (i = of->ost_index; i < nb_output_streams; i++) {
2291             InputStream *ist;
2292             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2293                 continue;
2294             ist = input_streams[output_streams[i]->source_index];
2295             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2296             if (!output_streams[i]->stream_copy) {
2297                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2298                 if (ist->autorotate)
2299                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2300             }
2301         }
2302
2303     /* process manually set metadata */
2304     for (i = 0; i < o->nb_metadata; i++) {
2305         AVDictionary **m;
2306         char type, *val;
2307         const char *stream_spec;
2308         int index = 0, j, ret = 0;
2309         char now_time[256];
2310
2311         val = strchr(o->metadata[i].u.str, '=');
2312         if (!val) {
2313             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2314                    o->metadata[i].u.str);
2315             exit_program(1);
2316         }
2317         *val++ = 0;
2318
2319         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2320             !strcmp(val, "now")) {
2321             time_t now = time(0);
2322             struct tm *ptm, tmbuf;
2323             ptm = localtime_r(&now, &tmbuf);
2324             if (ptm) {
2325                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2326                     val = now_time;
2327             }
2328         }
2329
2330         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2331         if (type == 's') {
2332             for (j = 0; j < oc->nb_streams; j++) {
2333                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2334                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2335                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2336                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2337                         ost->rotate_overridden = 1;
2338                     }
2339                 } else if (ret < 0)
2340                     exit_program(1);
2341             }
2342         }
2343         else {
2344             switch (type) {
2345             case 'g':
2346                 m = &oc->metadata;
2347                 break;
2348             case 'c':
2349                 if (index < 0 || index >= oc->nb_chapters) {
2350                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2351                     exit_program(1);
2352                 }
2353                 m = &oc->chapters[index]->metadata;
2354                 break;
2355             default:
2356                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2357                 exit_program(1);
2358             }
2359             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2360         }
2361     }
2362
2363     return 0;
2364 }
2365
2366 static int opt_target(void *optctx, const char *opt, const char *arg)
2367 {
2368     OptionsContext *o = optctx;
2369     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2370     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2371
2372     if (!strncmp(arg, "pal-", 4)) {
2373         norm = PAL;
2374         arg += 4;
2375     } else if (!strncmp(arg, "ntsc-", 5)) {
2376         norm = NTSC;
2377         arg += 5;
2378     } else if (!strncmp(arg, "film-", 5)) {
2379         norm = FILM;
2380         arg += 5;
2381     } else {
2382         /* Try to determine PAL/NTSC by peeking in the input files */
2383         if (nb_input_files) {
2384             int i, j, fr;
2385             for (j = 0; j < nb_input_files; j++) {
2386                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2387                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2388                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2389                         !c->time_base.num)
2390                         continue;
2391                     fr = c->time_base.den * 1000 / c->time_base.num;
2392                     if (fr == 25000) {
2393                         norm = PAL;
2394                         break;
2395                     } else if ((fr == 29970) || (fr == 23976)) {
2396                         norm = NTSC;
2397                         break;
2398                     }
2399                 }
2400                 if (norm != UNKNOWN)
2401                     break;
2402             }
2403         }
2404         if (norm != UNKNOWN)
2405             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2406     }
2407
2408     if (norm == UNKNOWN) {
2409         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2410         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2411         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2412         exit_program(1);
2413     }
2414
2415     if (!strcmp(arg, "vcd")) {
2416         opt_video_codec(o, "c:v", "mpeg1video");
2417         opt_audio_codec(o, "c:a", "mp2");
2418         parse_option(o, "f", "vcd", options);
2419
2420         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2421         parse_option(o, "r", frame_rates[norm], options);
2422         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2423
2424         opt_default(NULL, "b:v", "1150000");
2425         opt_default(NULL, "maxrate:v", "1150000");
2426         opt_default(NULL, "minrate:v", "1150000");
2427         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2428
2429         opt_default(NULL, "b:a", "224000");
2430         parse_option(o, "ar", "44100", options);
2431         parse_option(o, "ac", "2", options);
2432
2433         opt_default(NULL, "packetsize", "2324");
2434         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2435
2436         /* We have to offset the PTS, so that it is consistent with the SCR.
2437            SCR starts at 36000, but the first two packs contain only padding
2438            and the first pack from the other stream, respectively, may also have
2439            been written before.
2440            So the real data starts at SCR 36000+3*1200. */
2441         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2442     } else if (!strcmp(arg, "svcd")) {
2443
2444         opt_video_codec(o, "c:v", "mpeg2video");
2445         opt_audio_codec(o, "c:a", "mp2");
2446         parse_option(o, "f", "svcd", options);
2447
2448         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2449         parse_option(o, "r", frame_rates[norm], options);
2450         parse_option(o, "pix_fmt", "yuv420p", options);
2451         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2452
2453         opt_default(NULL, "b:v", "2040000");
2454         opt_default(NULL, "maxrate:v", "2516000");
2455         opt_default(NULL, "minrate:v", "0"); // 1145000;
2456         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2457         opt_default(NULL, "scan_offset", "1");
2458
2459         opt_default(NULL, "b:a", "224000");
2460         parse_option(o, "ar", "44100", options);
2461
2462         opt_default(NULL, "packetsize", "2324");
2463
2464     } else if (!strcmp(arg, "dvd")) {
2465
2466         opt_video_codec(o, "c:v", "mpeg2video");
2467         opt_audio_codec(o, "c:a", "ac3");
2468         parse_option(o, "f", "dvd", options);
2469
2470         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2471         parse_option(o, "r", frame_rates[norm], options);
2472         parse_option(o, "pix_fmt", "yuv420p", options);
2473         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2474
2475         opt_default(NULL, "b:v", "6000000");
2476         opt_default(NULL, "maxrate:v", "9000000");
2477         opt_default(NULL, "minrate:v", "0"); // 1500000;
2478         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2479
2480         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2481         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2482
2483         opt_default(NULL, "b:a", "448000");
2484         parse_option(o, "ar", "48000", options);
2485
2486     } else if (!strncmp(arg, "dv", 2)) {
2487
2488         parse_option(o, "f", "dv", options);
2489
2490         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2491         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2492                           norm == PAL ? "yuv420p" : "yuv411p", options);
2493         parse_option(o, "r", frame_rates[norm], options);
2494
2495         parse_option(o, "ar", "48000", options);
2496         parse_option(o, "ac", "2", options);
2497
2498     } else {
2499         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2500         return AVERROR(EINVAL);
2501     }
2502
2503     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2504     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2505
2506     return 0;
2507 }
2508
2509 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2510 {
2511     av_free (vstats_filename);
2512     vstats_filename = av_strdup (arg);
2513     return 0;
2514 }
2515
2516 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2517 {
2518     char filename[40];
2519     time_t today2 = time(NULL);
2520     struct tm *today = localtime(&today2);
2521
2522     if (!today) { // maybe tomorrow
2523         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2524         exit_program(1);
2525     }
2526
2527     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2528              today->tm_sec);
2529     return opt_vstats_file(NULL, opt, filename);
2530 }
2531
2532 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2533 {
2534     OptionsContext *o = optctx;
2535     return parse_option(o, "frames:v", arg, options);
2536 }
2537
2538 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2539 {
2540     OptionsContext *o = optctx;
2541     return parse_option(o, "frames:a", arg, options);
2542 }
2543
2544 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2545 {
2546     OptionsContext *o = optctx;
2547     return parse_option(o, "frames:d", arg, options);
2548 }
2549
2550 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2551 {
2552     int ret;
2553     AVDictionary *cbak = codec_opts;
2554     AVDictionary *fbak = format_opts;
2555     codec_opts = NULL;
2556     format_opts = NULL;
2557
2558     ret = opt_default(NULL, opt, arg);
2559
2560     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2561     av_dict_copy(&o->g->format_opts, format_opts, 0);
2562     av_dict_free(&codec_opts);
2563     av_dict_free(&format_opts);
2564     codec_opts = cbak;
2565     format_opts = fbak;
2566
2567     return ret;
2568 }
2569
2570 static int opt_preset(void *optctx, const char *opt, const char *arg)
2571 {
2572     OptionsContext *o = optctx;
2573     FILE *f=NULL;
2574     char filename[1000], line[1000], tmp_line[1000];
2575     const char *codec_name = NULL;
2576
2577     tmp_line[0] = *opt;
2578     tmp_line[1] = 0;
2579     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2580
2581     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2582         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2583             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2584         }else
2585             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2586         exit_program(1);
2587     }
2588
2589     while (fgets(line, sizeof(line), f)) {
2590         char *key = tmp_line, *value, *endptr;
2591
2592         if (strcspn(line, "#\n\r") == 0)
2593             continue;
2594         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2595         if (!av_strtok(key,   "=",    &value) ||
2596             !av_strtok(value, "\r\n", &endptr)) {
2597             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2598             exit_program(1);
2599         }
2600         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2601
2602         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2603         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2604         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2605         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2606         else if (opt_default_new(o, key, value) < 0) {
2607             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2608                    filename, line, key, value);
2609             exit_program(1);
2610         }
2611     }
2612
2613     fclose(f);
2614
2615     return 0;
2616 }
2617
2618 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2619 {
2620     OptionsContext *o = optctx;
2621     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2622     int ret = parse_option(o, s, arg, options);
2623     av_free(s);
2624     return ret;
2625 }
2626
2627 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2628 {
2629     OptionsContext *o = optctx;
2630
2631     if(!strcmp(opt, "ab")){
2632         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2633         return 0;
2634     } else if(!strcmp(opt, "b")){
2635         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2636         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2637         return 0;
2638     }
2639     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2640     return 0;
2641 }
2642
2643 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2644 {
2645     OptionsContext *o = optctx;
2646     char *s;
2647     int ret;
2648     if(!strcmp(opt, "qscale")){
2649         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2650         return parse_option(o, "q:v", arg, options);
2651     }
2652     s = av_asprintf("q%s", opt + 6);
2653     ret = parse_option(o, s, arg, options);
2654     av_free(s);
2655     return ret;
2656 }
2657
2658 static int opt_profile(void *optctx, const char *opt, const char *arg)
2659 {
2660     OptionsContext *o = optctx;
2661     if(!strcmp(opt, "profile")){
2662         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2663         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2664         return 0;
2665     }
2666     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2667     return 0;
2668 }
2669
2670 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2671 {
2672     OptionsContext *o = optctx;
2673     return parse_option(o, "filter:v", arg, options);
2674 }
2675
2676 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2677 {
2678     OptionsContext *o = optctx;
2679     return parse_option(o, "filter:a", arg, options);
2680 }
2681
2682 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2683 {
2684     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2685     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2686     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2687     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2688
2689     if (video_sync_method == VSYNC_AUTO)
2690         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2691     return 0;
2692 }
2693
2694 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2695 {
2696     OptionsContext *o = optctx;
2697     char *tcr = av_asprintf("timecode=%s", arg);
2698     int ret = parse_option(o, "metadata:g", tcr, options);
2699     if (ret >= 0)
2700         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2701     av_free(tcr);
2702     return 0;
2703 }
2704
2705 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2706 {
2707     OptionsContext *o = optctx;
2708     char layout_str[32];
2709     char *stream_str;
2710     char *ac_str;
2711     int ret, channels, ac_str_size;
2712     uint64_t layout;
2713
2714     layout = av_get_channel_layout(arg);
2715     if (!layout) {
2716         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2717         return AVERROR(EINVAL);
2718     }
2719     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2720     ret = opt_default_new(o, opt, layout_str);
2721     if (ret < 0)
2722         return ret;
2723
2724     /* set 'ac' option based on channel layout */
2725     channels = av_get_channel_layout_nb_channels(layout);
2726     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2727     stream_str = strchr(opt, ':');
2728     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2729     ac_str = av_mallocz(ac_str_size);
2730     if (!ac_str)
2731         return AVERROR(ENOMEM);
2732     av_strlcpy(ac_str, "ac", 3);
2733     if (stream_str)
2734         av_strlcat(ac_str, stream_str, ac_str_size);
2735     ret = parse_option(o, ac_str, layout_str, options);
2736     av_free(ac_str);
2737
2738     return ret;
2739 }
2740
2741 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2742 {
2743     OptionsContext *o = optctx;
2744     return parse_option(o, "q:a", arg, options);
2745 }
2746
2747 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2748 {
2749     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2750     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2751         return AVERROR(ENOMEM);
2752     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2753     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2754     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2755         return AVERROR(ENOMEM);
2756
2757     input_stream_potentially_available = 1;
2758
2759     return 0;
2760 }
2761
2762 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2763 {
2764     uint8_t *graph_desc = read_file(arg);
2765     if (!graph_desc)
2766         return AVERROR(EINVAL);
2767
2768     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2769     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2770         return AVERROR(ENOMEM);
2771     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2772     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2773
2774     input_stream_potentially_available = 1;
2775
2776     return 0;
2777 }
2778
2779 void show_help_default(const char *opt, const char *arg)
2780 {
2781     /* per-file options have at least one of those set */
2782     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2783     int show_advanced = 0, show_avoptions = 0;
2784
2785     if (opt && *opt) {
2786         if (!strcmp(opt, "long"))
2787             show_advanced = 1;
2788         else if (!strcmp(opt, "full"))
2789             show_advanced = show_avoptions = 1;
2790         else
2791             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2792     }
2793
2794     show_usage();
2795
2796     printf("Getting help:\n"
2797            "    -h      -- print basic options\n"
2798            "    -h long -- print more options\n"
2799            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2800            "    See man %s for detailed description of the options.\n"
2801            "\n", program_name);
2802
2803     show_help_options(options, "Print help / information / capabilities:",
2804                       OPT_EXIT, 0, 0);
2805
2806     show_help_options(options, "Global options (affect whole program "
2807                       "instead of just one file:",
2808                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2809     if (show_advanced)
2810         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2811                           per_file | OPT_EXIT, 0);
2812
2813     show_help_options(options, "Per-file main options:", 0,
2814                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2815                       OPT_EXIT, per_file);
2816     if (show_advanced)
2817         show_help_options(options, "Advanced per-file options:",
2818                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2819
2820     show_help_options(options, "Video options:",
2821                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2822     if (show_advanced)
2823         show_help_options(options, "Advanced Video options:",
2824                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2825
2826     show_help_options(options, "Audio options:",
2827                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2828     if (show_advanced)
2829         show_help_options(options, "Advanced Audio options:",
2830                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2831     show_help_options(options, "Subtitle options:",
2832                       OPT_SUBTITLE, 0, 0);
2833     printf("\n");
2834
2835     if (show_avoptions) {
2836         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2837         show_help_children(avcodec_get_class(), flags);
2838         show_help_children(avformat_get_class(), flags);
2839 #if CONFIG_SWSCALE
2840         show_help_children(sws_get_class(), flags);
2841 #endif
2842         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2843         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2844     }
2845 }
2846
2847 void show_usage(void)
2848 {
2849     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2850     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2851     av_log(NULL, AV_LOG_INFO, "\n");
2852 }
2853
2854 enum OptGroup {
2855     GROUP_OUTFILE,
2856     GROUP_INFILE,
2857 };
2858
2859 static const OptionGroupDef groups[] = {
2860     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2861     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2862 };
2863
2864 static int open_files(OptionGroupList *l, const char *inout,
2865                       int (*open_file)(OptionsContext*, const char*))
2866 {
2867     int i, ret;
2868
2869     for (i = 0; i < l->nb_groups; i++) {
2870         OptionGroup *g = &l->groups[i];
2871         OptionsContext o;
2872
2873         init_options(&o);
2874         o.g = g;
2875
2876         ret = parse_optgroup(&o, g);
2877         if (ret < 0) {
2878             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2879                    "%s.\n", inout, g->arg);
2880             return ret;
2881         }
2882
2883         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2884         ret = open_file(&o, g->arg);
2885         uninit_options(&o);
2886         if (ret < 0) {
2887             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2888                    inout, g->arg);
2889             return ret;
2890         }
2891         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2892     }
2893
2894     return 0;
2895 }
2896
2897 int ffmpeg_parse_options(int argc, char **argv)
2898 {
2899     OptionParseContext octx;
2900     uint8_t error[128];
2901     int ret;
2902
2903     memset(&octx, 0, sizeof(octx));
2904
2905     /* split the commandline into an internal representation */
2906     ret = split_commandline(&octx, argc, argv, options, groups,
2907                             FF_ARRAY_ELEMS(groups));
2908     if (ret < 0) {
2909         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2910         goto fail;
2911     }
2912
2913     /* apply global options */
2914     ret = parse_optgroup(NULL, &octx.global_opts);
2915     if (ret < 0) {
2916         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2917         goto fail;
2918     }
2919
2920     /* open input files */
2921     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2922     if (ret < 0) {
2923         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2924         goto fail;
2925     }
2926
2927     /* create the complex filtergraphs */
2928     ret = init_complex_filters();
2929     if (ret < 0) {
2930         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2931         goto fail;
2932     }
2933
2934     /* open output files */
2935     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2936     if (ret < 0) {
2937         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2938         goto fail;
2939     }
2940
2941     /* configure the complex filtergraphs */
2942     ret = configure_complex_filters();
2943     if (ret < 0) {
2944         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
2945         goto fail;
2946     }
2947
2948 fail:
2949     uninit_parse_context(&octx);
2950     if (ret < 0) {
2951         av_strerror(ret, error, sizeof(error));
2952         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2953     }
2954     return ret;
2955 }
2956
2957 static int opt_progress(void *optctx, const char *opt, const char *arg)
2958 {
2959     AVIOContext *avio = NULL;
2960     int ret;
2961
2962     if (!strcmp(arg, "-"))
2963         arg = "pipe:";
2964     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
2965     if (ret < 0) {
2966         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
2967                arg, av_err2str(ret));
2968         return ret;
2969     }
2970     progress_avio = avio;
2971     return 0;
2972 }
2973
2974 #define OFFSET(x) offsetof(OptionsContext, x)
2975 const OptionDef options[] = {
2976     /* main options */
2977 #include "cmdutils_common_opts.h"
2978     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2979                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2980         "force format", "fmt" },
2981     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2982         "overwrite output files" },
2983     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
2984         "never overwrite output files" },
2985     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
2986         "Ignore unknown stream types" },
2987     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
2988         "Copy unknown stream types" },
2989     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2990                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2991         "codec name", "codec" },
2992     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2993                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2994         "codec name", "codec" },
2995     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2996                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2997         "preset name", "preset" },
2998     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2999                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3000         "set input stream mapping",
3001         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3002     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3003         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3004     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3005                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3006         "set metadata information of outfile from infile",
3007         "outfile[,metadata]:infile[,metadata]" },
3008     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3009                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3010         "set chapters mapping", "input_file_index" },
3011     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3012                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3013         "record or transcode \"duration\" seconds of audio/video",
3014         "duration" },
3015     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3016         "record or transcode stop time", "time_stop" },
3017     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3018         "set the limit file size in bytes", "limit_size" },
3019     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3020                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3021         "set the start time offset", "time_off" },
3022     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3023                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3024         "enable/disable seeking by timestamp with -ss" },
3025     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3026                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3027         "enable/disable accurate seeking with -ss" },
3028     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3029                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3030         "set the input ts offset", "time_off" },
3031     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3032                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3033         "set the input ts scale", "scale" },
3034     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3035         "set the recording timestamp ('now' to set the current time)", "time" },
3036     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3037         "add metadata", "string=string" },
3038     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3039                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3040         "set the number of data frames to output", "number" },
3041     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3042         "add timings for benchmarking" },
3043     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3044       "add timings for each task" },
3045     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3046       "write program-readable progress information", "url" },
3047     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3048       "enable or disable interaction on standard input" },
3049     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3050         "set max runtime in seconds", "limit" },
3051     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3052         "dump each input packet" },
3053     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3054         "when dumping packets, also dump the payload" },
3055     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3056                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3057         "read input at native frame rate", "" },
3058     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3059         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
3060         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3061     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
3062         "video sync method", "" },
3063     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3064         "frame drop threshold", "" },
3065     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3066         "audio sync method", "" },
3067     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3068         "audio drift threshold", "threshold" },
3069     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3070         "copy timestamps" },
3071     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3072         "shift input timestamps to start at 0 when using copyts" },
3073     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3074         "copy input stream time base when stream copying", "mode" },
3075     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3076                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3077         "finish encoding within shortest input" },
3078     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3079                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3080         "audio pad", "" },
3081     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3082         "timestamp discontinuity delta threshold", "threshold" },
3083     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3084         "timestamp error delta threshold", "threshold" },
3085     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3086         "exit on error", "error" },
3087     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3088                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3089         "copy initial non-keyframes" },
3090     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3091         "copy or discard frames before start time" },
3092     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3093         "set the number of frames to output", "number" },
3094     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3095                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3096         "force codec tag/fourcc", "fourcc/tag" },
3097     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3098                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3099         "use fixed quality scale (VBR)", "q" },
3100     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3101                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3102         "use fixed quality scale (VBR)", "q" },
3103     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3104         "set profile", "profile" },
3105     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3106         "set stream filtergraph", "filter_graph" },
3107     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3108         "read stream filtergraph description from a file", "filename" },
3109     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3110         "reinit filtergraph on input parameter changes", "" },
3111     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3112         "create a complex filtergraph", "graph_description" },
3113     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3114         "create a complex filtergraph", "graph_description" },
3115     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3116         "read complex filtergraph description from a file", "filename" },
3117     { "stats",          OPT_BOOL,                                    { &print_stats },
3118         "print progress report during encoding", },
3119     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3120                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3121         "add an attachment to the output file", "filename" },
3122     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3123                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3124         "extract an attachment into a file", "filename" },
3125     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3126         "print timestamp debugging info" },
3127     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3128         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3129     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3130                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3131         "discard", "" },
3132     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3133                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3134         "disposition", "" },
3135     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3136                                                                      { .off = OFFSET(thread_queue_size) },
3137         "set the maximum number of queued packets from the demuxer" },
3138
3139     /* video options */
3140     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3141         "set the number of video frames to output", "number" },
3142     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3143                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3144         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3145     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3146                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3147         "set frame size (WxH or abbreviation)", "size" },
3148     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3149                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3150         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3151     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3152                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3153         "set pixel format", "format" },
3154     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3155         "set the number of bits per raw sample", "number" },
3156     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3157         "deprecated use -g 1" },
3158     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3159         "disable video" },
3160     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3161                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3162         "rate control override for specific intervals", "override" },
3163     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3164                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3165         "force video codec ('copy' to copy stream)", "codec" },
3166     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3167         "Removed" },
3168     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3169         "Removed" },
3170     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3171         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3172     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3173         "select the pass number (1 to 3)", "n" },
3174     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3175                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3176         "select two pass log file name prefix", "prefix" },
3177     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3178         "this option is deprecated, use the yadif filter instead" },
3179     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3180         "calculate PSNR of compressed frames" },
3181     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
3182         "dump video coding statistics to file" },
3183     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
3184         "dump video coding statistics to file", "file" },
3185     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3186         "set video filters", "filter_graph" },
3187     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3188                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3189         "specify intra matrix coeffs", "matrix" },
3190     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3191                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3192         "specify inter matrix coeffs", "matrix" },
3193     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3194                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3195         "specify intra matrix coeffs", "matrix" },
3196     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3197                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3198         "top=1/bottom=0/auto=-1 field first", "" },
3199     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3200                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3201         "force video tag/fourcc", "fourcc/tag" },
3202     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3203         "show QP histogram" },
3204     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3205                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3206         "force the selected framerate, disable the best supported framerate selection" },
3207     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3208                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3209         "set the value of an outfile streamid", "streamIndex:value" },
3210     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3211                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3212         "force key frames at specified timestamps", "timestamps" },
3213     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3214         "audio bitrate (please use -b:a)", "bitrate" },
3215     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3216         "video bitrate (please use -b:v)", "bitrate" },
3217     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3218                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3219         "use HW accelerated decoding", "hwaccel name" },
3220     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3221                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3222         "select a device for HW acceleration" "devicename" },
3223 #if HAVE_VDPAU_X11
3224     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3225 #endif
3226     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3227                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3228         "automatically insert correct rotate filters" },
3229
3230     /* audio options */
3231     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3232         "set the number of audio frames to output", "number" },
3233     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3234         "set audio quality (codec-specific)", "quality", },
3235     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3236                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3237         "set audio sampling rate (in Hz)", "rate" },
3238     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3239                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3240         "set number of audio channels", "channels" },
3241     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3242         "disable audio" },
3243     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3244                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3245         "force audio codec ('copy' to copy stream)", "codec" },
3246     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3247                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3248         "force audio tag/fourcc", "fourcc/tag" },
3249     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3250         "change audio volume (256=normal)" , "volume" },
3251     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3252                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3253         "set sample format", "format" },
3254     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3255                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3256         "set channel layout", "layout" },
3257     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3258         "set audio filters", "filter_graph" },
3259     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3260       "set the maximum number of channels to try to guess the channel layout" },
3261
3262     /* subtitle options */
3263     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3264         "disable subtitle" },
3265     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3266         "force subtitle codec ('copy' to copy stream)", "codec" },
3267     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3268         , "force subtitle tag/fourcc", "fourcc/tag" },
3269     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3270         "fix subtitles duration" },
3271     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3272         "set canvas size (WxH or abbreviation)", "size" },
3273
3274     /* grab options */
3275     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3276         "deprecated, use -channel", "channel" },
3277     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3278         "deprecated, use -standard", "standard" },
3279     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3280
3281     /* muxer options */
3282     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3283         "set the maximum demux-decode delay", "seconds" },
3284     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3285         "set the initial demux-decode delay", "seconds" },
3286     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3287         "override the options from ffserver", "" },
3288     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { opt_sdp_file },
3289         "specify a file in which to print sdp information", "file" },
3290
3291     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3292         "A comma-separated list of bitstream filters", "bitstream_filters" },
3293     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3294         "deprecated", "audio bitstream_filters" },
3295     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3296         "deprecated", "video bitstream_filters" },
3297
3298     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3299         "set the audio options to the indicated preset", "preset" },
3300     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3301         "set the video options to the indicated preset", "preset" },
3302     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3303         "set the subtitle options to the indicated preset", "preset" },
3304     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3305         "set options from indicated preset file", "filename" },
3306     /* data codec support */
3307     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3308         "force data codec ('copy' to copy stream)", "codec" },
3309     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3310         "disable data" },
3311
3312     { NULL, },
3313 };