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 area = 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 new_area;
2217                 ist = input_streams[i];
2218                 new_area = ist->st->codecpar->width * ist->st->codecpar->height + 100000000*!!ist->st->codec_info_nb_frames
2219                            + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2220                 if (ist->user_set_discard == AVDISCARD_ALL)
2221                     continue;
2222                 if((qcr!=MKTAG('A', 'P', 'I', 'C')) && (ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2223                     new_area = 1;
2224                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
2225                     new_area > area) {
2226                     if((qcr==MKTAG('A', 'P', 'I', 'C')) && !(ist->st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2227                         continue;
2228                     area = new_area;
2229                     idx = i;
2230                 }
2231             }
2232             if (idx >= 0)
2233                 new_video_stream(o, oc, idx);
2234         }
2235
2236         /* audio: most channels */
2237         if (!o->audio_disable && av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_AUDIO) != AV_CODEC_ID_NONE) {
2238             int best_score = 0, idx = -1;
2239             for (i = 0; i < nb_input_streams; i++) {
2240                 int score;
2241                 ist = input_streams[i];
2242                 score = ist->st->codecpar->channels + 100000000*!!ist->st->codec_info_nb_frames
2243                         + 5000000*!!(ist->st->disposition & AV_DISPOSITION_DEFAULT);
2244                 if (ist->user_set_discard == AVDISCARD_ALL)
2245                     continue;
2246                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
2247                     score > best_score) {
2248                     best_score = score;
2249                     idx = i;
2250                 }
2251             }
2252             if (idx >= 0)
2253                 new_audio_stream(o, oc, idx);
2254         }
2255
2256         /* subtitles: pick first */
2257         MATCH_PER_TYPE_OPT(codec_names, str, subtitle_codec_name, oc, "s");
2258         if (!o->subtitle_disable && (avcodec_find_encoder(oc->oformat->subtitle_codec) || subtitle_codec_name)) {
2259             for (i = 0; i < nb_input_streams; i++)
2260                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2261                     AVCodecDescriptor const *input_descriptor =
2262                         avcodec_descriptor_get(input_streams[i]->st->codecpar->codec_id);
2263                     AVCodecDescriptor const *output_descriptor = NULL;
2264                     AVCodec const *output_codec =
2265                         avcodec_find_encoder(oc->oformat->subtitle_codec);
2266                     int input_props = 0, output_props = 0;
2267                     if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2268                         continue;
2269                     if (output_codec)
2270                         output_descriptor = avcodec_descriptor_get(output_codec->id);
2271                     if (input_descriptor)
2272                         input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2273                     if (output_descriptor)
2274                         output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
2275                     if (subtitle_codec_name ||
2276                         input_props & output_props ||
2277                         // Map dvb teletext which has neither property to any output subtitle encoder
2278                         input_descriptor && output_descriptor &&
2279                         (!input_descriptor->props ||
2280                          !output_descriptor->props)) {
2281                         new_subtitle_stream(o, oc, i);
2282                         break;
2283                     }
2284                 }
2285         }
2286         /* Data only if codec id match */
2287         if (!o->data_disable ) {
2288             enum AVCodecID codec_id = av_guess_codec(oc->oformat, NULL, filename, NULL, AVMEDIA_TYPE_DATA);
2289             for (i = 0; codec_id != AV_CODEC_ID_NONE && i < nb_input_streams; i++) {
2290                 if (input_streams[i]->user_set_discard == AVDISCARD_ALL)
2291                     continue;
2292                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_DATA
2293                     && input_streams[i]->st->codecpar->codec_id == codec_id )
2294                     new_data_stream(o, oc, i);
2295             }
2296         }
2297     } else {
2298         for (i = 0; i < o->nb_stream_maps; i++) {
2299             StreamMap *map = &o->stream_maps[i];
2300
2301             if (map->disabled)
2302                 continue;
2303
2304             if (map->linklabel) {
2305                 FilterGraph *fg;
2306                 OutputFilter *ofilter = NULL;
2307                 int j, k;
2308
2309                 for (j = 0; j < nb_filtergraphs; j++) {
2310                     fg = filtergraphs[j];
2311                     for (k = 0; k < fg->nb_outputs; k++) {
2312                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
2313                         if (out && !strcmp(out->name, map->linklabel)) {
2314                             ofilter = fg->outputs[k];
2315                             goto loop_end;
2316                         }
2317                     }
2318                 }
2319 loop_end:
2320                 if (!ofilter) {
2321                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
2322                            "in any defined filter graph, or was already used elsewhere.\n", map->linklabel);
2323                     exit_program(1);
2324                 }
2325                 init_output_filter(ofilter, o, oc);
2326             } else {
2327                 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
2328
2329                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
2330                 if (ist->user_set_discard == AVDISCARD_ALL) {
2331                     av_log(NULL, AV_LOG_FATAL, "Stream #%d:%d is disabled and cannot be mapped.\n",
2332                            map->file_index, map->stream_index);
2333                     exit_program(1);
2334                 }
2335                 if(o->subtitle_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE)
2336                     continue;
2337                 if(o->   audio_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
2338                     continue;
2339                 if(o->   video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
2340                     continue;
2341                 if(o->    data_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_DATA)
2342                     continue;
2343
2344                 ost = NULL;
2345                 switch (ist->st->codecpar->codec_type) {
2346                 case AVMEDIA_TYPE_VIDEO:      ost = new_video_stream     (o, oc, src_idx); break;
2347                 case AVMEDIA_TYPE_AUDIO:      ost = new_audio_stream     (o, oc, src_idx); break;
2348                 case AVMEDIA_TYPE_SUBTITLE:   ost = new_subtitle_stream  (o, oc, src_idx); break;
2349                 case AVMEDIA_TYPE_DATA:       ost = new_data_stream      (o, oc, src_idx); break;
2350                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
2351                 case AVMEDIA_TYPE_UNKNOWN:
2352                     if (copy_unknown_streams) {
2353                         ost = new_unknown_stream   (o, oc, src_idx);
2354                         break;
2355                     }
2356                 default:
2357                     av_log(NULL, ignore_unknown_streams ? AV_LOG_WARNING : AV_LOG_FATAL,
2358                            "Cannot map stream #%d:%d - unsupported type.\n",
2359                            map->file_index, map->stream_index);
2360                     if (!ignore_unknown_streams) {
2361                         av_log(NULL, AV_LOG_FATAL,
2362                                "If you want unsupported types ignored instead "
2363                                "of failing, please use the -ignore_unknown option\n"
2364                                "If you want them copied, please use -copy_unknown\n");
2365                         exit_program(1);
2366                     }
2367                 }
2368                 if (ost)
2369                     ost->sync_ist = input_streams[  input_files[map->sync_file_index]->ist_index
2370                                                   + map->sync_stream_index];
2371             }
2372         }
2373     }
2374
2375     /* handle attached files */
2376     for (i = 0; i < o->nb_attachments; i++) {
2377         AVIOContext *pb;
2378         uint8_t *attachment;
2379         const char *p;
2380         int64_t len;
2381
2382         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
2383             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
2384                    o->attachments[i]);
2385             exit_program(1);
2386         }
2387         if ((len = avio_size(pb)) <= 0) {
2388             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
2389                    o->attachments[i]);
2390             exit_program(1);
2391         }
2392         if (len > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE ||
2393             !(attachment = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE))) {
2394             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large.\n",
2395                    o->attachments[i]);
2396             exit_program(1);
2397         }
2398         avio_read(pb, attachment, len);
2399         memset(attachment + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
2400
2401         ost = new_attachment_stream(o, oc, -1);
2402         ost->stream_copy               = 0;
2403         ost->attachment_filename       = o->attachments[i];
2404         ost->st->codecpar->extradata      = attachment;
2405         ost->st->codecpar->extradata_size = len;
2406
2407         p = strrchr(o->attachments[i], '/');
2408         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
2409         avio_closep(&pb);
2410     }
2411
2412 #if FF_API_LAVF_AVCTX
2413     for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
2414         AVDictionaryEntry *e;
2415         ost = output_streams[i];
2416
2417         if ((ost->stream_copy || ost->attachment_filename)
2418             && (e = av_dict_get(o->g->codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
2419             && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
2420             if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
2421                 exit_program(1);
2422     }
2423 #endif
2424
2425     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2426         av_dump_format(oc, nb_output_files - 1, oc->url, 1);
2427         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
2428         exit_program(1);
2429     }
2430
2431     /* check if all codec options have been used */
2432     unused_opts = strip_specifiers(o->g->codec_opts);
2433     for (i = of->ost_index; i < nb_output_streams; i++) {
2434         e = NULL;
2435         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
2436                                 AV_DICT_IGNORE_SUFFIX)))
2437             av_dict_set(&unused_opts, e->key, NULL, 0);
2438     }
2439
2440     e = NULL;
2441     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
2442         const AVClass *class = avcodec_get_class();
2443         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
2444                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2445         const AVClass *fclass = avformat_get_class();
2446         const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
2447                                               AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
2448         if (!option || foption)
2449             continue;
2450
2451
2452         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
2453             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
2454                    "output file #%d (%s) is not an encoding option.\n", e->key,
2455                    option->help ? option->help : "", nb_output_files - 1,
2456                    filename);
2457             exit_program(1);
2458         }
2459
2460         // gop_timecode is injected by generic code but not always used
2461         if (!strcmp(e->key, "gop_timecode"))
2462             continue;
2463
2464         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
2465                "output file #%d (%s) has not been used for any stream. The most "
2466                "likely reason is either wrong type (e.g. a video option with "
2467                "no video streams) or that it is a private option of some encoder "
2468                "which was not actually used for any stream.\n", e->key,
2469                option->help ? option->help : "", nb_output_files - 1, filename);
2470     }
2471     av_dict_free(&unused_opts);
2472
2473     /* set the decoding_needed flags and create simple filtergraphs */
2474     for (i = of->ost_index; i < nb_output_streams; i++) {
2475         OutputStream *ost = output_streams[i];
2476
2477         if (ost->encoding_needed && ost->source_index >= 0) {
2478             InputStream *ist = input_streams[ost->source_index];
2479             ist->decoding_needed |= DECODING_FOR_OST;
2480
2481             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
2482                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
2483                 err = init_simple_filtergraph(ist, ost);
2484                 if (err < 0) {
2485                     av_log(NULL, AV_LOG_ERROR,
2486                            "Error initializing a simple filtergraph between streams "
2487                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
2488                            nb_output_files - 1, ost->st->index);
2489                     exit_program(1);
2490                 }
2491             }
2492         }
2493
2494         /* set the filter output constraints */
2495         if (ost->filter) {
2496             OutputFilter *f = ost->filter;
2497             int count;
2498             switch (ost->enc_ctx->codec_type) {
2499             case AVMEDIA_TYPE_VIDEO:
2500                 f->frame_rate = ost->frame_rate;
2501                 f->width      = ost->enc_ctx->width;
2502                 f->height     = ost->enc_ctx->height;
2503                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
2504                     f->format = ost->enc_ctx->pix_fmt;
2505                 } else if (ost->enc->pix_fmts) {
2506                     count = 0;
2507                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
2508                         count++;
2509                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2510                     if (!f->formats)
2511                         exit_program(1);
2512                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
2513                 }
2514                 break;
2515             case AVMEDIA_TYPE_AUDIO:
2516                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
2517                     f->format = ost->enc_ctx->sample_fmt;
2518                 } else if (ost->enc->sample_fmts) {
2519                     count = 0;
2520                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
2521                         count++;
2522                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
2523                     if (!f->formats)
2524                         exit_program(1);
2525                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
2526                 }
2527                 if (ost->enc_ctx->sample_rate) {
2528                     f->sample_rate = ost->enc_ctx->sample_rate;
2529                 } else if (ost->enc->supported_samplerates) {
2530                     count = 0;
2531                     while (ost->enc->supported_samplerates[count])
2532                         count++;
2533                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
2534                     if (!f->sample_rates)
2535                         exit_program(1);
2536                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
2537                            (count + 1) * sizeof(*f->sample_rates));
2538                 }
2539                 if (ost->enc_ctx->channels) {
2540                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
2541                 } else if (ost->enc->channel_layouts) {
2542                     count = 0;
2543                     while (ost->enc->channel_layouts[count])
2544                         count++;
2545                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
2546                     if (!f->channel_layouts)
2547                         exit_program(1);
2548                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
2549                            (count + 1) * sizeof(*f->channel_layouts));
2550                 }
2551                 break;
2552             }
2553         }
2554     }
2555
2556     /* check filename in case of an image number is expected */
2557     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2558         if (!av_filename_number_test(oc->url)) {
2559             print_error(oc->url, AVERROR(EINVAL));
2560             exit_program(1);
2561         }
2562     }
2563
2564     if (!(oc->oformat->flags & AVFMT_NOSTREAMS) && !input_stream_potentially_available) {
2565         av_log(NULL, AV_LOG_ERROR,
2566                "No input streams but output needs an input stream\n");
2567         exit_program(1);
2568     }
2569
2570     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2571         /* test if it already exists to avoid losing precious files */
2572         assert_file_overwrite(filename);
2573
2574         /* open the file */
2575         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
2576                               &oc->interrupt_callback,
2577                               &of->opts)) < 0) {
2578             print_error(filename, err);
2579             exit_program(1);
2580         }
2581     } else if (strcmp(oc->oformat->name, "image2")==0 && !av_filename_number_test(filename))
2582         assert_file_overwrite(filename);
2583
2584     if (o->mux_preload) {
2585         av_dict_set_int(&of->opts, "preload", o->mux_preload*AV_TIME_BASE, 0);
2586     }
2587     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
2588
2589     /* copy metadata */
2590     for (i = 0; i < o->nb_metadata_map; i++) {
2591         char *p;
2592         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
2593
2594         if (in_file_index >= nb_input_files) {
2595             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
2596             exit_program(1);
2597         }
2598         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
2599                       in_file_index >= 0 ?
2600                       input_files[in_file_index]->ctx : NULL, o);
2601     }
2602
2603     /* copy chapters */
2604     if (o->chapters_input_file >= nb_input_files) {
2605         if (o->chapters_input_file == INT_MAX) {
2606             /* copy chapters from the first input file that has them*/
2607             o->chapters_input_file = -1;
2608             for (i = 0; i < nb_input_files; i++)
2609                 if (input_files[i]->ctx->nb_chapters) {
2610                     o->chapters_input_file = i;
2611                     break;
2612                 }
2613         } else {
2614             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
2615                    o->chapters_input_file);
2616             exit_program(1);
2617         }
2618     }
2619     if (o->chapters_input_file >= 0)
2620         copy_chapters(input_files[o->chapters_input_file], of,
2621                       !o->metadata_chapters_manual);
2622
2623     /* copy global metadata by default */
2624     if (!o->metadata_global_manual && nb_input_files){
2625         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
2626                      AV_DICT_DONT_OVERWRITE);
2627         if(o->recording_time != INT64_MAX)
2628             av_dict_set(&oc->metadata, "duration", NULL, 0);
2629         av_dict_set(&oc->metadata, "creation_time", NULL, 0);
2630     }
2631     if (!o->metadata_streams_manual)
2632         for (i = of->ost_index; i < nb_output_streams; i++) {
2633             InputStream *ist;
2634             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
2635                 continue;
2636             ist = input_streams[output_streams[i]->source_index];
2637             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
2638             if (!output_streams[i]->stream_copy) {
2639                 av_dict_set(&output_streams[i]->st->metadata, "encoder", NULL, 0);
2640             }
2641         }
2642
2643     /* process manually set programs */
2644     for (i = 0; i < o->nb_program; i++) {
2645         const char *p = o->program[i].u.str;
2646         int progid = i+1;
2647         AVProgram *program;
2648
2649         while(*p) {
2650             const char *p2 = av_get_token(&p, ":");
2651             const char *to_dealloc = p2;
2652             char *key;
2653             if (!p2)
2654                 break;
2655
2656             if(*p) p++;
2657
2658             key = av_get_token(&p2, "=");
2659             if (!key || !*p2) {
2660                 av_freep(&to_dealloc);
2661                 av_freep(&key);
2662                 break;
2663             }
2664             p2++;
2665
2666             if (!strcmp(key, "program_num"))
2667                 progid = strtol(p2, NULL, 0);
2668             av_freep(&to_dealloc);
2669             av_freep(&key);
2670         }
2671
2672         program = av_new_program(oc, progid);
2673
2674         p = o->program[i].u.str;
2675         while(*p) {
2676             const char *p2 = av_get_token(&p, ":");
2677             const char *to_dealloc = p2;
2678             char *key;
2679             if (!p2)
2680                 break;
2681             if(*p) p++;
2682
2683             key = av_get_token(&p2, "=");
2684             if (!key) {
2685                 av_log(NULL, AV_LOG_FATAL,
2686                        "No '=' character in program string %s.\n",
2687                        p2);
2688                 exit_program(1);
2689             }
2690             if (!*p2)
2691                 exit_program(1);
2692             p2++;
2693
2694             if (!strcmp(key, "title")) {
2695                 av_dict_set(&program->metadata, "title", p2, 0);
2696             } else if (!strcmp(key, "program_num")) {
2697             } else if (!strcmp(key, "st")) {
2698                 int st_num = strtol(p2, NULL, 0);
2699                 av_program_add_stream_index(oc, progid, st_num);
2700             } else {
2701                 av_log(NULL, AV_LOG_FATAL, "Unknown program key %s.\n", key);
2702                 exit_program(1);
2703             }
2704             av_freep(&to_dealloc);
2705             av_freep(&key);
2706         }
2707     }
2708
2709     /* process manually set metadata */
2710     for (i = 0; i < o->nb_metadata; i++) {
2711         AVDictionary **m;
2712         char type, *val;
2713         const char *stream_spec;
2714         int index = 0, j, ret = 0;
2715
2716         val = strchr(o->metadata[i].u.str, '=');
2717         if (!val) {
2718             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
2719                    o->metadata[i].u.str);
2720             exit_program(1);
2721         }
2722         *val++ = 0;
2723
2724         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
2725         if (type == 's') {
2726             for (j = 0; j < oc->nb_streams; j++) {
2727                 ost = output_streams[nb_output_streams - oc->nb_streams + j];
2728                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
2729                     if (!strcmp(o->metadata[i].u.str, "rotate")) {
2730                         char *tail;
2731                         double theta = av_strtod(val, &tail);
2732                         if (!*tail) {
2733                             ost->rotate_overridden = 1;
2734                             ost->rotate_override_value = theta;
2735                         }
2736                     } else {
2737                         av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
2738                     }
2739                 } else if (ret < 0)
2740                     exit_program(1);
2741             }
2742         }
2743         else {
2744             switch (type) {
2745             case 'g':
2746                 m = &oc->metadata;
2747                 break;
2748             case 'c':
2749                 if (index < 0 || index >= oc->nb_chapters) {
2750                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2751                     exit_program(1);
2752                 }
2753                 m = &oc->chapters[index]->metadata;
2754                 break;
2755             case 'p':
2756                 if (index < 0 || index >= oc->nb_programs) {
2757                     av_log(NULL, AV_LOG_FATAL, "Invalid program index %d in metadata specifier.\n", index);
2758                     exit_program(1);
2759                 }
2760                 m = &oc->programs[index]->metadata;
2761                 break;
2762             default:
2763                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2764                 exit_program(1);
2765             }
2766             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2767         }
2768     }
2769
2770     return 0;
2771 }
2772
2773 static int opt_target(void *optctx, const char *opt, const char *arg)
2774 {
2775     OptionsContext *o = optctx;
2776     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2777     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2778
2779     if (!strncmp(arg, "pal-", 4)) {
2780         norm = PAL;
2781         arg += 4;
2782     } else if (!strncmp(arg, "ntsc-", 5)) {
2783         norm = NTSC;
2784         arg += 5;
2785     } else if (!strncmp(arg, "film-", 5)) {
2786         norm = FILM;
2787         arg += 5;
2788     } else {
2789         /* Try to determine PAL/NTSC by peeking in the input files */
2790         if (nb_input_files) {
2791             int i, j;
2792             for (j = 0; j < nb_input_files; j++) {
2793                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2794                     AVStream *st = input_files[j]->ctx->streams[i];
2795                     int64_t fr;
2796                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2797                         continue;
2798                     fr = st->time_base.den * 1000LL / st->time_base.num;
2799                     if (fr == 25000) {
2800                         norm = PAL;
2801                         break;
2802                     } else if ((fr == 29970) || (fr == 23976)) {
2803                         norm = NTSC;
2804                         break;
2805                     }
2806                 }
2807                 if (norm != UNKNOWN)
2808                     break;
2809             }
2810         }
2811         if (norm != UNKNOWN)
2812             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2813     }
2814
2815     if (norm == UNKNOWN) {
2816         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2817         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2818         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2819         exit_program(1);
2820     }
2821
2822     if (!strcmp(arg, "vcd")) {
2823         opt_video_codec(o, "c:v", "mpeg1video");
2824         opt_audio_codec(o, "c:a", "mp2");
2825         parse_option(o, "f", "vcd", options);
2826
2827         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2828         parse_option(o, "r", frame_rates[norm], options);
2829         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2830
2831         opt_default(NULL, "b:v", "1150000");
2832         opt_default(NULL, "maxrate:v", "1150000");
2833         opt_default(NULL, "minrate:v", "1150000");
2834         opt_default(NULL, "bufsize:v", "327680"); // 40*1024*8;
2835
2836         opt_default(NULL, "b:a", "224000");
2837         parse_option(o, "ar", "44100", options);
2838         parse_option(o, "ac", "2", options);
2839
2840         opt_default(NULL, "packetsize", "2324");
2841         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
2842
2843         /* We have to offset the PTS, so that it is consistent with the SCR.
2844            SCR starts at 36000, but the first two packs contain only padding
2845            and the first pack from the other stream, respectively, may also have
2846            been written before.
2847            So the real data starts at SCR 36000+3*1200. */
2848         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2849     } else if (!strcmp(arg, "svcd")) {
2850
2851         opt_video_codec(o, "c:v", "mpeg2video");
2852         opt_audio_codec(o, "c:a", "mp2");
2853         parse_option(o, "f", "svcd", options);
2854
2855         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2856         parse_option(o, "r", frame_rates[norm], options);
2857         parse_option(o, "pix_fmt", "yuv420p", options);
2858         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2859
2860         opt_default(NULL, "b:v", "2040000");
2861         opt_default(NULL, "maxrate:v", "2516000");
2862         opt_default(NULL, "minrate:v", "0"); // 1145000;
2863         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2864         opt_default(NULL, "scan_offset", "1");
2865
2866         opt_default(NULL, "b:a", "224000");
2867         parse_option(o, "ar", "44100", options);
2868
2869         opt_default(NULL, "packetsize", "2324");
2870
2871     } else if (!strcmp(arg, "dvd")) {
2872
2873         opt_video_codec(o, "c:v", "mpeg2video");
2874         opt_audio_codec(o, "c:a", "ac3");
2875         parse_option(o, "f", "dvd", options);
2876
2877         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2878         parse_option(o, "r", frame_rates[norm], options);
2879         parse_option(o, "pix_fmt", "yuv420p", options);
2880         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2881
2882         opt_default(NULL, "b:v", "6000000");
2883         opt_default(NULL, "maxrate:v", "9000000");
2884         opt_default(NULL, "minrate:v", "0"); // 1500000;
2885         opt_default(NULL, "bufsize:v", "1835008"); // 224*1024*8;
2886
2887         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2888         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
2889
2890         opt_default(NULL, "b:a", "448000");
2891         parse_option(o, "ar", "48000", options);
2892
2893     } else if (!strncmp(arg, "dv", 2)) {
2894
2895         parse_option(o, "f", "dv", options);
2896
2897         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2898         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2899                           norm == PAL ? "yuv420p" : "yuv411p", options);
2900         parse_option(o, "r", frame_rates[norm], options);
2901
2902         parse_option(o, "ar", "48000", options);
2903         parse_option(o, "ac", "2", options);
2904
2905     } else {
2906         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2907         return AVERROR(EINVAL);
2908     }
2909
2910     av_dict_copy(&o->g->codec_opts,  codec_opts, AV_DICT_DONT_OVERWRITE);
2911     av_dict_copy(&o->g->format_opts, format_opts, AV_DICT_DONT_OVERWRITE);
2912
2913     return 0;
2914 }
2915
2916 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2917 {
2918     av_free (vstats_filename);
2919     vstats_filename = av_strdup (arg);
2920     return 0;
2921 }
2922
2923 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2924 {
2925     char filename[40];
2926     time_t today2 = time(NULL);
2927     struct tm *today = localtime(&today2);
2928
2929     if (!today) { // maybe tomorrow
2930         av_log(NULL, AV_LOG_FATAL, "Unable to get current time: %s\n", strerror(errno));
2931         exit_program(1);
2932     }
2933
2934     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2935              today->tm_sec);
2936     return opt_vstats_file(NULL, opt, filename);
2937 }
2938
2939 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2940 {
2941     OptionsContext *o = optctx;
2942     return parse_option(o, "frames:v", arg, options);
2943 }
2944
2945 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2946 {
2947     OptionsContext *o = optctx;
2948     return parse_option(o, "frames:a", arg, options);
2949 }
2950
2951 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2952 {
2953     OptionsContext *o = optctx;
2954     return parse_option(o, "frames:d", arg, options);
2955 }
2956
2957 static int opt_default_new(OptionsContext *o, const char *opt, const char *arg)
2958 {
2959     int ret;
2960     AVDictionary *cbak = codec_opts;
2961     AVDictionary *fbak = format_opts;
2962     codec_opts = NULL;
2963     format_opts = NULL;
2964
2965     ret = opt_default(NULL, opt, arg);
2966
2967     av_dict_copy(&o->g->codec_opts , codec_opts, 0);
2968     av_dict_copy(&o->g->format_opts, format_opts, 0);
2969     av_dict_free(&codec_opts);
2970     av_dict_free(&format_opts);
2971     codec_opts = cbak;
2972     format_opts = fbak;
2973
2974     return ret;
2975 }
2976
2977 static int opt_preset(void *optctx, const char *opt, const char *arg)
2978 {
2979     OptionsContext *o = optctx;
2980     FILE *f=NULL;
2981     char filename[1000], line[1000], tmp_line[1000];
2982     const char *codec_name = NULL;
2983
2984     tmp_line[0] = *opt;
2985     tmp_line[1] = 0;
2986     MATCH_PER_TYPE_OPT(codec_names, str, codec_name, NULL, tmp_line);
2987
2988     if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
2989         if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
2990             av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
2991         }else
2992             av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
2993         exit_program(1);
2994     }
2995
2996     while (fgets(line, sizeof(line), f)) {
2997         char *key = tmp_line, *value, *endptr;
2998
2999         if (strcspn(line, "#\n\r") == 0)
3000             continue;
3001         av_strlcpy(tmp_line, line, sizeof(tmp_line));
3002         if (!av_strtok(key,   "=",    &value) ||
3003             !av_strtok(value, "\r\n", &endptr)) {
3004             av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
3005             exit_program(1);
3006         }
3007         av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
3008
3009         if      (!strcmp(key, "acodec")) opt_audio_codec   (o, key, value);
3010         else if (!strcmp(key, "vcodec")) opt_video_codec   (o, key, value);
3011         else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
3012         else if (!strcmp(key, "dcodec")) opt_data_codec    (o, key, value);
3013         else if (opt_default_new(o, key, value) < 0) {
3014             av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
3015                    filename, line, key, value);
3016             exit_program(1);
3017         }
3018     }
3019
3020     fclose(f);
3021
3022     return 0;
3023 }
3024
3025 static int opt_old2new(void *optctx, const char *opt, const char *arg)
3026 {
3027     OptionsContext *o = optctx;
3028     int ret;
3029     char *s = av_asprintf("%s:%c", opt + 1, *opt);
3030     if (!s)
3031         return AVERROR(ENOMEM);
3032     ret = parse_option(o, s, arg, options);
3033     av_free(s);
3034     return ret;
3035 }
3036
3037 static int opt_bitrate(void *optctx, const char *opt, const char *arg)
3038 {
3039     OptionsContext *o = optctx;
3040
3041     if(!strcmp(opt, "ab")){
3042         av_dict_set(&o->g->codec_opts, "b:a", arg, 0);
3043         return 0;
3044     } else if(!strcmp(opt, "b")){
3045         av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
3046         av_dict_set(&o->g->codec_opts, "b:v", arg, 0);
3047         return 0;
3048     }
3049     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3050     return 0;
3051 }
3052
3053 static int opt_qscale(void *optctx, const char *opt, const char *arg)
3054 {
3055     OptionsContext *o = optctx;
3056     char *s;
3057     int ret;
3058     if(!strcmp(opt, "qscale")){
3059         av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
3060         return parse_option(o, "q:v", arg, options);
3061     }
3062     s = av_asprintf("q%s", opt + 6);
3063     if (!s)
3064         return AVERROR(ENOMEM);
3065     ret = parse_option(o, s, arg, options);
3066     av_free(s);
3067     return ret;
3068 }
3069
3070 static int opt_profile(void *optctx, const char *opt, const char *arg)
3071 {
3072     OptionsContext *o = optctx;
3073     if(!strcmp(opt, "profile")){
3074         av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
3075         av_dict_set(&o->g->codec_opts, "profile:v", arg, 0);
3076         return 0;
3077     }
3078     av_dict_set(&o->g->codec_opts, opt, arg, 0);
3079     return 0;
3080 }
3081
3082 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
3083 {
3084     OptionsContext *o = optctx;
3085     return parse_option(o, "filter:v", arg, options);
3086 }
3087
3088 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
3089 {
3090     OptionsContext *o = optctx;
3091     return parse_option(o, "filter:a", arg, options);
3092 }
3093
3094 static int opt_vsync(void *optctx, const char *opt, const char *arg)
3095 {
3096     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
3097     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
3098     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
3099     else if (!av_strcasecmp(arg, "drop"))        video_sync_method = VSYNC_DROP;
3100
3101     if (video_sync_method == VSYNC_AUTO)
3102         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
3103     return 0;
3104 }
3105
3106 static int opt_timecode(void *optctx, const char *opt, const char *arg)
3107 {
3108     OptionsContext *o = optctx;
3109     int ret;
3110     char *tcr = av_asprintf("timecode=%s", arg);
3111     if (!tcr)
3112         return AVERROR(ENOMEM);
3113     ret = parse_option(o, "metadata:g", tcr, options);
3114     if (ret >= 0)
3115         ret = av_dict_set(&o->g->codec_opts, "gop_timecode", arg, 0);
3116     av_free(tcr);
3117     return ret;
3118 }
3119
3120 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
3121 {
3122     OptionsContext *o = optctx;
3123     char layout_str[32];
3124     char *stream_str;
3125     char *ac_str;
3126     int ret, channels, ac_str_size;
3127     uint64_t layout;
3128
3129     layout = av_get_channel_layout(arg);
3130     if (!layout) {
3131         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
3132         return AVERROR(EINVAL);
3133     }
3134     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
3135     ret = opt_default_new(o, opt, layout_str);
3136     if (ret < 0)
3137         return ret;
3138
3139     /* set 'ac' option based on channel layout */
3140     channels = av_get_channel_layout_nb_channels(layout);
3141     snprintf(layout_str, sizeof(layout_str), "%d", channels);
3142     stream_str = strchr(opt, ':');
3143     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
3144     ac_str = av_mallocz(ac_str_size);
3145     if (!ac_str)
3146         return AVERROR(ENOMEM);
3147     av_strlcpy(ac_str, "ac", 3);
3148     if (stream_str)
3149         av_strlcat(ac_str, stream_str, ac_str_size);
3150     ret = parse_option(o, ac_str, layout_str, options);
3151     av_free(ac_str);
3152
3153     return ret;
3154 }
3155
3156 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
3157 {
3158     OptionsContext *o = optctx;
3159     return parse_option(o, "q:a", arg, options);
3160 }
3161
3162 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
3163 {
3164     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3165     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3166         return AVERROR(ENOMEM);
3167     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3168     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
3169     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
3170         return AVERROR(ENOMEM);
3171
3172     input_stream_potentially_available = 1;
3173
3174     return 0;
3175 }
3176
3177 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
3178 {
3179     uint8_t *graph_desc = read_file(arg);
3180     if (!graph_desc)
3181         return AVERROR(EINVAL);
3182
3183     GROW_ARRAY(filtergraphs, nb_filtergraphs);
3184     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
3185         return AVERROR(ENOMEM);
3186     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
3187     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
3188
3189     input_stream_potentially_available = 1;
3190
3191     return 0;
3192 }
3193
3194 void show_help_default(const char *opt, const char *arg)
3195 {
3196     /* per-file options have at least one of those set */
3197     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
3198     int show_advanced = 0, show_avoptions = 0;
3199
3200     if (opt && *opt) {
3201         if (!strcmp(opt, "long"))
3202             show_advanced = 1;
3203         else if (!strcmp(opt, "full"))
3204             show_advanced = show_avoptions = 1;
3205         else
3206             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
3207     }
3208
3209     show_usage();
3210
3211     printf("Getting help:\n"
3212            "    -h      -- print basic options\n"
3213            "    -h long -- print more options\n"
3214            "    -h full -- print all options (including all format and codec specific options, very long)\n"
3215            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter/bsf/protocol\n"
3216            "    See man %s for detailed description of the options.\n"
3217            "\n", program_name);
3218
3219     show_help_options(options, "Print help / information / capabilities:",
3220                       OPT_EXIT, 0, 0);
3221
3222     show_help_options(options, "Global options (affect whole program "
3223                       "instead of just one file):",
3224                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
3225     if (show_advanced)
3226         show_help_options(options, "Advanced global options:", OPT_EXPERT,
3227                           per_file | OPT_EXIT, 0);
3228
3229     show_help_options(options, "Per-file main options:", 0,
3230                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
3231                       OPT_EXIT, per_file);
3232     if (show_advanced)
3233         show_help_options(options, "Advanced per-file options:",
3234                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
3235
3236     show_help_options(options, "Video options:",
3237                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
3238     if (show_advanced)
3239         show_help_options(options, "Advanced Video options:",
3240                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
3241
3242     show_help_options(options, "Audio options:",
3243                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
3244     if (show_advanced)
3245         show_help_options(options, "Advanced Audio options:",
3246                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
3247     show_help_options(options, "Subtitle options:",
3248                       OPT_SUBTITLE, 0, 0);
3249     printf("\n");
3250
3251     if (show_avoptions) {
3252         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3253         show_help_children(avcodec_get_class(), flags);
3254         show_help_children(avformat_get_class(), flags);
3255 #if CONFIG_SWSCALE
3256         show_help_children(sws_get_class(), flags);
3257 #endif
3258 #if CONFIG_SWRESAMPLE
3259         show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
3260 #endif
3261         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_FILTERING_PARAM);
3262         show_help_children(av_bsf_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_BSF_PARAM);
3263     }
3264 }
3265
3266 void show_usage(void)
3267 {
3268     av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
3269     av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3270     av_log(NULL, AV_LOG_INFO, "\n");
3271 }
3272
3273 enum OptGroup {
3274     GROUP_OUTFILE,
3275     GROUP_INFILE,
3276 };
3277
3278 static const OptionGroupDef groups[] = {
3279     [GROUP_OUTFILE] = { "output url",  NULL, OPT_OUTPUT },
3280     [GROUP_INFILE]  = { "input url",   "i",  OPT_INPUT },
3281 };
3282
3283 static int open_files(OptionGroupList *l, const char *inout,
3284                       int (*open_file)(OptionsContext*, const char*))
3285 {
3286     int i, ret;
3287
3288     for (i = 0; i < l->nb_groups; i++) {
3289         OptionGroup *g = &l->groups[i];
3290         OptionsContext o;
3291
3292         init_options(&o);
3293         o.g = g;
3294
3295         ret = parse_optgroup(&o, g);
3296         if (ret < 0) {
3297             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
3298                    "%s.\n", inout, g->arg);
3299             uninit_options(&o);
3300             return ret;
3301         }
3302
3303         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
3304         ret = open_file(&o, g->arg);
3305         uninit_options(&o);
3306         if (ret < 0) {
3307             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
3308                    inout, g->arg);
3309             return ret;
3310         }
3311         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
3312     }
3313
3314     return 0;
3315 }
3316
3317 int ffmpeg_parse_options(int argc, char **argv)
3318 {
3319     OptionParseContext octx;
3320     uint8_t error[128];
3321     int ret;
3322
3323     memset(&octx, 0, sizeof(octx));
3324
3325     /* split the commandline into an internal representation */
3326     ret = split_commandline(&octx, argc, argv, options, groups,
3327                             FF_ARRAY_ELEMS(groups));
3328     if (ret < 0) {
3329         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
3330         goto fail;
3331     }
3332
3333     /* apply global options */
3334     ret = parse_optgroup(NULL, &octx.global_opts);
3335     if (ret < 0) {
3336         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
3337         goto fail;
3338     }
3339
3340     /* configure terminal and setup signal handlers */
3341     term_init();
3342
3343     /* open input files */
3344     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
3345     if (ret < 0) {
3346         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
3347         goto fail;
3348     }
3349
3350     /* create the complex filtergraphs */
3351     ret = init_complex_filters();
3352     if (ret < 0) {
3353         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
3354         goto fail;
3355     }
3356
3357     /* open output files */
3358     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
3359     if (ret < 0) {
3360         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
3361         goto fail;
3362     }
3363
3364     check_filter_outputs();
3365
3366 fail:
3367     uninit_parse_context(&octx);
3368     if (ret < 0) {
3369         av_strerror(ret, error, sizeof(error));
3370         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
3371     }
3372     return ret;
3373 }
3374
3375 static int opt_progress(void *optctx, const char *opt, const char *arg)
3376 {
3377     AVIOContext *avio = NULL;
3378     int ret;
3379
3380     if (!strcmp(arg, "-"))
3381         arg = "pipe:";
3382     ret = avio_open2(&avio, arg, AVIO_FLAG_WRITE, &int_cb, NULL);
3383     if (ret < 0) {
3384         av_log(NULL, AV_LOG_ERROR, "Failed to open progress URL \"%s\": %s\n",
3385                arg, av_err2str(ret));
3386         return ret;
3387     }
3388     progress_avio = avio;
3389     return 0;
3390 }
3391
3392 #define OFFSET(x) offsetof(OptionsContext, x)
3393 const OptionDef options[] = {
3394     /* main options */
3395     CMDUTILS_COMMON_OPTIONS
3396     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
3397                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
3398         "force format", "fmt" },
3399     { "y",              OPT_BOOL,                                    {              &file_overwrite },
3400         "overwrite output files" },
3401     { "n",              OPT_BOOL,                                    {              &no_file_overwrite },
3402         "never overwrite output files" },
3403     { "ignore_unknown", OPT_BOOL,                                    {              &ignore_unknown_streams },
3404         "Ignore unknown stream types" },
3405     { "copy_unknown",   OPT_BOOL | OPT_EXPERT,                       {              &copy_unknown_streams },
3406         "Copy unknown stream types" },
3407     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
3408                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3409         "codec name", "codec" },
3410     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
3411                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
3412         "codec name", "codec" },
3413     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
3414                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
3415         "preset name", "preset" },
3416     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3417                         OPT_OUTPUT,                                  { .func_arg = opt_map },
3418         "set input stream mapping",
3419         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
3420     { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_map_channel },
3421         "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
3422     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
3423                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
3424         "set metadata information of outfile from infile",
3425         "outfile[,metadata]:infile[,metadata]" },
3426     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
3427                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
3428         "set chapters mapping", "input_file_index" },
3429     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
3430                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
3431         "record or transcode \"duration\" seconds of audio/video",
3432         "duration" },
3433     { "to",             HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,  { .off = OFFSET(stop_time) },
3434         "record or transcode stop time", "time_stop" },
3435     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
3436         "set the limit file size in bytes", "limit_size" },
3437     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
3438                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
3439         "set the start time offset", "time_off" },
3440     { "sseof",          HAS_ARG | OPT_TIME | OPT_OFFSET |
3441                         OPT_INPUT,                                   { .off = OFFSET(start_time_eof) },
3442         "set the start time offset relative to EOF", "time_off" },
3443     { "seek_timestamp", HAS_ARG | OPT_INT | OPT_OFFSET |
3444                         OPT_INPUT,                                   { .off = OFFSET(seek_timestamp) },
3445         "enable/disable seeking by timestamp with -ss" },
3446     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
3447                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
3448         "enable/disable accurate seeking with -ss" },
3449     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
3450                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
3451         "set the input ts offset", "time_off" },
3452     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
3453                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
3454         "set the input ts scale", "scale" },
3455     { "timestamp",      HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_recording_timestamp },
3456         "set the recording timestamp ('now' to set the current time)", "time" },
3457     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
3458         "add metadata", "string=string" },
3459     { "program",        HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(program) },
3460         "add program with specified streams", "title=string:st=number..." },
3461     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3462                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
3463         "set the number of data frames to output", "number" },
3464     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
3465         "add timings for benchmarking" },
3466     { "benchmark_all",  OPT_BOOL | OPT_EXPERT,                       { &do_benchmark_all },
3467       "add timings for each task" },
3468     { "progress",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_progress },
3469       "write program-readable progress information", "url" },
3470     { "stdin",          OPT_BOOL | OPT_EXPERT,                       { &stdin_interaction },
3471       "enable or disable interaction on standard input" },
3472     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
3473         "set max runtime in seconds in CPU user time", "limit" },
3474     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
3475         "dump each input packet" },
3476     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
3477         "when dumping packets, also dump the payload" },
3478     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3479                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
3480         "read input at native frame rate", "" },
3481     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
3482         "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\" or \"dv50\" "
3483         "with optional prefixes \"pal-\", \"ntsc-\" or \"film-\")", "type" },
3484     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
3485         "video sync method", "" },
3486     { "frame_drop_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,      { &frame_drop_threshold },
3487         "frame drop threshold", "" },
3488     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
3489         "audio sync method", "" },
3490     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
3491         "audio drift threshold", "threshold" },
3492     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
3493         "copy timestamps" },
3494     { "start_at_zero",  OPT_BOOL | OPT_EXPERT,                       { &start_at_zero },
3495         "shift input timestamps to start at 0 when using copyts" },
3496     { "copytb",         HAS_ARG | OPT_INT | OPT_EXPERT,              { &copy_tb },
3497         "copy input stream time base when stream copying", "mode" },
3498     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3499                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
3500         "finish encoding within shortest input" },
3501     { "bitexact",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
3502                         OPT_OUTPUT | OPT_INPUT,                      { .off = OFFSET(bitexact) },
3503         "bitexact mode" },
3504     { "apad",           OPT_STRING | HAS_ARG | OPT_SPEC |
3505                         OPT_OUTPUT,                                  { .off = OFFSET(apad) },
3506         "audio pad", "" },
3507     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
3508         "timestamp discontinuity delta threshold", "threshold" },
3509     { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_error_threshold },
3510         "timestamp error delta threshold", "threshold" },
3511     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
3512         "exit on error", "error" },
3513     { "abort_on",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_abort_on },
3514         "abort on the specified condition flags", "flags" },
3515     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
3516                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
3517         "copy initial non-keyframes" },
3518     { "copypriorss",    OPT_INT | HAS_ARG | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT,   { .off = OFFSET(copy_prior_start) },
3519         "copy or discard frames before start time" },
3520     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
3521         "set the number of frames to output", "number" },
3522     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
3523                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
3524         "force codec tag/fourcc", "fourcc/tag" },
3525     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
3526                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
3527         "use fixed quality scale (VBR)", "q" },
3528     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3529                         OPT_OUTPUT,                                  { .func_arg = opt_qscale },
3530         "use fixed quality scale (VBR)", "q" },
3531     { "profile",        HAS_ARG | OPT_EXPERT | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_profile },
3532         "set profile", "profile" },
3533     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
3534         "set stream filtergraph", "filter_graph" },
3535     { "filter_threads",  HAS_ARG | OPT_INT,                          { &filter_nbthreads },
3536         "number of non-complex filter threads" },
3537     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
3538         "read stream filtergraph description from a file", "filename" },
3539     { "reinit_filter",  HAS_ARG | OPT_INT | OPT_SPEC | OPT_INPUT,    { .off = OFFSET(reinit_filters) },
3540         "reinit filtergraph on input parameter changes", "" },
3541     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3542         "create a complex filtergraph", "graph_description" },
3543     { "filter_complex_threads", HAS_ARG | OPT_INT,                   { &filter_complex_nbthreads },
3544         "number of threads for -filter_complex" },
3545     { "lavfi",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
3546         "create a complex filtergraph", "graph_description" },
3547     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
3548         "read complex filtergraph description from a file", "filename" },
3549     { "auto_conversion_filters", OPT_BOOL | OPT_EXPERT,              { &auto_conversion_filters },
3550         "enable automatic conversion filters globally" },
3551     { "stats",          OPT_BOOL,                                    { &print_stats },
3552         "print progress report during encoding", },
3553     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
3554                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
3555         "add an attachment to the output file", "filename" },
3556     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
3557                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
3558         "extract an attachment into a file", "filename" },
3559     { "stream_loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
3560                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
3561     { "debug_ts",       OPT_BOOL | OPT_EXPERT,                       { &debug_ts },
3562         "print timestamp debugging info" },
3563     { "max_error_rate",  HAS_ARG | OPT_FLOAT,                        { &max_error_rate },
3564         "ratio of errors (0.0: no errors, 1.0: 100% errors) above which ffmpeg returns an error instead of success.", "maximum error rate" },
3565     { "discard",        OPT_STRING | HAS_ARG | OPT_SPEC |
3566                         OPT_INPUT,                                   { .off = OFFSET(discard) },
3567         "discard", "" },
3568     { "disposition",    OPT_STRING | HAS_ARG | OPT_SPEC |
3569                         OPT_OUTPUT,                                  { .off = OFFSET(disposition) },
3570         "disposition", "" },
3571     { "thread_queue_size", HAS_ARG | OPT_INT | OPT_OFFSET | OPT_EXPERT | OPT_INPUT,
3572                                                                      { .off = OFFSET(thread_queue_size) },
3573         "set the maximum number of queued packets from the demuxer" },
3574     { "find_stream_info", OPT_BOOL | OPT_PERFILE | OPT_INPUT | OPT_EXPERT, { &find_stream_info },
3575         "read and decode the streams to fill missing information with heuristics" },
3576
3577     /* video options */
3578     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
3579         "set the number of video frames to output", "number" },
3580     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3581                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
3582         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3583     { "s",            OPT_VIDEO | HAS_ARG | OPT_SUBTITLE | OPT_STRING | OPT_SPEC |
3584                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
3585         "set frame size (WxH or abbreviation)", "size" },
3586     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
3587                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
3588         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3589     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3590                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
3591         "set pixel format", "format" },
3592     { "bits_per_raw_sample", OPT_VIDEO | OPT_INT | HAS_ARG,                      { &frame_bits_per_raw_sample },
3593         "set the number of bits per raw sample", "number" },
3594     { "intra",        OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &intra_only },
3595         "deprecated use -g 1" },
3596     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(video_disable) },
3597         "disable video" },
3598     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3599                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
3600         "rate control override for specific intervals", "override" },
3601     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
3602                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
3603         "force video codec ('copy' to copy stream)", "codec" },
3604     { "sameq",        OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3605         "Removed" },
3606     { "same_quant",   OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_sameq },
3607         "Removed" },
3608     { "timecode",     OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_timecode },
3609         "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
3610     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
3611         "select the pass number (1 to 3)", "n" },
3612     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
3613                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
3614         "select two pass log file name prefix", "prefix" },
3615     { "deinterlace",  OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_deinterlace },
3616         "this option is deprecated, use the yadif filter instead" },
3617     { "psnr",         OPT_VIDEO | OPT_BOOL | OPT_EXPERT,                         { &do_psnr },
3618         "calculate PSNR of compressed frames" },
3619     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_vstats },
3620         "dump video coding statistics to file" },
3621     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
3622         "dump video coding statistics to file", "file" },
3623     { "vstats_version",  OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,            { &vstats_version },
3624         "Version of the vstats format to use."},
3625     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
3626         "set video filters", "filter_graph" },
3627     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3628                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
3629         "specify intra matrix coeffs", "matrix" },
3630     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3631                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
3632         "specify inter matrix coeffs", "matrix" },
3633     { "chroma_intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
3634                       OPT_OUTPUT,                                                { .off = OFFSET(chroma_intra_matrices) },
3635         "specify intra matrix coeffs", "matrix" },
3636     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
3637                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(top_field_first) },
3638         "top=1/bottom=0/auto=-1 field first", "" },
3639     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
3640                       OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_old2new },
3641         "force video tag/fourcc", "fourcc/tag" },
3642     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
3643         "show QP histogram" },
3644     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
3645                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
3646         "force the selected framerate, disable the best supported framerate selection" },
3647     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
3648                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
3649         "set the value of an outfile streamid", "streamIndex:value" },
3650     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3651                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
3652         "force key frames at specified timestamps", "timestamps" },
3653     { "ab",           OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3654         "audio bitrate (please use -b:a)", "bitrate" },
3655     { "b",            OPT_VIDEO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT,            { .func_arg = opt_bitrate },
3656         "video bitrate (please use -b:v)", "bitrate" },
3657     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3658                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
3659         "use HW accelerated decoding", "hwaccel name" },
3660     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3661                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
3662         "select a device for HW acceleration", "devicename" },
3663     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
3664                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
3665         "select output format used with HW accelerated decoding", "format" },
3666 #if CONFIG_VIDEOTOOLBOX
3667     { "videotoolbox_pixfmt", HAS_ARG | OPT_STRING | OPT_EXPERT, { &videotoolbox_pixfmt}, "" },
3668 #endif
3669     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
3670         "show available HW acceleration methods" },
3671     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
3672                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
3673         "automatically insert correct rotate filters" },
3674     { "autoscale",        HAS_ARG | OPT_BOOL | OPT_SPEC |
3675                           OPT_EXPERT | OPT_OUTPUT,                               { .off = OFFSET(autoscale) },
3676         "automatically insert a scale filter at the end of the filter graph" },
3677
3678     /* audio options */
3679     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
3680         "set the number of audio frames to output", "number" },
3681     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
3682         "set audio quality (codec-specific)", "quality", },
3683     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3684                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
3685         "set audio sampling rate (in Hz)", "rate" },
3686     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
3687                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
3688         "set number of audio channels", "channels" },
3689     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT,{ .off = OFFSET(audio_disable) },
3690         "disable audio" },
3691     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
3692                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
3693         "force audio codec ('copy' to copy stream)", "codec" },
3694     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3695                         OPT_OUTPUT,                                                { .func_arg = opt_old2new },
3696         "force audio tag/fourcc", "fourcc/tag" },
3697     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
3698         "change audio volume (256=normal)" , "volume" },
3699     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
3700                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
3701         "set sample format", "format" },
3702     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
3703                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
3704         "set channel layout", "layout" },
3705     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
3706         "set audio filters", "filter_graph" },
3707     { "guess_layout_max", OPT_AUDIO | HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_INPUT, { .off = OFFSET(guess_layout_max) },
3708       "set the maximum number of channels to try to guess the channel layout" },
3709
3710     /* subtitle options */
3711     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
3712         "disable subtitle" },
3713     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
3714         "force subtitle codec ('copy' to copy stream)", "codec" },
3715     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new }
3716         , "force subtitle tag/fourcc", "fourcc/tag" },
3717     { "fix_sub_duration", OPT_BOOL | OPT_EXPERT | OPT_SUBTITLE | OPT_SPEC | OPT_INPUT, { .off = OFFSET(fix_sub_duration) },
3718         "fix subtitles duration" },
3719     { "canvas_size", OPT_SUBTITLE | HAS_ARG | OPT_STRING | OPT_SPEC | OPT_INPUT, { .off = OFFSET(canvas_sizes) },
3720         "set canvas size (WxH or abbreviation)", "size" },
3721
3722     /* grab options */
3723     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_channel },
3724         "deprecated, use -channel", "channel" },
3725     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, { .func_arg = opt_video_standard },
3726         "deprecated, use -standard", "standard" },
3727     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
3728
3729     /* muxer options */
3730     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
3731         "set the maximum demux-decode delay", "seconds" },
3732     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
3733         "set the initial demux-decode delay", "seconds" },
3734     { "sdp_file", HAS_ARG | OPT_EXPERT | OPT_OUTPUT, { .func_arg = opt_sdp_file },
3735         "specify a file in which to print sdp information", "file" },
3736
3737     { "time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(time_bases) },
3738         "set the desired time base hint for output stream (1:24, 1:48000 or 0.04166, 2.0833e-5)", "ratio" },
3739     { "enc_time_base", HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(enc_time_bases) },
3740         "set the desired time base for the encoder (1:24, 1:48000 or 0.04166, 2.0833e-5). "
3741         "two special values are defined - "
3742         "0 = use frame rate (video) or sample rate (audio),"
3743         "-1 = match source time base", "ratio" },
3744
3745     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
3746         "A comma-separated list of bitstream filters", "bitstream_filters" },
3747     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3748         "deprecated", "audio bitstream_filters" },
3749     { "vbsf", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_old2new },
3750         "deprecated", "video bitstream_filters" },
3751
3752     { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3753         "set the audio options to the indicated preset", "preset" },
3754     { "vpre", OPT_VIDEO | HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,    { .func_arg = opt_preset },
3755         "set the video options to the indicated preset", "preset" },
3756     { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_preset },
3757         "set the subtitle options to the indicated preset", "preset" },
3758     { "fpre", HAS_ARG | OPT_EXPERT| OPT_PERFILE | OPT_OUTPUT,                { .func_arg = opt_preset },
3759         "set options from indicated preset file", "filename" },
3760
3761     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
3762         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
3763
3764     /* data codec support */
3765     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
3766         "force data codec ('copy' to copy stream)", "codec" },
3767     { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET | OPT_INPUT | OPT_OUTPUT, { .off = OFFSET(data_disable) },
3768         "disable data" },
3769
3770 #if CONFIG_VAAPI
3771     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
3772         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
3773 #endif
3774
3775 #if CONFIG_QSV
3776     { "qsv_device", HAS_ARG | OPT_STRING | OPT_EXPERT, { &qsv_device },
3777         "set QSV hardware device (DirectX adapter index, DRM path or X11 display name)", "device"},
3778 #endif
3779
3780     { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device },
3781         "initialise hardware device", "args" },
3782     { "filter_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_filter_hw_device },
3783         "set hardware device used when filtering", "device" },
3784
3785     { NULL, },
3786 };