ffmpeg_opt.c

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