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

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