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