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