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

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