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