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