git.sesse.net Git - ffmpeg/blob - ffmpeg_opt.c

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