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

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