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