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             const char *to_dealloc = p2;
2370             char *key;
2371             if (!p2)
2372                 break;
2373
2374             if(*p) p++;
2375
2376             key = av_get_token(&p2, "=");
2377             if (!key || !*p2) {
2378                 av_freep(&to_dealloc);
2379                 av_freep(&key);
2380                 break;
2381             }
2382             p2++;
2383
2384             if (!strcmp(key, "program_num"))
2385                 progid = strtol(p2, NULL, 0);
2386             av_freep(&to_dealloc);
2387             av_freep(&key);
2388         }
2389
2390         program = av_new_program(oc, progid);
2391
2392         p = o->program[i].u.str;
2393         while(*p) {
2394             const char *p2 = av_get_token(&p, ":");
2395             const char *to_dealloc = p2;
2396             char *key;
2397             if (!p2)
2398                 break;
2399             if(*p) p++;
2400
2401             key = av_get_token(&p2, "=");
2402             if (!key) {
2403                 av_log(NULL, AV_LOG_FATAL,
2404                        "No '=' character in program string %s.\n",
2405                        p2);
2406                 exit_program(1);
2407             }
2408             if (!*p2)
2409                 exit_program(1);
2410             p2++;
2411
2412             if (!strcmp(key, "title")) {
2413                 av_dict_set(&program->metadata, "title", p2, 0);
2414             } else if (!strcmp(key, "program_num")) {
2415             } else if (!strcmp(key, "st")) {
2416                 int st_num = strtol(p2, NULL, 0);
2417                 av_program_add_stream_index(oc, progid, st_num);
2418             } else {
2419                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2420                 exit_program(1);
2421             }
2422             av_freep(&to_dealloc);
2423             av_freep(&key);
2424         }
2425     }
2426
2427     /* process manually set metadata */
2428     for (i = 0; i < o->nb_metadata; i++) {
2429         AVDictionary **m;
2430         char type, *val;
2431         const char *stream_spec;
2432         int index = 0, j, ret = 0;
2433         char now_time[256];
2434
2435         val = strchr(o->metadata[i].u.str, '=');
2436         if (!val) {
2437             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2438                    o->metadata[i].u.str);
2439             exit_program(1);
2440         }
2441         *val++ = 0;
2442
2443         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2444             !strcmp(val, "now")) {
2445             time_t now = time(0);
2446             struct tm *ptm, tmbuf;
2447             ptm = localtime_r(&now, &tmbuf);
2448             if (ptm) {
2449                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2450                     val = now_time;
2451             }
2452         }
2453
2454         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2455         if (type == 's') {
2456             for (j = 0; j < oc->nb_streams; j++) {
2457                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2458                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2459                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2460                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2461                         ost->rotate_overridden = 1;
2462                     }
2463                 } else if (ret < 0)
2464                     exit_program(1);
2465             }
2466         }
2467         else {
2468             switch (type) {
2469             case 'g':
2470                 m = &oc->metadata;
2471                 break;
2472             case 'c':
2473                 if (index < 0 || index >= oc->nb_chapters) {
2474                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2475                     exit_program(1);
2476                 }
2477                 m = &oc->chapters[index]->metadata;
2478                 break;
2479             case 'p':
2480                 if (index < 0 || index >= oc->nb_programs) {
2481                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2482                     exit_program(1);
2483                 }
2484                 m = &oc->programs[index]->metadata;
2485                 break;
2486             default:
2487                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2488                 exit_program(1);
2489             }
2490             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2491         }
2492     }
2493
2494     return 0;
2495 }
2496
2497 static int opt_target(void *optctx, const char *opt, const char *arg)
2498 {
2499     OptionsContext *o = optctx;
2500     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2501     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2502
2503     if (!strncmp(arg, "pal-", 4)) {
2504         norm = PAL;
2505         arg += 4;
2506     } else if (!strncmp(arg, "ntsc-", 5)) {
2507         norm = NTSC;
2508         arg += 5;
2509     } else if (!strncmp(arg, "film-", 5)) {
2510         norm = FILM;
2511         arg += 5;
2512     } else {
2513         /* Try to determine PAL/NTSC by peeking in the input files */
2514         if (nb_input_files) {
2515             int i, j, fr;
2516             for (j = 0; j < nb_input_files; j++) {
2517                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2518                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2519                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2520                         !c->time_base.num)
2521                         continue;
2522                     fr = c->time_base.den * 1000 / c->time_base.num;
2523                     if (fr == 25000) {
2524                         norm = PAL;
2525                         break;
2526                     } else if ((fr == 29970) || (fr == 23976)) {
2527                         norm = NTSC;
2528                         break;
2529                     }
2530                 }
2531                 if (norm != UNKNOWN)
2532                     break;
2533             }
2534         }
2535         if (norm != UNKNOWN)
2536             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2537     }
2538
2539     if (norm == UNKNOWN) {
2540         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2541         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2542         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2543         exit_program(1);
2544     }
2545
2546     if (!strcmp(arg, "vcd")) {
2547         opt_video_codec(o, "c:v", "mpeg1video");
2548         opt_audio_codec(o, "c:a", "mp2");
2549         parse_option(o, "f", "vcd", options);
2550
2551         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2552         parse_option(o, "r", frame_rates[norm], options);
2553         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2554
2555         opt_default(NULL, "b:v", "1150000");
2556         opt_default(NULL, "maxrate:v", "1150000");
2557         opt_default(NULL, "minrate:v", "1150000");
2558         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2559
2560         opt_default(NULL, "b:a", "224000");
2561         parse_option(o, "ar", "44100", options);
2562         parse_option(o, "ac", "2", options);
2563
2564         opt_default(NULL, "packetsize", "2324");
2565         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2566
2567         /* We have to offset the PTS, so that it is consistent with the SCR.
2568            SCR starts at 36000, but the first two packs contain only padding
2569            and the first pack from the other stream, respectively, may also have
2570            been written before.
2571            So the real data starts at SCR 36000+3*1200. */
2572         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2573     } else if (!strcmp(arg, "svcd")) {
2574
2575         opt_video_codec(o, "c:v", "mpeg2video");
2576         opt_audio_codec(o, "c:a", "mp2");
2577         parse_option(o, "f", "svcd", options);
2578
2579         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2580         parse_option(o, "r", frame_rates[norm], options);
2581         parse_option(o, "pix_fmt", "yuv420p", options);
2582         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2583
2584         opt_default(NULL, "b:v", "2040000");
2585         opt_default(NULL, "maxrate:v", "2516000");
2586         opt_default(NULL, "minrate:v", "0"); // 1145000;
2587         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2588         opt_default(NULL, "scan_offset", "1");
2589
2590         opt_default(NULL, "b:a", "224000");
2591         parse_option(o, "ar", "44100", options);
2592
2593         opt_default(NULL, "packetsize", "2324");
2594
2595     } else if (!strcmp(arg, "dvd")) {
2596
2597         opt_video_codec(o, "c:v", "mpeg2video");
2598         opt_audio_codec(o, "c:a", "ac3");
2599         parse_option(o, "f", "dvd", options);
2600
2601         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2602         parse_option(o, "r", frame_rates[norm], options);
2603         parse_option(o, "pix_fmt", "yuv420p", options);
2604         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2605
2606         opt_default(NULL, "b:v", "6000000");
2607         opt_default(NULL, "maxrate:v", "9000000");
2608         opt_default(NULL, "minrate:v", "0"); // 1500000;
2609         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2610
2611         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2612         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2613
2614         opt_default(NULL, "b:a", "448000");
2615         parse_option(o, "ar", "48000", options);
2616
2617     } else if (!strncmp(arg, "dv", 2)) {
2618
2619         parse_option(o, "f", "dv", options);
2620
2621         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2622         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2623                           norm == PAL ? "yuv420p" : "yuv411p", options);
2624         parse_option(o, "r", frame_rates[norm], options);
2625
2626         parse_option(o, "ar", "48000", options);
2627         parse_option(o, "ac", "2", options);
2628
2629     } else {
2630         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2631         return AVERROR(EINVAL);
2632     }
2633
2634     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2635     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2636
2637     return 0;
2638 }
2639
2640 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2641 {
2642     av_free (vstats_filename);
2643     vstats_filename = av_strdup (arg);
2644     return 0;
2645 }
2646
2647 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2648 {
2649     char filename[40];
2650     time_t today2 = time(NULL);
2651     struct tm *today = localtime(&today2);
2652
2653     if (!today) { // maybe tomorrow
2654         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2655         exit_program(1);
2656     }
2657
2658     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2659              today->tm_sec);
2660     return opt_vstats_file(NULL, opt, filename);
2661 }
2662
2663 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2664 {
2665     OptionsContext *o = optctx;
2666     return parse_option(o, "frames:v", arg, options);
2667 }
2668
2669 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2670 {
2671     OptionsContext *o = optctx;
2672     return parse_option(o, "frames:a", arg, options);
2673 }
2674
2675 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2676 {
2677     OptionsContext *o = optctx;
2678     return parse_option(o, "frames:d", arg, options);
2679 }
2680
2681 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2682 {
2683     int ret;
2684     AVDictionary *cbak = codec_opts;
2685     AVDictionary *fbak = format_opts;
2686     codec_opts = NULL;
2687     format_opts = NULL;
2688
2689     ret = opt_default(NULL, opt, arg);
2690
2691     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2692     av_dict_copy(&o->g->format_opts, format_opts, 0);
2693     av_dict_free(&codec_opts);
2694     av_dict_free(&format_opts);
2695     codec_opts = cbak;
2696     format_opts = fbak;
2697
2698     return ret;
2699 }
2700
2701 static int opt_preset(void *optctx, const char *opt, const char *arg)
2702 {
2703     OptionsContext *o = optctx;
2704     FILE *f=NULL;
2705     char filename[1000], line[1000], tmp_line[1000];
2706     const char *codec_name = NULL;
2707
2708     tmp_line[0] = *opt;
2709     tmp_line[1] = 0;
2710     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2711
2712     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2713         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2714             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2715         }else
2716             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2717         exit_program(1);
2718     }
2719
2720     while (fgets(line, sizeof(line), f)) {
2721         char *key = tmp_line, *value, *endptr;
2722
2723         if (strcspn(line, "#\n\r") == 0)
2724             continue;
2725         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2726         if (!av_strtok(key,   "=",    &value) ||
2727             !av_strtok(value, "\r\n", &endptr)) {
2728             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2729             exit_program(1);
2730         }
2731         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2732
2733         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2734         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2735         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2736         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2737         else if (opt_default_new(o, key, value) < 0) {
2738             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2739                    filename, line, key, value);
2740             exit_program(1);
2741         }
2742     }
2743
2744     fclose(f);
2745
2746     return 0;
2747 }
2748
2749 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2750 {
2751     OptionsContext *o = optctx;
2752     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2753     int ret = parse_option(o, s, arg, options);
2754     av_free(s);
2755     return ret;
2756 }
2757
2758 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2759 {
2760     OptionsContext *o = optctx;
2761
2762     if(!strcmp(opt, "ab")){
2763         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2764         return 0;
2765     } else if(!strcmp(opt, "b")){
2766         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2767         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2768         return 0;
2769     }
2770     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2771     return 0;
2772 }
2773
2774 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2775 {
2776     OptionsContext *o = optctx;
2777     char *s;
2778     int ret;
2779     if(!strcmp(opt, "qscale")){
2780         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2781         return parse_option(o, "q:v", arg, options);
2782     }
2783     s = av_asprintf("q%s", opt + 6);
2784     ret = parse_option(o, s, arg, options);
2785     av_free(s);
2786     return ret;
2787 }
2788
2789 static int opt_profile(void *optctx, const char *opt, const char *arg)
2790 {
2791     OptionsContext *o = optctx;
2792     if(!strcmp(opt, "profile")){
2793         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2794         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2795         return 0;
2796     }
2797     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2798     return 0;
2799 }
2800
2801 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2802 {
2803     OptionsContext *o = optctx;
2804     return parse_option(o, "filter:v", arg, options);
2805 }
2806
2807 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2808 {
2809     OptionsContext *o = optctx;
2810     return parse_option(o, "filter:a", arg, options);
2811 }
2812
2813 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2814 {
2815     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2816     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2817     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2818     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2819
2820     if (video_sync_method == VSYNC_AUTO)
2821         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2822     return 0;
2823 }
2824
2825 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2826 {
2827     OptionsContext *o = optctx;
2828     char *tcr = av_asprintf("timecode=%s", arg);
2829     int ret = parse_option(o, "metadata:g", tcr, options);
2830     if (ret >= 0)
2831         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2832     av_free(tcr);
2833     return 0;
2834 }
2835
2836 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2837 {
2838     OptionsContext *o = optctx;
2839     char layout_str[32];
2840     char *stream_str;
2841     char *ac_str;
2842     int ret, channels, ac_str_size;
2843     uint64_t layout;
2844
2845     layout = av_get_channel_layout(arg);
2846     if (!layout) {
2847         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2848         return AVERROR(EINVAL);
2849     }
2850     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2851     ret = opt_default_new(o, opt, layout_str);
2852     if (ret < 0)
2853         return ret;
2854
2855     /* set 'ac' option based on channel layout */
2856     channels = av_get_channel_layout_nb_channels(layout);
2857     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2858     stream_str = strchr(opt, ':');
2859     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2860     ac_str = av_mallocz(ac_str_size);
2861     if (!ac_str)
2862         return AVERROR(ENOMEM);
2863     av_strlcpy(ac_str, "ac", 3);
2864     if (stream_str)
2865         av_strlcat(ac_str, stream_str, ac_str_size);
2866     ret = parse_option(o, ac_str, layout_str, options);
2867     av_free(ac_str);
2868
2869     return ret;
2870 }
2871
2872 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2873 {
2874     OptionsContext *o = optctx;
2875     return parse_option(o, "q:a", arg, options);
2876 }
2877
2878 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2879 {
2880     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2881     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2882         return AVERROR(ENOMEM);
2883     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2884     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2885     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2886         return AVERROR(ENOMEM);
2887
2888     input_stream_potentially_available = 1;
2889
2890     return 0;
2891 }
2892
2893 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2894 {
2895     uint8_t *graph_desc = read_file(arg);
2896     if (!graph_desc)
2897         return AVERROR(EINVAL);
2898
2899     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2900     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2901         return AVERROR(ENOMEM);
2902     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2903     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2904
2905     input_stream_potentially_available = 1;
2906
2907     return 0;
2908 }
2909
2910 void show_help_default(const char *opt, const char *arg)
2911 {
2912     /* per-file options have at least one of those set */
2913     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2914     int show_advanced = 0, show_avoptions = 0;
2915
2916     if (opt && *opt) {
2917         if (!strcmp(opt, "long"))
2918             show_advanced = 1;
2919         else if (!strcmp(opt, "full"))
2920             show_advanced = show_avoptions = 1;
2921         else
2922             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2923     }
2924
2925     show_usage();
2926
2927     printf("Getting help:\n"
2928            "    -h      -- print basic options\n"
2929            "    -h long -- print more options\n"
2930            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2931            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2932            "    See man %s for detailed description of the options.\n"
2933            "\n", program_name);
2934
2935     show_help_options(options, "Print help / information / capabilities:",
2936                       OPT_EXIT, 0, 0);
2937
2938     show_help_options(options, "Global options (affect whole program "
2939                       "instead of just one file:",
2940                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2941     if (show_advanced)
2942         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2943                           per_file | OPT_EXIT, 0);
2944
2945     show_help_options(options, "Per-file main options:", 0,
2946                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2947                       OPT_EXIT, per_file);
2948     if (show_advanced)
2949         show_help_options(options, "Advanced per-file options:",
2950                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2951
2952     show_help_options(options, "Video options:",
2953                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2954     if (show_advanced)
2955         show_help_options(options, "Advanced Video options:",
2956                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2957
2958     show_help_options(options, "Audio options:",
2959                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2960     if (show_advanced)
2961         show_help_options(options, "Advanced Audio options:",
2962                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2963     show_help_options(options, "Subtitle options:",
2964                       OPT_SUBTITLE, 0, 0);
2965     printf("\n");
2966
2967     if (show_avoptions) {
2968         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2969         show_help_children(avcodec_get_class(), flags);
2970         show_help_children(avformat_get_class(), flags);
2971 #if CONFIG_SWSCALE
2972         show_help_children(sws_get_class(), flags);
2973 #endif
2974         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2975         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2976     }
2977 }
2978
2979 void show_usage(void)
2980 {
2981     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2982     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2983     av_log(NULL, AV_LOG_INFO, "\n");
2984 }
2985
2986 enum OptGroup {
2987     GROUP_OUTFILE,
2988     GROUP_INFILE,
2989 };
2990
2991 static const OptionGroupDef groups[] = {
2992     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2993     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2994 };
2995
2996 static int open_files(OptionGroupList *l, const char *inout,
2997                       int (*open_file)(OptionsContext*, const char*))
2998 {
2999     int i, ret;
3000
3001     for (i = 0; i < l->nb_groups; i++) {
3002         OptionGroup *g = &l->groups[i];
3003         OptionsContext o;
3004
3005         init_options(&o);
3006         o.g = g;
3007
3008         ret = parse_optgroup(&o, g);
3009         if (ret < 0) {
3010             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3011                    "%s.\n", inout, g->arg);
3012             return ret;
3013         }
3014
3015         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3016         ret = open_file(&o, g->arg);
3017         uninit_options(&o);
3018         if (ret < 0) {
3019             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3020                    inout, g->arg);
3021             return ret;
3022         }
3023         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3024     }
3025
3026     return 0;
3027 }
3028
3029 int ffmpeg_parse_options(int argc, char **argv)
3030 {
3031     OptionParseContext octx;
3032     uint8_t error[128];
3033     int ret;
3034
3035     memset(&octx, 0, sizeof(octx));
3036
3037     /* split the commandline into an internal representation */
3038     ret = split_commandline(&octx, argc, argv, options, groups,
3039                             FF_ARRAY_ELEMS(groups));
3040     if (ret < 0) {
3041         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3042         goto fail;
3043     }
3044
3045     /* apply global options */
3046     ret = parse_optgroup(NULL, &octx.global_opts);
3047     if (ret < 0) {
3048         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3049         goto fail;
3050     }
3051
3052     /* open input files */
3053     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3054     if (ret < 0) {
3055         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3056         goto fail;
3057     }
3058
3059     /* create the complex filtergraphs */
3060     ret = init_complex_filters();
3061     if (ret < 0) {
3062         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3063         goto fail;
3064     }
3065
3066     /* open output files */
3067     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3068     if (ret < 0) {
3069         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3070         goto fail;
3071     }
3072
3073     /* configure the complex filtergraphs */
3074     ret = configure_complex_filters();
3075     if (ret < 0) {
3076         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3077         goto fail;
3078     }
3079
3080 fail:
3081     uninit_parse_context(&octx);
3082     if (ret < 0) {
3083         av_strerror(ret, error, sizeof(error));
3084         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3085     }
3086     return ret;
3087 }
3088
3089 static int opt_progress(void *optctx, const char *opt, const char *arg)
3090 {
3091     AVIOContext *avio = NULL;
3092     int ret;
3093
3094     if (!strcmp(arg, "-"))
3095         arg = "pipe:";
3096     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3097     if (ret < 0) {
3098         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3099                arg, av_err2str(ret));
3100         return ret;
3101     }
3102     progress_avio = avio;
3103     return 0;
3104 }
3105
3106 #define OFFSET(x) offsetof(OptionsContext, x)
3107 const OptionDef options[] = {
3108     /* main options */
3109 #include "cmdutils_common_opts.h"
3110     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3111                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3112         "force format", "fmt" },
3113     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3114         "overwrite output files" },
3115     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3116         "never overwrite output files" },
3117     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3118         "Ignore unknown stream types" },
3119     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3120         "Copy unknown stream types" },
3121     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3122                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3123         "codec name", "codec" },
3124     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3125                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3126         "codec name", "codec" },
3127     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3128                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3129         "preset name", "preset" },
3130     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3131                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3132         "set input stream mapping",
3133         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3134     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3135         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3136     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3137                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3138         "set metadata information of outfile from infile",
3139         "outfile[,metadata]:infile[,metadata]" },
3140     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3141                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3142         "set chapters mapping", "input_file_index" },
3143     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3144                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3145         "record or transcode \"duration\" seconds of audio/video",
3146         "duration" },
3147     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3148         "record or transcode stop time", "time_stop" },
3149     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3150         "set the limit file size in bytes", "limit_size" },
3151     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3152                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3153         "set the start time offset", "time_off" },
3154     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3155                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3156         "set the start time offset relative to EOF", "time_off" },
3157     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3158                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3159         "enable/disable seeking by timestamp with -ss" },
3160     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3161                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3162         "enable/disable accurate seeking with -ss" },
3163     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3164                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3165         "set the input ts offset", "time_off" },
3166     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3167                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3168         "set the input ts scale", "scale" },
3169     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3170         "set the recording timestamp ('now' to set the current time)", "time" },
3171     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3172         "add metadata", "string=string" },
3173     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3174         "add program with specified streams", "title=string:st=number..." },
3175     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3176                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3177         "set the number of data frames to output", "number" },
3178     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3179         "add timings for benchmarking" },
3180     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3181       "add timings for each task" },
3182     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3183       "write program-readable progress information", "url" },
3184     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3185       "enable or disable interaction on standard input" },
3186     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3187         "set max runtime in seconds", "limit" },
3188     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3189         "dump each input packet" },
3190     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3191         "when dumping packets, also dump the payload" },
3192     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3193                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3194         "read input at native frame rate", "" },
3195     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3196         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3197         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3198     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3199         "video sync method", "" },
3200     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3201         "frame drop threshold", "" },
3202     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3203         "audio sync method", "" },
3204     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3205         "audio drift threshold", "threshold" },
3206     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3207         "copy timestamps" },
3208     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3209         "shift input timestamps to start at 0 when using copyts" },
3210     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3211         "copy input stream time base when stream copying", "mode" },
3212     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3213                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3214         "finish encoding within shortest input" },
3215     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3216                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3217         "audio pad", "" },
3218     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3219         "timestamp discontinuity delta threshold", "threshold" },
3220     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3221         "timestamp error delta threshold", "threshold" },
3222     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3223         "exit on error", "error" },
3224     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3225         "abort on the specified condition flags", "flags" },
3226     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3227                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3228         "copy initial non-keyframes" },
3229     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3230         "copy or discard frames before start time" },
3231     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3232         "set the number of frames to output", "number" },
3233     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3234                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3235         "force codec tag/fourcc", "fourcc/tag" },
3236     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3237                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3238         "use fixed quality scale (VBR)", "q" },
3239     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3240                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3241         "use fixed quality scale (VBR)", "q" },
3242     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3243         "set profile", "profile" },
3244     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3245         "set stream filtergraph", "filter_graph" },
3246     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3247         "read stream filtergraph description from a file", "filename" },
3248     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3249         "reinit filtergraph on input parameter changes", "" },
3250     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3251         "create a complex filtergraph", "graph_description" },
3252     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3253         "create a complex filtergraph", "graph_description" },
3254     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3255         "read complex filtergraph description from a file", "filename" },
3256     { "stats",          OPT_BOOL,                                    { &print_stats },
3257         "print progress report during encoding", },
3258     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3259                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3260         "add an attachment to the output file", "filename" },
3261     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3262                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3263         "extract an attachment into a file", "filename" },
3264     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3265                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3266     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3267         "print timestamp debugging info" },
3268     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3269         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3270     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3271                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3272         "discard", "" },
3273     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3274                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3275         "disposition", "" },
3276     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3277                                                                      { .off = OFFSET(thread_queue_size) },
3278         "set the maximum number of queued packets from the demuxer" },
3279
3280     /* video options */
3281     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3282         "set the number of video frames to output", "number" },
3283     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3284                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3285         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3286     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3287                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3288         "set frame size (WxH or abbreviation)", "size" },
3289     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3290                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3291         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3292     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3293                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3294         "set pixel format", "format" },
3295     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3296         "set the number of bits per raw sample", "number" },
3297     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3298         "deprecated use -g 1" },
3299     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3300         "disable video" },
3301     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3302                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3303         "rate control override for specific intervals", "override" },
3304     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3305                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3306         "force video codec ('copy' to copy stream)", "codec" },
3307     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3308         "Removed" },
3309     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3310         "Removed" },
3311     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3312         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3313     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3314         "select the pass number (1 to 3)", "n" },
3315     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3316                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3317         "select two pass log file name prefix", "prefix" },
3318     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3319         "this option is deprecated, use the yadif filter instead" },
3320     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3321         "calculate PSNR of compressed frames" },
3322     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3323         "dump video coding statistics to file" },
3324     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3325         "dump video coding statistics to file", "file" },
3326     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3327         "set video filters", "filter_graph" },
3328     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3329                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3330         "specify intra matrix coeffs", "matrix" },
3331     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3332                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3333         "specify inter matrix coeffs", "matrix" },
3334     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3335                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3336         "specify intra matrix coeffs", "matrix" },
3337     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3338                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3339         "top=1/bottom=0/auto=-1 field first", "" },
3340     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3341                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3342         "force video tag/fourcc", "fourcc/tag" },
3343     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3344         "show QP histogram" },
3345     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3346                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3347         "force the selected framerate, disable the best supported framerate selection" },
3348     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3349                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3350         "set the value of an outfile streamid", "streamIndex:value" },
3351     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3352                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3353         "force key frames at specified timestamps", "timestamps" },
3354     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3355         "audio bitrate (please use -b:a)", "bitrate" },
3356     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3357         "video bitrate (please use -b:v)", "bitrate" },
3358     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3359                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3360         "use HW accelerated decoding", "hwaccel name" },
3361     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3362                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3363         "select a device for HW acceleration", "devicename" },
3364 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3365     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3366 #endif
3367     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3368         "show available HW acceleration methods" },
3369     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3370                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3371         "automatically insert correct rotate filters" },
3372
3373     /* audio options */
3374     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3375         "set the number of audio frames to output", "number" },
3376     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3377         "set audio quality (codec-specific)", "quality", },
3378     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3379                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3380         "set audio sampling rate (in Hz)", "rate" },
3381     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3382                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3383         "set number of audio channels", "channels" },
3384     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3385         "disable audio" },
3386     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3387                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3388         "force audio codec ('copy' to copy stream)", "codec" },
3389     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3390                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3391         "force audio tag/fourcc", "fourcc/tag" },
3392     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3393         "change audio volume (256=normal)" , "volume" },
3394     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3395                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3396         "set sample format", "format" },
3397     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3398                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3399         "set channel layout", "layout" },
3400     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3401         "set audio filters", "filter_graph" },
3402     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3403       "set the maximum number of channels to try to guess the channel layout" },
3404
3405     /* subtitle options */
3406     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3407         "disable subtitle" },
3408     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3409         "force subtitle codec ('copy' to copy stream)", "codec" },
3410     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3411         , "force subtitle tag/fourcc", "fourcc/tag" },
3412     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3413         "fix subtitles duration" },
3414     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3415         "set canvas size (WxH or abbreviation)", "size" },
3416
3417     /* grab options */
3418     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3419         "deprecated, use -channel", "channel" },
3420     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3421         "deprecated, use -standard", "standard" },
3422     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3423
3424     /* muxer options */
3425     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3426         "set the maximum demux-decode delay", "seconds" },
3427     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3428         "set the initial demux-decode delay", "seconds" },
3429     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3430         "override the options from ffserver", "" },
3431     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3432         "specify a file in which to print sdp information", "file" },
3433
3434     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3435         "A comma-separated list of bitstream filters", "bitstream_filters" },
3436     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3437         "deprecated", "audio bitstream_filters" },
3438     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3439         "deprecated", "video bitstream_filters" },
3440
3441     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3442         "set the audio options to the indicated preset", "preset" },
3443     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3444         "set the video options to the indicated preset", "preset" },
3445     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3446         "set the subtitle options to the indicated preset", "preset" },
3447     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3448         "set options from indicated preset file", "filename" },
3449     /* data codec support */
3450     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3451         "force data codec ('copy' to copy stream)", "codec" },
3452     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3453         "disable data" },
3454
3455     { NULL, },
3456 };