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