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