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