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