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         av_dict_set(&ost->bsf_args, bsfc->filter->name, arg, 0);
1259
1260         bsfc_prev = bsfc;
1261         bsf       = next;
1262     }
1263
1264     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1265     if (codec_tag) {
1266         uint32_t tag = strtol(codec_tag, &next, 0);
1267         if (*next)
1268             tag = AV_RL32(codec_tag);
1269         ost->st->codec->codec_tag =
1270         ost->enc_ctx->codec_tag = tag;
1271     }
1272
1273     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1274     if (qscale >= 0) {
1275         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1276         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1277     }
1278
1279     MATCH_PER_STREAM_OPT(disposition, str, ost->disposition, oc, st);
1280     ost->disposition = av_strdup(ost->disposition);
1281
1282     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1283         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1284
1285     av_dict_copy(&ost->sws_dict, o->g->sws_dict, 0);
1286
1287     av_dict_copy(&ost->swr_opts, o->g->swr_opts, 0);
1288     if (ost->enc && av_get_exact_bits_per_sample(ost->enc->id) == 24)
1289         av_dict_set(&ost->swr_opts, "output_sample_bits", "24", 0);
1290
1291     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1292
1293     ost->source_index = source_index;
1294     if (source_index >= 0) {
1295         ost->sync_ist = input_streams[source_index];
1296         input_streams[source_index]->discard = 0;
1297         input_streams[source_index]->st->discard = input_streams[source_index]->user_set_discard;
1298     }
1299     ost->last_mux_dts = AV_NOPTS_VALUE;
1300
1301     return ost;
1302 }
1303
1304 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1305 {
1306     int i;
1307     const char *p = str;
1308     for (i = 0;; i++) {
1309         dest[i] = atoi(p);
1310         if (i == 63)
1311             break;
1312         p = strchr(p, ',');
1313         if (!p) {
1314             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1315             exit_program(1);
1316         }
1317         p++;
1318     }
1319 }
1320
1321 /* read file contents into a string */
1322 static uint8_t *read_file(const char *filename)
1323 {
1324     AVIOContext *pb      = NULL;
1325     AVIOContext *dyn_buf = NULL;
1326     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1327     uint8_t buf[1024], *str;
1328
1329     if (ret < 0) {
1330         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1331         return NULL;
1332     }
1333
1334     ret = avio_open_dyn_buf(&dyn_buf);
1335     if (ret < 0) {
1336         avio_closep(&pb);
1337         return NULL;
1338     }
1339     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1340         avio_write(dyn_buf, buf, ret);
1341     avio_w8(dyn_buf, 0);
1342     avio_closep(&pb);
1343
1344     ret = avio_close_dyn_buf(dyn_buf, &str);
1345     if (ret < 0)
1346         return NULL;
1347     return str;
1348 }
1349
1350 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1351                              OutputStream *ost)
1352 {
1353     AVStream *st = ost->st;
1354
1355     if (ost->filters_script && ost->filters) {
1356         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1357                "output stream #%d:%d.\n", nb_output_files, st->index);
1358         exit_program(1);
1359     }
1360
1361     if (ost->filters_script)
1362         return read_file(ost->filters_script);
1363     else if (ost->filters)
1364         return av_strdup(ost->filters);
1365
1366     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
1367                      "null" : "anull");
1368 }
1369
1370 static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc,
1371                                      const OutputStream *ost, enum AVMediaType type)
1372 {
1373     if (ost->filters_script || ost->filters) {
1374         av_log(NULL, AV_LOG_ERROR,
1375                "%s '%s' was defined for %s output stream %d:%d but codec copy was selected.\n"
1376                "Filtering and streamcopy cannot be used together.\n",
1377                ost->filters ? "Filtergraph" : "Filtergraph script",
1378                ost->filters ? ost->filters : ost->filters_script,
1379                av_get_media_type_string(type), ost->file_index, ost->index);
1380         exit_program(1);
1381     }
1382 }
1383
1384 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1385 {
1386     AVStream *st;
1387     OutputStream *ost;
1388     AVCodecContext *video_enc;
1389     char *frame_rate = NULL, *frame_aspect_ratio = NULL;
1390
1391     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
1392     st  = ost->st;
1393     video_enc = ost->enc_ctx;
1394
1395     MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1396     if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1397         av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1398         exit_program(1);
1399     }
1400     if (frame_rate && video_sync_method == VSYNC_PASSTHROUGH)
1401         av_log(NULL, AV_LOG_ERROR, "Using -vsync 0 and -r can produce invalid output files\n");
1402
1403     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1404     if (frame_aspect_ratio) {
1405         AVRational q;
1406         if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
1407             q.num <= 0 || q.den <= 0) {
1408             av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
1409             exit_program(1);
1410         }
1411         ost->frame_aspect_ratio = q;
1412     }
1413
1414     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1415     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1416
1417     if (!ost->stream_copy) {
1418         const char *p = NULL;
1419         char *frame_size = NULL;
1420         char *frame_pix_fmt = NULL;
1421         char *intra_matrix = NULL, *inter_matrix = NULL;
1422         char *chroma_intra_matrix = NULL;
1423         int do_pass = 0;
1424         int i;
1425
1426         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1427         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1428             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1429             exit_program(1);
1430         }
1431
1432         video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
1433         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1434         if (frame_pix_fmt && *frame_pix_fmt == '+') {
1435             ost->keep_pix_fmt = 1;
1436             if (!*++frame_pix_fmt)
1437                 frame_pix_fmt = NULL;
1438         }
1439         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1440             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1441             exit_program(1);
1442         }
1443         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1444
1445         if (intra_only)
1446             video_enc->gop_size = 0;
1447         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1448         if (intra_matrix) {
1449             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1450                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1451                 exit_program(1);
1452             }
1453             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1454         }
1455         MATCH_PER_STREAM_OPT(chroma_intra_matrices, str, chroma_intra_matrix, oc, st);
1456         if (chroma_intra_matrix) {
1457             uint16_t *p = av_mallocz(sizeof(*video_enc->chroma_intra_matrix) * 64);
1458             if (!p) {
1459                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1460                 exit_program(1);
1461             }
1462             av_codec_set_chroma_intra_matrix(video_enc, p);
1463             parse_matrix_coeffs(p, chroma_intra_matrix);
1464         }
1465         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1466         if (inter_matrix) {
1467             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1468                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1469                 exit_program(1);
1470             }
1471             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1472         }
1473
1474         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1475         for (i = 0; p; i++) {
1476             int start, end, q;
1477             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1478             if (e != 3) {
1479                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1480                 exit_program(1);
1481             }
1482             video_enc->rc_override =
1483                 av_realloc_array(video_enc->rc_override,
1484                                  i + 1, sizeof(RcOverride));
1485             if (!video_enc->rc_override) {
1486                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1487                 exit_program(1);
1488             }
1489             video_enc->rc_override[i].start_frame = start;
1490             video_enc->rc_override[i].end_frame   = end;
1491             if (q > 0) {
1492                 video_enc->rc_override[i].qscale         = q;
1493                 video_enc->rc_override[i].quality_factor = 1.0;
1494             }
1495             else {
1496                 video_enc->rc_override[i].qscale         = 0;
1497                 video_enc->rc_override[i].quality_factor = -q/100.0;
1498             }
1499             p = strchr(p, '/');
1500             if (p) p++;
1501         }
1502         video_enc->rc_override_count = i;
1503
1504         if (do_psnr)
1505             video_enc->flags|= AV_CODEC_FLAG_PSNR;
1506
1507         /* two pass mode */
1508         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1509         if (do_pass) {
1510             if (do_pass & 1) {
1511                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1512                 av_dict_set(&ost->encoder_opts, "flags", "+pass1", AV_DICT_APPEND);
1513             }
1514             if (do_pass & 2) {
1515                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1516                 av_dict_set(&ost->encoder_opts, "flags", "+pass2", AV_DICT_APPEND);
1517             }
1518         }
1519
1520         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1521         if (ost->logfile_prefix &&
1522             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1523             exit_program(1);
1524
1525         if (do_pass) {
1526             char logfilename[1024];
1527             FILE *f;
1528
1529             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1530                      ost->logfile_prefix ? ost->logfile_prefix :
1531                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1532                      i);
1533             if (!strcmp(ost->enc->name, "libx264")) {
1534                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1535             } else {
1536                 if (video_enc->flags & AV_CODEC_FLAG_PASS2) {
1537                     char  *logbuffer = read_file(logfilename);
1538
1539                     if (!logbuffer) {
1540                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1541                                logfilename);
1542                         exit_program(1);
1543                     }
1544                     video_enc->stats_in = logbuffer;
1545                 }
1546                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1547                     f = av_fopen_utf8(logfilename, "wb");
1548                     if (!f) {
1549                         av_log(NULL, AV_LOG_FATAL,
1550                                "Cannot write log file '%s' for pass-1 encoding: %s\n",
1551                                logfilename, strerror(errno));
1552                         exit_program(1);
1553                     }
1554                     ost->logfile = f;
1555                 }
1556             }
1557         }
1558
1559         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1560         if (ost->forced_keyframes)
1561             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1562
1563         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1564
1565         ost->top_field_first = -1;
1566         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1567
1568
1569         ost->avfilter = get_ost_filters(o, oc, ost);
1570         if (!ost->avfilter)
1571             exit_program(1);
1572     } else {
1573         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1574     }
1575
1576     if (ost->stream_copy)
1577         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_VIDEO);
1578
1579     return ost;
1580 }
1581
1582 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1583 {
1584     int n;
1585     AVStream *st;
1586     OutputStream *ost;
1587     AVCodecContext *audio_enc;
1588
1589     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
1590     st  = ost->st;
1591
1592     audio_enc = ost->enc_ctx;
1593     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1594
1595     MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st);
1596     MATCH_PER_STREAM_OPT(filters,        str, ost->filters,        oc, st);
1597
1598     if (!ost->stream_copy) {
1599         char *sample_fmt = NULL;
1600
1601         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1602
1603         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1604         if (sample_fmt &&
1605             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1606             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1607             exit_program(1);
1608         }
1609
1610         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1611
1612         MATCH_PER_STREAM_OPT(apad, str, ost->apad, oc, st);
1613         ost->apad = av_strdup(ost->apad);
1614
1615         ost->avfilter = get_ost_filters(o, oc, ost);
1616         if (!ost->avfilter)
1617             exit_program(1);
1618
1619         /* check for channel mapping for this audio stream */
1620         for (n = 0; n < o->nb_audio_channel_maps; n++) {
1621             AudioChannelMap *map = &o->audio_channel_maps[n];
1622             if ((map->ofile_idx   == -1 || ost->file_index == map->ofile_idx) &&
1623                 (map->ostream_idx == -1 || ost->st->index  == map->ostream_idx)) {
1624                 InputStream *ist;
1625
1626                 if (map->channel_idx == -1) {
1627                     ist = NULL;
1628                 } else if (ost->source_index < 0) {
1629                     av_log(NULL, AV_LOG_FATAL, "Cannot determine input stream for channel mapping %d.%d\n",
1630                            ost->file_index, ost->st->index);
1631                     continue;
1632                 } else {
1633                     ist = input_streams[ost->source_index];
1634                 }
1635
1636                 if (!ist || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) {
1637                     if (av_reallocp_array(&ost->audio_channels_map,
1638                                           ost->audio_channels_mapped + 1,
1639                                           sizeof(*ost->audio_channels_map)
1640                                           ) < 0 )
1641                         exit_program(1);
1642
1643                     ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
1644                 }
1645             }
1646         }
1647     }
1648
1649     if (ost->stream_copy)
1650         check_streamcopy_filters(o, oc, ost, AVMEDIA_TYPE_AUDIO);
1651
1652     return ost;
1653 }
1654
1655 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1656 {
1657     OutputStream *ost;
1658
1659     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
1660     if (!ost->stream_copy) {
1661         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1662         exit_program(1);
1663     }
1664
1665     return ost;
1666 }
1667
1668 static OutputStream *new_unknown_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1669 {
1670     OutputStream *ost;
1671
1672     ost = new_output_stream(o, oc, AVMEDIA_TYPE_UNKNOWN, source_index);
1673     if (!ost->stream_copy) {
1674         av_log(NULL, AV_LOG_FATAL, "Unknown stream encoding not supported yet (only streamcopy)\n");
1675         exit_program(1);
1676     }
1677
1678     return ost;
1679 }
1680
1681 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1682 {
1683     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
1684     ost->stream_copy = 1;
1685     ost->finished    = 1;
1686     return ost;
1687 }
1688
1689 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
1690 {
1691     AVStream *st;
1692     OutputStream *ost;
1693     AVCodecContext *subtitle_enc;
1694
1695     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
1696     st  = ost->st;
1697     subtitle_enc = ost->enc_ctx;
1698
1699     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1700
1701     MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
1702
1703     if (!ost->stream_copy) {
1704         char *frame_size = NULL;
1705
1706         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1707         if (frame_size && av_parse_video_size(&subtitle_enc->width, &subtitle_enc->height, frame_size) < 0) {
1708             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1709             exit_program(1);
1710         }
1711     }
1712
1713     return ost;
1714 }
1715
1716 /* arg format is "output-stream-index:streamid-value". */
1717 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1718 {
1719     OptionsContext *o = optctx;
1720     int idx;
1721     char *p;
1722     char idx_str[16];
1723
1724     av_strlcpy(idx_str, arg, sizeof(idx_str));
1725     p = strchr(idx_str, ':');
1726     if (!p) {
1727         av_log(NULL, AV_LOG_FATAL,
1728                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1729                arg, opt);
1730         exit_program(1);
1731     }
1732     *p++ = '\0';
1733     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
1734     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1735     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1736     return 0;
1737 }
1738
1739 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1740 {
1741     AVFormatContext *is = ifile->ctx;
1742     AVFormatContext *os = ofile->ctx;
1743     AVChapter **tmp;
1744     int i;
1745
1746     tmp = av_realloc_f(os->chapters, is->nb_chapters + os->nb_chapters, sizeof(*os->chapters));
1747     if (!tmp)
1748         return AVERROR(ENOMEM);
1749     os->chapters = tmp;
1750
1751     for (i = 0; i < is->nb_chapters; i++) {
1752         AVChapter *in_ch = is->chapters[i], *out_ch;
1753         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1754         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1755                                        AV_TIME_BASE_Q, in_ch->time_base);
1756         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1757                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1758
1759
1760         if (in_ch->end < ts_off)
1761             continue;
1762         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1763             break;
1764
1765         out_ch = av_mallocz(sizeof(AVChapter));
1766         if (!out_ch)
1767             return AVERROR(ENOMEM);
1768
1769         out_ch->id        = in_ch->id;
1770         out_ch->time_base = in_ch->time_base;
1771         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1772         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1773
1774         if (copy_metadata)
1775             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1776
1777         os->chapters[os->nb_chapters++] = out_ch;
1778     }
1779     return 0;
1780 }
1781
1782 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
1783 {
1784     int i, err;
1785     AVFormatContext *ic = avformat_alloc_context();
1786
1787     ic->interrupt_callback = int_cb;
1788     err = avformat_open_input(&ic, filename, NULL, NULL);
1789     if (err < 0)
1790         return err;
1791     /* copy stream format */
1792     for(i=0;i<ic->nb_streams;i++) {
1793         AVStream *st;
1794         OutputStream *ost;
1795         AVCodec *codec;
1796         const char *enc_config;
1797
1798         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
1799         if (!codec) {
1800             av_log(s, AV_LOG_ERROR, "no encoder found for codec id %i\n", ic->streams[i]->codec->codec_id);
1801             return AVERROR(EINVAL);
1802         }
1803         if (codec->type == AVMEDIA_TYPE_AUDIO)
1804             opt_audio_codec(o, "c:a", codec->name);
1805         else if (codec->type == AVMEDIA_TYPE_VIDEO)
1806             opt_video_codec(o, "c:v", codec->name);
1807         ost   = new_output_stream(o, s, codec->type, -1);
1808         st    = ost->st;
1809
1810         avcodec_get_context_defaults3(st->codec, codec);
1811         enc_config = av_stream_get_recommended_encoder_configuration(ic->streams[i]);
1812         if (enc_config) {
1813             AVDictionary *opts = NULL;
1814             av_dict_parse_string(&opts, enc_config, "=", ",", 0);
1815             av_opt_set_dict2(st->codec, &opts, AV_OPT_SEARCH_CHILDREN);
1816             av_dict_free(&opts);
1817         }
1818
1819         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
1820             choose_sample_fmt(st, codec);
1821         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
1822             choose_pixel_fmt(st, st->codec, codec, st->codec->pix_fmt);
1823         avcodec_copy_context(ost->enc_ctx, st->codec);
1824         if (enc_config)
1825             av_dict_parse_string(&ost->encoder_opts, enc_config, "=", ",", 0);
1826     }
1827
1828     avformat_close_input(&ic);
1829     return err;
1830 }
1831
1832 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1833                                AVFormatContext *oc)
1834 {
1835     OutputStream *ost;
1836
1837     switch (ofilter->type) {
1838     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
1839     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
1840     default:
1841         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1842                "currently.\n");
1843         exit_program(1);
1844     }
1845
1846     ost->source_index = -1;
1847     ost->filter       = ofilter;
1848
1849     ofilter->ost      = ost;
1850
1851     if (ost->stream_copy) {
1852         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1853                "which is fed from a complex filtergraph. Filtering and streamcopy "
1854                "cannot be used together.\n", ost->file_index, ost->index);
1855         exit_program(1);
1856     }
1857
1858     if (ost->avfilter && (ost->filters || ost->filters_script)) {
1859         const char *opt = ost->filters ? "-vf/-af/-filter" : "-filter_script";
1860         av_log(NULL, AV_LOG_ERROR,
1861                "%s '%s' was specified through the %s option "
1862                "for output stream %d:%d, which is fed from a complex filtergraph.\n"
1863                "%s and -filter_complex cannot be used together for the same stream.\n",
1864                ost->filters ? "Filtergraph" : "Filtergraph script",
1865                ost->filters ? ost->filters : ost->filters_script,
1866                opt, ost->file_index, ost->index, opt);
1867         exit_program(1);
1868     }
1869
1870     avfilter_inout_free(&ofilter->out_tmp);
1871 }
1872
1873 static int init_complex_filters(void)
1874 {
1875     int i, ret = 0;
1876
1877     for (i = 0; i < nb_filtergraphs; i++) {
1878         ret = init_complex_filtergraph(filtergraphs[i]);
1879         if (ret < 0)
1880             return ret;
1881     }
1882     return 0;
1883 }
1884
1885 static int configure_complex_filters(void)
1886 {
1887     int i, ret = 0;
1888
1889     for (i = 0; i < nb_filtergraphs; i++)
1890         if (!filtergraphs[i]->graph &&
1891             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1892             return ret;
1893     return 0;
1894 }
1895
1896 static int open_output_file(OptionsContext *o, const char *filename)
1897 {
1898     AVFormatContext *oc;
1899     int i, j, err;
1900     AVOutputFormat *file_oformat;
1901     OutputFile *of;
1902     OutputStream *ost;
1903     InputStream  *ist;
1904     AVDictionary *unused_opts = NULL;
1905     AVDictionaryEntry *e = NULL;
1906
1907
1908     if (o->stop_time != INT64_MAX && o->recording_time != INT64_MAX) {
1909         o->stop_time = INT64_MAX;
1910         av_log(NULL, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1911     }
1912
1913     if (o->stop_time != INT64_MAX && o->recording_time == INT64_MAX) {
1914         int64_t start_time = o->start_time == AV_NOPTS_VALUE ? 0 : o->start_time;
1915         if (o->stop_time <= start_time) {
1916             av_log(NULL, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1917             exit_program(1);
1918         } else {
1919             o->recording_time = o->stop_time - start_time;
1920         }
1921     }
1922
1923     GROW_ARRAY(output_files, nb_output_files);
1924     of = av_mallocz(sizeof(*of));
1925     if (!of)
1926         exit_program(1);
1927     output_files[nb_output_files - 1] = of;
1928
1929     of->ost_index      = nb_output_streams;
1930     of->recording_time = o->recording_time;
1931     of->start_time     = o->start_time;
1932     of->limit_filesize = o->limit_filesize;
1933     of->shortest       = o->shortest;
1934     av_dict_copy(&of->opts, o->g->format_opts, 0);
1935
1936     if (!strcmp(filename, "-"))
1937         filename = "pipe:";
1938
1939     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
1940     if (!oc) {
1941         print_error(filename, err);
1942         exit_program(1);
1943     }
1944
1945     of->ctx = oc;
1946     if (o->recording_time != INT64_MAX)
1947         oc->duration = o->recording_time;
1948
1949     file_oformat= oc->oformat;
1950     oc->interrupt_callback = int_cb;
1951
1952     /* create streams for all unlabeled output pads */
1953     for (i = 0; i < nb_filtergraphs; i++) {
1954         FilterGraph *fg = filtergraphs[i];
1955         for (j = 0; j < fg->nb_outputs; j++) {
1956             OutputFilter *ofilter = fg->outputs[j];
1957
1958             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1959                 continue;
1960
1961             switch (ofilter->type) {
1962             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1963             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1964             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1965             }
1966             init_output_filter(ofilter, o, oc);
1967         }
1968     }
1969
1970     /* ffserver seeking with date=... needs a date reference */
1971     if (!strcmp(file_oformat->name, "ffm") &&
1972         av_strstart(filename, "http:", NULL)) {
1973         int err = parse_option(o, "metadata", "creation_time=now", options);
1974         if (err < 0) {
1975             print_error(filename, err);
1976             exit_program(1);
1977         }
1978     }
1979
1980     if (!strcmp(file_oformat->name, "ffm") && !override_ffserver &&
1981         av_strstart(filename, "http:", NULL)) {
1982         int j;
1983         /* special case for files sent to ffserver: we get the stream
1984            parameters from ffserver */
1985         int err = read_ffserver_streams(o, oc, filename);
1986         if (err < 0) {
1987             print_error(filename, err);
1988             exit_program(1);
1989         }
1990         for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
1991             ost = output_streams[j];
1992             for (i = 0; i < nb_input_streams; i++) {
1993                 ist = input_streams[i];
1994                 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
1995                     ost->sync_ist= ist;
1996                     ost->source_index= i;
1997                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
1998                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
1999                     ist->discard = 0;
2000                     ist->st->discard = ist->user_set_discard;
2001                     break;
2002                 }
2003             }
2004             if(!ost->sync_ist){
2005                 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));
2006                 exit_program(1);
2007             }
2008         }
2009     } else if (!o->nb_stream_maps) {
2010         char *subtitle_codec_name = NULL;
2011         /* pick the "best" stream of each type */
2012
2013         /* video: highest resolution */
2014         if (!o->video_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_VIDEO) != AV_CODEC_ID_NONE) {
2015             int area = 0, idx = -1;
2016             int qcr = avformat_query_codec(oc->oformat, oc->oformat->video_codec, 0);
2017             for (i = 0; i < nb_input_streams; i++) {
2018                 int new_area;
2019                 ist = input_streams[i];
2020                 new_area = ist->st->codec->width * ist->st->codec->height + 100000000*!!ist->st->codec_info_nb_frames;
2021                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2022                     new_area = 1;
2023                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
2024                     new_area > area) {
2025                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2026                         continue;
2027                     area = new_area;
2028                     idx = i;
2029                 }
2030             }
2031             if (idx >= 0)
2032                 new_video_stream(o, oc, idx);
2033         }
2034
2035         /* audio: most channels */
2036         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2037             int best_score = 0, idx = -1;
2038             for (i = 0; i < nb_input_streams; i++) {
2039                 int score;
2040                 ist = input_streams[i];
2041                 score = ist->st->codec->channels + 100000000*!!ist->st->codec_info_nb_frames;
2042                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
2043                     score > best_score) {
2044                     best_score = score;
2045                     idx = i;
2046                 }
2047             }
2048             if (idx >= 0)
2049                 new_audio_stream(o, oc, idx);
2050         }
2051
2052         /* subtitles: pick first */
2053         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2054         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2055             for (i = 0; i < nb_input_streams; i++)
2056                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2057                     AVCodecDescriptor const *input_descriptor =
2058                         avcodec_descriptor_get(input_streams[i]->st->codec->codec_id);
2059                     AVCodecDescriptor const *output_descriptor = NULL;
2060                     AVCodec const *output_codec =
2061                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2062                     int input_props = 0, output_props = 0;
2063                     if (output_codec)
2064                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2065                     if (input_descriptor)
2066                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2067                     if (output_descriptor)
2068                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2069                     if (subtitle_codec_name ||
2070                         input_props & output_props ||
2071                         // Map dvb teletext which has neither property to any output subtitle encoder
2072                         input_descriptor && output_descriptor &&
2073                         (!input_descriptor->props ||
2074                          !output_descriptor->props)) {
2075                         new_subtitle_stream(o, oc, i);
2076                         break;
2077                     }
2078                 }
2079         }
2080         /* Data only if codec id match */
2081         if (!o->data_disable ) {
2082             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2083             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2084                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_DATA
2085                     && input_streams[i]->st->codec->codec_id == codec_id )
2086                     new_data_stream(o, oc, i);
2087             }
2088         }
2089     } else {
2090         for (i = 0; i < o->nb_stream_maps; i++) {
2091             StreamMap *map = &o->stream_maps[i];
2092
2093             if (map->disabled)
2094                 continue;
2095
2096             if (map->linklabel) {
2097                 FilterGraph *fg;
2098                 OutputFilter *ofilter = NULL;
2099                 int j, k;
2100
2101                 for (j = 0; j < nb_filtergraphs; j++) {
2102                     fg = filtergraphs[j];
2103                     for (k = 0; k < fg->nb_outputs; k++) {
2104                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2105                         if (out && !strcmp(out->name, map->linklabel)) {
2106                             ofilter = fg->outputs[k];
2107                             goto loop_end;
2108                         }
2109                     }
2110                 }
2111 loop_end:
2112                 if (!ofilter) {
2113                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2114                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2115                     exit_program(1);
2116                 }
2117                 init_output_filter(ofilter, o, oc);
2118             } else {
2119                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2120
2121                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2122                 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
2123                     continue;
2124                 if(o->   audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2125                     continue;
2126                 if(o->   video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2127                     continue;
2128                 if(o->    data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
2129                     continue;
2130
2131                 ost = NULL;
2132                 switch (ist->st->codec->codec_type) {
2133                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2134                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2135                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2136                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2137                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2138                 case AVMEDIA_TYPE_UNKNOWN:
2139                     if (copy_unknown_streams) {
2140                         ost = new_unknown_stream   (o, oc, src_idx);
2141                         break;
2142                     }
2143                 default:
2144                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2145                            "Cannot map stream #%d:%d - unsupported type.\n",
2146                            map->file_index, map->stream_index);
2147                     if (!ignore_unknown_streams) {
2148                         av_log(NULL, AV_LOG_FATAL,
2149                                "If you want unsupported types ignored instead "
2150                                "of failing, please use the -ignore_unknown option\n"
2151                                "If you want them copied, please use -copy_unknown\n");
2152                         exit_program(1);
2153                     }
2154                 }
2155                 if (ost)
2156                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2157                                                   + map->sync_stream_index];
2158             }
2159         }
2160     }
2161
2162     /* handle attached files */
2163     for (i = 0; i < o->nb_attachments; i++) {
2164         AVIOContext *pb;
2165         uint8_t *attachment;
2166         const char *p;
2167         int64_t len;
2168
2169         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2170             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2171                    o->attachments[i]);
2172             exit_program(1);
2173         }
2174         if ((len = avio_size(pb)) <= 0) {
2175             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2176                    o->attachments[i]);
2177             exit_program(1);
2178         }
2179         if (!(attachment = av_malloc(len))) {
2180             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
2181                    o->attachments[i]);
2182             exit_program(1);
2183         }
2184         avio_read(pb, attachment, len);
2185
2186         ost = new_attachment_stream(o, oc, -1);
2187         ost->stream_copy               = 1;
2188         ost->attachment_filename       = o->attachments[i];
2189         ost->finished                  = 1;
2190         ost->st->codec->extradata      = attachment;
2191         ost->st->codec->extradata_size = len;
2192
2193         p = strrchr(o->attachments[i], '/');
2194         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2195         avio_closep(&pb);
2196     }
2197
2198     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2199         AVDictionaryEntry *e;
2200         ost = output_streams[i];
2201
2202         if ((ost->stream_copy || ost->attachment_filename)
2203             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2204             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2205             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2206                 exit_program(1);
2207     }
2208
2209     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2210         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
2211         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2212         exit_program(1);
2213     }
2214
2215     /* check if all codec options have been used */
2216     unused_opts = strip_specifiers(o->g->codec_opts);
2217     for (i = of->ost_index; i < nb_output_streams; i++) {
2218         e = NULL;
2219         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2220                                 AV_DICT_IGNORE_SUFFIX)))
2221             av_dict_set(&unused_opts, e->key, NULL, 0);
2222     }
2223
2224     e = NULL;
2225     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2226         const AVClass *class = avcodec_get_class();
2227         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2228                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2229         const AVClass *fclass = avformat_get_class();
2230         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2231                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2232         if (!option || foption)
2233             continue;
2234
2235
2236         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2237             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2238                    "output file #%d (%s) is not an encoding option.\n", e->key,
2239                    option->help ? option->help : "", nb_output_files - 1,
2240                    filename);
2241             exit_program(1);
2242         }
2243
2244         // gop_timecode is injected by generic code but not always used
2245         if (!strcmp(e->key, "gop_timecode"))
2246             continue;
2247
2248         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2249                "output file #%d (%s) has not been used for any stream. The most "
2250                "likely reason is either wrong type (e.g. a video option with "
2251                "no video streams) or that it is a private option of some encoder "
2252                "which was not actually used for any stream.\n", e->key,
2253                option->help ? option->help : "", nb_output_files - 1, filename);
2254     }
2255     av_dict_free(&unused_opts);
2256
2257     /* set the encoding/decoding_needed flags */
2258     for (i = of->ost_index; i < nb_output_streams; i++) {
2259         OutputStream *ost = output_streams[i];
2260
2261         ost->encoding_needed = !ost->stream_copy;
2262         if (ost->encoding_needed && ost->source_index >= 0) {
2263             InputStream *ist = input_streams[ost->source_index];
2264             ist->decoding_needed |= DECODING_FOR_OST;
2265         }
2266     }
2267
2268     /* check filename in case of an image number is expected */
2269     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2270         if (!av_filename_number_test(oc->filename)) {
2271             print_error(oc->filename, AVERROR(EINVAL));
2272             exit_program(1);
2273         }
2274     }
2275
2276     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2277         av_log(NULL, AV_LOG_ERROR,
2278                "No input streams but output needs an input stream\n");
2279         exit_program(1);
2280     }
2281
2282     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2283         /* test if it already exists to avoid losing precious files */
2284         assert_file_overwrite(filename);
2285
2286         /* open the file */
2287         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2288                               &oc->interrupt_callback,
2289                               &of->opts)) < 0) {
2290             print_error(filename, err);
2291             exit_program(1);
2292         }
2293     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2294         assert_file_overwrite(filename);
2295
2296     if (o->mux_preload) {
2297         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2298     }
2299     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2300
2301     /* copy metadata */
2302     for (i = 0; i < o->nb_metadata_map; i++) {
2303         char *p;
2304         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2305
2306         if (in_file_index >= nb_input_files) {
2307             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2308             exit_program(1);
2309         }
2310         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2311                       in_file_index >= 0 ?
2312                       input_files[in_file_index]->ctx : NULL, o);
2313     }
2314
2315     /* copy chapters */
2316     if (o->chapters_input_file >= nb_input_files) {
2317         if (o->chapters_input_file == INT_MAX) {
2318             /* copy chapters from the first input file that has them*/
2319             o->chapters_input_file = -1;
2320             for (i = 0; i < nb_input_files; i++)
2321                 if (input_files[i]->ctx->nb_chapters) {
2322                     o->chapters_input_file = i;
2323                     break;
2324                 }
2325         } else {
2326             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2327                    o->chapters_input_file);
2328             exit_program(1);
2329         }
2330     }
2331     if (o->chapters_input_file >= 0)
2332         copy_chapters(input_files[o->chapters_input_file], of,
2333                       !o->metadata_chapters_manual);
2334
2335     /* copy global metadata by default */
2336     if (!o->metadata_global_manual && nb_input_files){
2337         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2338                      AV_DICT_DONT_OVERWRITE);
2339         if(o->recording_time != INT64_MAX)
2340             av_dict_set(&oc->metadata, "duration", NULL, 0);
2341         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2342     }
2343     if (!o->metadata_streams_manual)
2344         for (i = of->ost_index; i < nb_output_streams; i++) {
2345             InputStream *ist;
2346             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2347                 continue;
2348             ist = input_streams[output_streams[i]->source_index];
2349             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2350             if (!output_streams[i]->stream_copy) {
2351                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2352                 if (ist->autorotate)
2353                     av_dict_set(&output_streams[i]->st->metadata, "rotate", NULL, 0);
2354             }
2355         }
2356
2357     /* process manually set metadata */
2358     for (i = 0; i < o->nb_metadata; i++) {
2359         AVDictionary **m;
2360         char type, *val;
2361         const char *stream_spec;
2362         int index = 0, j, ret = 0;
2363         char now_time[256];
2364
2365         val = strchr(o->metadata[i].u.str, '=');
2366         if (!val) {
2367             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2368                    o->metadata[i].u.str);
2369             exit_program(1);
2370         }
2371         *val++ = 0;
2372
2373         if (!strcmp(o->metadata[i].u.str, "creation_time") &&
2374             !strcmp(val, "now")) {
2375             time_t now = time(0);
2376             struct tm *ptm, tmbuf;
2377             ptm = localtime_r(&now, &tmbuf);
2378             if (ptm) {
2379                 if (strftime(now_time, sizeof(now_time), "%Y-%m-%d %H:%M:%S", ptm))
2380                     val = now_time;
2381             }
2382         }
2383
2384         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2385         if (type == 's') {
2386             for (j = 0; j < oc->nb_streams; j++) {
2387                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2388                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2389                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2390                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2391                         ost->rotate_overridden = 1;
2392                     }
2393                 } else if (ret < 0)
2394                     exit_program(1);
2395             }
2396         }
2397         else {
2398             switch (type) {
2399             case 'g':
2400                 m = &oc->metadata;
2401                 break;
2402             case 'c':
2403                 if (index < 0 || index >= oc->nb_chapters) {
2404                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2405                     exit_program(1);
2406                 }
2407                 m = &oc->chapters[index]->metadata;
2408                 break;
2409             default:
2410                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2411                 exit_program(1);
2412             }
2413             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2414         }
2415     }
2416
2417     /* process manually set programs */
2418     for (i = 0; i < o->nb_program; i++) {
2419         const char *p = o->program[i].u.str;
2420         int progid = i+1;
2421         AVProgram *program;
2422
2423         while(*p) {
2424             const char *p2 = av_get_token(&p, ":");
2425             char *key;
2426             if (!p2)
2427                 break;
2428             if(*p) p++;
2429
2430             key = av_get_token(&p2, "=");
2431             if (!key || !*p2)
2432                 break;
2433             p2++;
2434
2435             if (!strcmp(key, "program_num"))
2436                 progid = strtol(p2, NULL, 0);
2437         }
2438
2439         program = av_new_program(oc, progid);
2440
2441         p = o->program[i].u.str;
2442         while(*p) {
2443             const char *p2 = av_get_token(&p, ":");
2444             char *key;
2445             if (!p2)
2446                 break;
2447             if(*p) p++;
2448
2449             key = av_get_token(&p2, "=");
2450             if (!key) {
2451                 av_log(NULL, AV_LOG_FATAL,
2452                        "No '=' character in program string %s.\n",
2453                        p2);
2454                 exit_program(1);
2455             }
2456             if (!*p2)
2457                 exit_program(1);
2458             p2++;
2459
2460             if (!strcmp(key, "title")) {
2461                 av_dict_set(&program->metadata, "title", p2, 0);
2462             } else if (!strcmp(key, "program_num")) {
2463             } else if (!strcmp(key, "st")) {
2464                 int st_num = strtol(p2, NULL, 0);
2465                 av_program_add_stream_index(oc, progid, st_num);
2466             } else {
2467                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2468                 exit_program(1);
2469             }
2470         }
2471     }
2472
2473     return 0;
2474 }
2475
2476 static int opt_target(void *optctx, const char *opt, const char *arg)
2477 {
2478     OptionsContext *o = optctx;
2479     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2480     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2481
2482     if (!strncmp(arg, "pal-", 4)) {
2483         norm = PAL;
2484         arg += 4;
2485     } else if (!strncmp(arg, "ntsc-", 5)) {
2486         norm = NTSC;
2487         arg += 5;
2488     } else if (!strncmp(arg, "film-", 5)) {
2489         norm = FILM;
2490         arg += 5;
2491     } else {
2492         /* Try to determine PAL/NTSC by peeking in the input files */
2493         if (nb_input_files) {
2494             int i, j, fr;
2495             for (j = 0; j < nb_input_files; j++) {
2496                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2497                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
2498                     if (c->codec_type != AVMEDIA_TYPE_VIDEO ||
2499                         !c->time_base.num)
2500                         continue;
2501                     fr = c->time_base.den * 1000 / c->time_base.num;
2502                     if (fr == 25000) {
2503                         norm = PAL;
2504                         break;
2505                     } else if ((fr == 29970) || (fr == 23976)) {
2506                         norm = NTSC;
2507                         break;
2508                     }
2509                 }
2510                 if (norm != UNKNOWN)
2511                     break;
2512             }
2513         }
2514         if (norm != UNKNOWN)
2515             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2516     }
2517
2518     if (norm == UNKNOWN) {
2519         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2520         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2521         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2522         exit_program(1);
2523     }
2524
2525     if (!strcmp(arg, "vcd")) {
2526         opt_video_codec(o, "c:v", "mpeg1video");
2527         opt_audio_codec(o, "c:a", "mp2");
2528         parse_option(o, "f", "vcd", options);
2529
2530         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2531         parse_option(o, "r", frame_rates[norm], options);
2532         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2533
2534         opt_default(NULL, "b:v", "1150000");
2535         opt_default(NULL, "maxrate:v", "1150000");
2536         opt_default(NULL, "minrate:v", "1150000");
2537         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2538
2539         opt_default(NULL, "b:a", "224000");
2540         parse_option(o, "ar", "44100", options);
2541         parse_option(o, "ac", "2", options);
2542
2543         opt_default(NULL, "packetsize", "2324");
2544         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2545
2546         /* We have to offset the PTS, so that it is consistent with the SCR.
2547            SCR starts at 36000, but the first two packs contain only padding
2548            and the first pack from the other stream, respectively, may also have
2549            been written before.
2550            So the real data starts at SCR 36000+3*1200. */
2551         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2552     } else if (!strcmp(arg, "svcd")) {
2553
2554         opt_video_codec(o, "c:v", "mpeg2video");
2555         opt_audio_codec(o, "c:a", "mp2");
2556         parse_option(o, "f", "svcd", options);
2557
2558         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2559         parse_option(o, "r", frame_rates[norm], options);
2560         parse_option(o, "pix_fmt", "yuv420p", options);
2561         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2562
2563         opt_default(NULL, "b:v", "2040000");
2564         opt_default(NULL, "maxrate:v", "2516000");
2565         opt_default(NULL, "minrate:v", "0"); // 1145000;
2566         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2567         opt_default(NULL, "scan_offset", "1");
2568
2569         opt_default(NULL, "b:a", "224000");
2570         parse_option(o, "ar", "44100", options);
2571
2572         opt_default(NULL, "packetsize", "2324");
2573
2574     } else if (!strcmp(arg, "dvd")) {
2575
2576         opt_video_codec(o, "c:v", "mpeg2video");
2577         opt_audio_codec(o, "c:a", "ac3");
2578         parse_option(o, "f", "dvd", options);
2579
2580         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2581         parse_option(o, "r", frame_rates[norm], options);
2582         parse_option(o, "pix_fmt", "yuv420p", options);
2583         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2584
2585         opt_default(NULL, "b:v", "6000000");
2586         opt_default(NULL, "maxrate:v", "9000000");
2587         opt_default(NULL, "minrate:v", "0"); // 1500000;
2588         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2589
2590         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2591         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2592
2593         opt_default(NULL, "b:a", "448000");
2594         parse_option(o, "ar", "48000", options);
2595
2596     } else if (!strncmp(arg, "dv", 2)) {
2597
2598         parse_option(o, "f", "dv", options);
2599
2600         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2601         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2602                           norm == PAL ? "yuv420p" : "yuv411p", options);
2603         parse_option(o, "r", frame_rates[norm], options);
2604
2605         parse_option(o, "ar", "48000", options);
2606         parse_option(o, "ac", "2", options);
2607
2608     } else {
2609         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2610         return AVERROR(EINVAL);
2611     }
2612
2613     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2614     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2615
2616     return 0;
2617 }
2618
2619 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2620 {
2621     av_free (vstats_filename);
2622     vstats_filename = av_strdup (arg);
2623     return 0;
2624 }
2625
2626 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2627 {
2628     char filename[40];
2629     time_t today2 = time(NULL);
2630     struct tm *today = localtime(&today2);
2631
2632     if (!today) { // maybe tomorrow
2633         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2634         exit_program(1);
2635     }
2636
2637     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2638              today->tm_sec);
2639     return opt_vstats_file(NULL, opt, filename);
2640 }
2641
2642 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2643 {
2644     OptionsContext *o = optctx;
2645     return parse_option(o, "frames:v", arg, options);
2646 }
2647
2648 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2649 {
2650     OptionsContext *o = optctx;
2651     return parse_option(o, "frames:a", arg, options);
2652 }
2653
2654 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2655 {
2656     OptionsContext *o = optctx;
2657     return parse_option(o, "frames:d", arg, options);
2658 }
2659
2660 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2661 {
2662     int ret;
2663     AVDictionary *cbak = codec_opts;
2664     AVDictionary *fbak = format_opts;
2665     codec_opts = NULL;
2666     format_opts = NULL;
2667
2668     ret = opt_default(NULL, opt, arg);
2669
2670     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2671     av_dict_copy(&o->g->format_opts, format_opts, 0);
2672     av_dict_free(&codec_opts);
2673     av_dict_free(&format_opts);
2674     codec_opts = cbak;
2675     format_opts = fbak;
2676
2677     return ret;
2678 }
2679
2680 static int opt_preset(void *optctx, const char *opt, const char *arg)
2681 {
2682     OptionsContext *o = optctx;
2683     FILE *f=NULL;
2684     char filename[1000], line[1000], tmp_line[1000];
2685     const char *codec_name = NULL;
2686
2687     tmp_line[0] = *opt;
2688     tmp_line[1] = 0;
2689     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2690
2691     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2692         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2693             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2694         }else
2695             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2696         exit_program(1);
2697     }
2698
2699     while (fgets(line, sizeof(line), f)) {
2700         char *key = tmp_line, *value, *endptr;
2701
2702         if (strcspn(line, "#\n\r") == 0)
2703             continue;
2704         av_strlcpy(tmp_line, line, sizeof(tmp_line));
2705         if (!av_strtok(key,   "=",    &value) ||
2706             !av_strtok(value, "\r\n", &endptr)) {
2707             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
2708             exit_program(1);
2709         }
2710         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
2711
2712         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
2713         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
2714         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
2715         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
2716         else if (opt_default_new(o, key, value) < 0) {
2717             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
2718                    filename, line, key, value);
2719             exit_program(1);
2720         }
2721     }
2722
2723     fclose(f);
2724
2725     return 0;
2726 }
2727
2728 static int opt_old2new(void *optctx, const char *opt, const char *arg)
2729 {
2730     OptionsContext *o = optctx;
2731     char *s = av_asprintf("%s:%c", opt + 1, *opt);
2732     int ret = parse_option(o, s, arg, options);
2733     av_free(s);
2734     return ret;
2735 }
2736
2737 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
2738 {
2739     OptionsContext *o = optctx;
2740
2741     if(!strcmp(opt, "ab")){
2742         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
2743         return 0;
2744     } else if(!strcmp(opt, "b")){
2745         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
2746         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
2747         return 0;
2748     }
2749     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2750     return 0;
2751 }
2752
2753 static int opt_qscale(void *optctx, const char *opt, const char *arg)
2754 {
2755     OptionsContext *o = optctx;
2756     char *s;
2757     int ret;
2758     if(!strcmp(opt, "qscale")){
2759         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
2760         return parse_option(o, "q:v", arg, options);
2761     }
2762     s = av_asprintf("q%s", opt + 6);
2763     ret = parse_option(o, s, arg, options);
2764     av_free(s);
2765     return ret;
2766 }
2767
2768 static int opt_profile(void *optctx, const char *opt, const char *arg)
2769 {
2770     OptionsContext *o = optctx;
2771     if(!strcmp(opt, "profile")){
2772         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
2773         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
2774         return 0;
2775     }
2776     av_dict_set(&o->g->codec_opts, opt, arg, 0);
2777     return 0;
2778 }
2779
2780 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2781 {
2782     OptionsContext *o = optctx;
2783     return parse_option(o, "filter:v", arg, options);
2784 }
2785
2786 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2787 {
2788     OptionsContext *o = optctx;
2789     return parse_option(o, "filter:a", arg, options);
2790 }
2791
2792 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2793 {
2794     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2795     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2796     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2797     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
2798
2799     if (video_sync_method == VSYNC_AUTO)
2800         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2801     return 0;
2802 }
2803
2804 static int opt_timecode(void *optctx, const char *opt, const char *arg)
2805 {
2806     OptionsContext *o = optctx;
2807     char *tcr = av_asprintf("timecode=%s", arg);
2808     int ret = parse_option(o, "metadata:g", tcr, options);
2809     if (ret >= 0)
2810         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
2811     av_free(tcr);
2812     return 0;
2813 }
2814
2815 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2816 {
2817     OptionsContext *o = optctx;
2818     char layout_str[32];
2819     char *stream_str;
2820     char *ac_str;
2821     int ret, channels, ac_str_size;
2822     uint64_t layout;
2823
2824     layout = av_get_channel_layout(arg);
2825     if (!layout) {
2826         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2827         return AVERROR(EINVAL);
2828     }
2829     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2830     ret = opt_default_new(o, opt, layout_str);
2831     if (ret < 0)
2832         return ret;
2833
2834     /* set 'ac' option based on channel layout */
2835     channels = av_get_channel_layout_nb_channels(layout);
2836     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2837     stream_str = strchr(opt, ':');
2838     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2839     ac_str = av_mallocz(ac_str_size);
2840     if (!ac_str)
2841         return AVERROR(ENOMEM);
2842     av_strlcpy(ac_str, "ac", 3);
2843     if (stream_str)
2844         av_strlcat(ac_str, stream_str, ac_str_size);
2845     ret = parse_option(o, ac_str, layout_str, options);
2846     av_free(ac_str);
2847
2848     return ret;
2849 }
2850
2851 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2852 {
2853     OptionsContext *o = optctx;
2854     return parse_option(o, "q:a", arg, options);
2855 }
2856
2857 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2858 {
2859     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2860     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2861         return AVERROR(ENOMEM);
2862     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2863     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2864     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2865         return AVERROR(ENOMEM);
2866
2867     input_stream_potentially_available = 1;
2868
2869     return 0;
2870 }
2871
2872 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2873 {
2874     uint8_t *graph_desc = read_file(arg);
2875     if (!graph_desc)
2876         return AVERROR(EINVAL);
2877
2878     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2879     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2880         return AVERROR(ENOMEM);
2881     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2882     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2883
2884     input_stream_potentially_available = 1;
2885
2886     return 0;
2887 }
2888
2889 void show_help_default(const char *opt, const char *arg)
2890 {
2891     /* per-file options have at least one of those set */
2892     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2893     int show_advanced = 0, show_avoptions = 0;
2894
2895     if (opt && *opt) {
2896         if (!strcmp(opt, "long"))
2897             show_advanced = 1;
2898         else if (!strcmp(opt, "full"))
2899             show_advanced = show_avoptions = 1;
2900         else
2901             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2902     }
2903
2904     show_usage();
2905
2906     printf("Getting help:\n"
2907            "    -h      -- print basic options\n"
2908            "    -h long -- print more options\n"
2909            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2910            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2911            "    See man %s for detailed description of the options.\n"
2912            "\n", program_name);
2913
2914     show_help_options(options, "Print help / information / capabilities:",
2915                       OPT_EXIT, 0, 0);
2916
2917     show_help_options(options, "Global options (affect whole program "
2918                       "instead of just one file:",
2919                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2920     if (show_advanced)
2921         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2922                           per_file | OPT_EXIT, 0);
2923
2924     show_help_options(options, "Per-file main options:", 0,
2925                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2926                       OPT_EXIT, per_file);
2927     if (show_advanced)
2928         show_help_options(options, "Advanced per-file options:",
2929                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2930
2931     show_help_options(options, "Video options:",
2932                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2933     if (show_advanced)
2934         show_help_options(options, "Advanced Video options:",
2935                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2936
2937     show_help_options(options, "Audio options:",
2938                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2939     if (show_advanced)
2940         show_help_options(options, "Advanced Audio options:",
2941                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2942     show_help_options(options, "Subtitle options:",
2943                       OPT_SUBTITLE, 0, 0);
2944     printf("\n");
2945
2946     if (show_avoptions) {
2947         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2948         show_help_children(avcodec_get_class(), flags);
2949         show_help_children(avformat_get_class(), flags);
2950 #if CONFIG_SWSCALE
2951         show_help_children(sws_get_class(), flags);
2952 #endif
2953         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
2954         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
2955     }
2956 }
2957
2958 void show_usage(void)
2959 {
2960     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
2961     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2962     av_log(NULL, AV_LOG_INFO, "\n");
2963 }
2964
2965 enum OptGroup {
2966     GROUP_OUTFILE,
2967     GROUP_INFILE,
2968 };
2969
2970 static const OptionGroupDef groups[] = {
2971     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2972     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2973 };
2974
2975 static int open_files(OptionGroupList *l, const char *inout,
2976                       int (*open_file)(OptionsContext*, const char*))
2977 {
2978     int i, ret;
2979
2980     for (i = 0; i < l->nb_groups; i++) {
2981         OptionGroup *g = &l->groups[i];
2982         OptionsContext o;
2983
2984         init_options(&o);
2985         o.g = g;
2986
2987         ret = parse_optgroup(&o, g);
2988         if (ret < 0) {
2989             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2990                    "%s.\n", inout, g->arg);
2991             return ret;
2992         }
2993
2994         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2995         ret = open_file(&o, g->arg);
2996         uninit_options(&o);
2997         if (ret < 0) {
2998             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2999                    inout, g->arg);
3000             return ret;
3001         }
3002         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3003     }
3004
3005     return 0;
3006 }
3007
3008 int ffmpeg_parse_options(int argc, char **argv)
3009 {
3010     OptionParseContext octx;
3011     uint8_t error[128];
3012     int ret;
3013
3014     memset(&octx, 0, sizeof(octx));
3015
3016     /* split the commandline into an internal representation */
3017     ret = split_commandline(&octx, argc, argv, options, groups,
3018                             FF_ARRAY_ELEMS(groups));
3019     if (ret < 0) {
3020         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3021         goto fail;
3022     }
3023
3024     /* apply global options */
3025     ret = parse_optgroup(NULL, &octx.global_opts);
3026     if (ret < 0) {
3027         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3028         goto fail;
3029     }
3030
3031     /* open input files */
3032     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3033     if (ret < 0) {
3034         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3035         goto fail;
3036     }
3037
3038     /* create the complex filtergraphs */
3039     ret = init_complex_filters();
3040     if (ret < 0) {
3041         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3042         goto fail;
3043     }
3044
3045     /* open output files */
3046     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3047     if (ret < 0) {
3048         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3049         goto fail;
3050     }
3051
3052     /* configure the complex filtergraphs */
3053     ret = configure_complex_filters();
3054     if (ret < 0) {
3055         av_log(NULL, AV_LOG_FATAL, "Error configuring complex filters.\n");
3056         goto fail;
3057     }
3058
3059 fail:
3060     uninit_parse_context(&octx);
3061     if (ret < 0) {
3062         av_strerror(ret, error, sizeof(error));
3063         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3064     }
3065     return ret;
3066 }
3067
3068 static int opt_progress(void *optctx, const char *opt, const char *arg)
3069 {
3070     AVIOContext *avio = NULL;
3071     int ret;
3072
3073     if (!strcmp(arg, "-"))
3074         arg = "pipe:";
3075     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3076     if (ret < 0) {
3077         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3078                arg, av_err2str(ret));
3079         return ret;
3080     }
3081     progress_avio = avio;
3082     return 0;
3083 }
3084
3085 #define OFFSET(x) offsetof(OptionsContext, x)
3086 const OptionDef options[] = {
3087     /* main options */
3088 #include "cmdutils_common_opts.h"
3089     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3090                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3091         "force format", "fmt" },
3092     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3093         "overwrite output files" },
3094     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3095         "never overwrite output files" },
3096     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3097         "Ignore unknown stream types" },
3098     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3099         "Copy unknown stream types" },
3100     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3101                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3102         "codec name", "codec" },
3103     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3104                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3105         "codec name", "codec" },
3106     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3107                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3108         "preset name", "preset" },
3109     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3110                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3111         "set input stream mapping",
3112         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3113     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3114         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3115     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3116                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3117         "set metadata information of outfile from infile",
3118         "outfile[,metadata]:infile[,metadata]" },
3119     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3120                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3121         "set chapters mapping", "input_file_index" },
3122     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3123                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3124         "record or transcode \"duration\" seconds of audio/video",
3125         "duration" },
3126     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3127         "record or transcode stop time", "time_stop" },
3128     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3129         "set the limit file size in bytes", "limit_size" },
3130     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3131                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3132         "set the start time offset", "time_off" },
3133     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3134                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time_eof) },
3135         "set the start time offset relative to EOF", "time_off" },
3136     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3137                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3138         "enable/disable seeking by timestamp with -ss" },
3139     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3140                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3141         "enable/disable accurate seeking with -ss" },
3142     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3143                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3144         "set the input ts offset", "time_off" },
3145     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3146                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3147         "set the input ts scale", "scale" },
3148     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3149         "set the recording timestamp ('now' to set the current time)", "time" },
3150     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3151         "add metadata", "string=string" },
3152     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3153         "add program with specified streams", "title=string:st=number..." },
3154     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3155                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3156         "set the number of data frames to output", "number" },
3157     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3158         "add timings for benchmarking" },
3159     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3160       "add timings for each task" },
3161     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3162       "write program-readable progress information", "url" },
3163     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3164       "enable or disable interaction on standard input" },
3165     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3166         "set max runtime in seconds", "limit" },
3167     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3168         "dump each input packet" },
3169     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3170         "when dumping packets, also dump the payload" },
3171     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3172                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3173         "read input at native frame rate", "" },
3174     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3175         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3176         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3177     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3178         "video sync method", "" },
3179     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3180         "frame drop threshold", "" },
3181     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3182         "audio sync method", "" },
3183     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3184         "audio drift threshold", "threshold" },
3185     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3186         "copy timestamps" },
3187     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3188         "shift input timestamps to start at 0 when using copyts" },
3189     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3190         "copy input stream time base when stream copying", "mode" },
3191     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3192                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3193         "finish encoding within shortest input" },
3194     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3195                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3196         "audio pad", "" },
3197     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3198         "timestamp discontinuity delta threshold", "threshold" },
3199     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3200         "timestamp error delta threshold", "threshold" },
3201     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3202         "exit on error", "error" },
3203     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3204         "abort on the specified condition flags", "flags" },
3205     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3206                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3207         "copy initial non-keyframes" },
3208     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3209         "copy or discard frames before start time" },
3210     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3211         "set the number of frames to output", "number" },
3212     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3213                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3214         "force codec tag/fourcc", "fourcc/tag" },
3215     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3216                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3217         "use fixed quality scale (VBR)", "q" },
3218     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3219                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3220         "use fixed quality scale (VBR)", "q" },
3221     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3222         "set profile", "profile" },
3223     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3224         "set stream filtergraph", "filter_graph" },
3225     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3226         "read stream filtergraph description from a file", "filename" },
3227     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3228         "reinit filtergraph on input parameter changes", "" },
3229     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3230         "create a complex filtergraph", "graph_description" },
3231     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3232         "create a complex filtergraph", "graph_description" },
3233     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3234         "read complex filtergraph description from a file", "filename" },
3235     { "stats",          OPT_BOOL,                                    { &print_stats },
3236         "print progress report during encoding", },
3237     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3238                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3239         "add an attachment to the output file", "filename" },
3240     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3241                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3242         "extract an attachment into a file", "filename" },
3243     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3244                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3245     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3246         "print timestamp debugging info" },
3247     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3248         "maximum error rate", "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success." },
3249     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3250                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3251         "discard", "" },
3252     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3253                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3254         "disposition", "" },
3255     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3256                                                                      { .off = OFFSET(thread_queue_size) },
3257         "set the maximum number of queued packets from the demuxer" },
3258
3259     /* video options */
3260     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3261         "set the number of video frames to output", "number" },
3262     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3263                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3264         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3265     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3266                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3267         "set frame size (WxH or abbreviation)", "size" },
3268     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3269                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3270         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3271     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3272                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3273         "set pixel format", "format" },
3274     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3275         "set the number of bits per raw sample", "number" },
3276     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3277         "deprecated use -g 1" },
3278     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3279         "disable video" },
3280     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3281                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3282         "rate control override for specific intervals", "override" },
3283     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3284                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3285         "force video codec ('copy' to copy stream)", "codec" },
3286     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3287         "Removed" },
3288     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3289         "Removed" },
3290     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3291         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3292     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3293         "select the pass number (1 to 3)", "n" },
3294     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3295                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3296         "select two pass log file name prefix", "prefix" },
3297     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3298         "this option is deprecated, use the yadif filter instead" },
3299     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3300         "calculate PSNR of compressed frames" },
3301     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3302         "dump video coding statistics to file" },
3303     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3304         "dump video coding statistics to file", "file" },
3305     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3306         "set video filters", "filter_graph" },
3307     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3308                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3309         "specify intra matrix coeffs", "matrix" },
3310     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3311                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3312         "specify inter matrix coeffs", "matrix" },
3313     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3314                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3315         "specify intra matrix coeffs", "matrix" },
3316     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3317                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3318         "top=1/bottom=0/auto=-1 field first", "" },
3319     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3320                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3321         "force video tag/fourcc", "fourcc/tag" },
3322     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3323         "show QP histogram" },
3324     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3325                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3326         "force the selected framerate, disable the best supported framerate selection" },
3327     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3328                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3329         "set the value of an outfile streamid", "streamIndex:value" },
3330     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3331                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3332         "force key frames at specified timestamps", "timestamps" },
3333     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3334         "audio bitrate (please use -b:a)", "bitrate" },
3335     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3336         "video bitrate (please use -b:v)", "bitrate" },
3337     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3338                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3339         "use HW accelerated decoding", "hwaccel name" },
3340     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3341                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3342         "select a device for HW acceleration", "devicename" },
3343 #if HAVE_VDPAU_X11
3344     { "vdpau_api_ver", HAS_ARG | OPT_INT | OPT_EXPERT, { &vdpau_api_ver }, "" },
3345 #endif
3346 #if CONFIG_VDA || CONFIG_VIDEOTOOLBOX
3347     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3348 #endif
3349     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3350         "show available HW acceleration methods" },
3351     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3352                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3353         "automatically insert correct rotate filters" },
3354
3355     /* audio options */
3356     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3357         "set the number of audio frames to output", "number" },
3358     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3359         "set audio quality (codec-specific)", "quality", },
3360     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3361                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3362         "set audio sampling rate (in Hz)", "rate" },
3363     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3364                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3365         "set number of audio channels", "channels" },
3366     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3367         "disable audio" },
3368     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3369                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3370         "force audio codec ('copy' to copy stream)", "codec" },
3371     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3372                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3373         "force audio tag/fourcc", "fourcc/tag" },
3374     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3375         "change audio volume (256=normal)" , "volume" },
3376     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3377                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3378         "set sample format", "format" },
3379     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3380                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3381         "set channel layout", "layout" },
3382     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3383         "set audio filters", "filter_graph" },
3384     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3385       "set the maximum number of channels to try to guess the channel layout" },
3386
3387     /* subtitle options */
3388     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3389         "disable subtitle" },
3390     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3391         "force subtitle codec ('copy' to copy stream)", "codec" },
3392     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3393         , "force subtitle tag/fourcc", "fourcc/tag" },
3394     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3395         "fix subtitles duration" },
3396     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3397         "set canvas size (WxH or abbreviation)", "size" },
3398
3399     /* grab options */
3400     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3401         "deprecated, use -channel", "channel" },
3402     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3403         "deprecated, use -standard", "standard" },
3404     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3405
3406     /* muxer options */
3407     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3408         "set the maximum demux-decode delay", "seconds" },
3409     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3410         "set the initial demux-decode delay", "seconds" },
3411     { "override_ffserver", OPT_BOOL | OPT_EXPERT | OPT_OUTPUT, { &override_ffserver },
3412         "override the options from ffserver", "" },
3413     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3414         "specify a file in which to print sdp information", "file" },
3415
3416     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3417         "A comma-separated list of bitstream filters", "bitstream_filters" },
3418     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3419         "deprecated", "audio bitstream_filters" },
3420     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3421         "deprecated", "video bitstream_filters" },
3422
3423     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3424         "set the audio options to the indicated preset", "preset" },
3425     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3426         "set the video options to the indicated preset", "preset" },
3427     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3428         "set the subtitle options to the indicated preset", "preset" },
3429     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3430         "set options from indicated preset file", "filename" },
3431     /* data codec support */
3432     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3433         "force data codec ('copy' to copy stream)", "codec" },
3434     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3435         "disable data" },
3436
3437     { NULL, },
3438 };