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