git.sesse.net Git - ffmpeg/blob - avconv_opt.c

   1 /*
   2  * avconv option parsing
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav 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  * Libav 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 Libav; 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 "avconv.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 "av2pass"
  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 const HWAccel hwaccels[] = {
  59 #if HAVE_VDPAU_X11
  60     { "vdpau", vdpau_init, HWACCEL_VDPAU, AV_PIX_FMT_VDPAU },
  61 #endif
  62 #if HAVE_DXVA2_LIB
  63     { "dxva2", dxva2_init, HWACCEL_DXVA2, AV_PIX_FMT_DXVA2_VLD },
  64 #endif
  65 #if CONFIG_VDA
  66     { "vda",   vda_init,   HWACCEL_VDA,   AV_PIX_FMT_VDA },
  67 #endif
  68 #if CONFIG_LIBMFX
  69     { "qsv",   qsv_init,   HWACCEL_QSV,   AV_PIX_FMT_QSV },
  70 #endif
  71 #if CONFIG_VAAPI
  72     { "vaapi", vaapi_decode_init, HWACCEL_VAAPI, AV_PIX_FMT_VAAPI },
  73 #endif
  74     { 0 },
  75 };
  76 int hwaccel_lax_profile_check = 0;
  77 AVBufferRef *hw_device_ctx;
  78
  79 char *vstats_filename;
  80
  81 float audio_drift_threshold = 0.1;
  82 float dts_delta_threshold   = 10;
  83
  84 int audio_volume      = 256;
  85 int audio_sync_method = 0;
  86 int video_sync_method = VSYNC_AUTO;
  87 int do_benchmark      = 0;
  88 int do_hex_dump       = 0;
  89 int do_pkt_dump       = 0;
  90 int copy_ts           = 0;
  91 int copy_tb           = 1;
  92 int exit_on_error     = 0;
  93 int print_stats       = 1;
  94 int qp_hist           = 0;
  95
  96 static int file_overwrite     = 0;
  97 static int file_skip          = 0;
  98 static int video_discard      = 0;
  99 static int intra_dc_precision = 8;
 100 static int using_stdin        = 0;
 101 static int input_sync;
 102
 103 static void uninit_options(OptionsContext *o)
 104 {
 105     const OptionDef *po = options;
 106     int i;
 107
 108     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 109     while (po->name) {
 110         void *dst = (uint8_t*)o + po->u.off;
 111
 112         if (po->flags & OPT_SPEC) {
 113             SpecifierOpt **so = dst;
 114             int i, *count = (int*)(so + 1);
 115             for (i = 0; i < *count; i++) {
 116                 av_freep(&(*so)[i].specifier);
 117                 if (po->flags & OPT_STRING)
 118                     av_freep(&(*so)[i].u.str);
 119             }
 120             av_freep(so);
 121             *count = 0;
 122         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 123             av_freep(dst);
 124         po++;
 125     }
 126
 127     for (i = 0; i < o->nb_stream_maps; i++)
 128         av_freep(&o->stream_maps[i].linklabel);
 129     av_freep(&o->stream_maps);
 130     av_freep(&o->meta_data_maps);
 131     av_freep(&o->streamid_map);
 132 }
 133
 134 static void init_options(OptionsContext *o)
 135 {
 136     memset(o, 0, sizeof(*o));
 137
 138     o->mux_max_delay  = 0.7;
 139     o->start_time     = AV_NOPTS_VALUE;
 140     o->recording_time = INT64_MAX;
 141     o->limit_filesize = UINT64_MAX;
 142     o->chapters_input_file = INT_MAX;
 143     o->accurate_seek  = 1;
 144 }
 145
 146 /* return a copy of the input with the stream specifiers removed from the keys */
 147 static AVDictionary *strip_specifiers(AVDictionary *dict)
 148 {
 149     AVDictionaryEntry *e = NULL;
 150     AVDictionary    *ret = NULL;
 151
 152     while ((e = av_dict_get(dict, "", e, AV_DICT_IGNORE_SUFFIX))) {
 153         char *p = strchr(e->key, ':');
 154
 155         if (p)
 156             *p = 0;
 157         av_dict_set(&ret, e->key, e->value, 0);
 158         if (p)
 159             *p = ':';
 160     }
 161     return ret;
 162 }
 163
 164 static double parse_frame_aspect_ratio(const char *arg)
 165 {
 166     int x = 0, y = 0;
 167     double ar = 0;
 168     const char *p;
 169     char *end;
 170
 171     p = strchr(arg, ':');
 172     if (p) {
 173         x = strtol(arg, &end, 10);
 174         if (end == p)
 175             y = strtol(end + 1, &end, 10);
 176         if (x > 0 && y > 0)
 177             ar = (double)x / (double)y;
 178     } else
 179         ar = strtod(arg, NULL);
 180
 181     if (!ar) {
 182         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
 183         exit_program(1);
 184     }
 185     return ar;
 186 }
 187
 188 static int show_hwaccels(void *optctx, const char *opt, const char *arg)
 189 {
 190     int i;
 191
 192     printf("Supported hardware acceleration:\n");
 193     for (i = 0; hwaccels[i].name; i++) {
 194         printf("%s\n", hwaccels[i].name);
 195     }
 196     printf("\n");
 197     return 0;
 198 }
 199
 200 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 201 {
 202     OptionsContext *o = optctx;
 203     return parse_option(o, "codec:a", arg, options);
 204 }
 205
 206 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 207 {
 208     OptionsContext *o = optctx;
 209     return parse_option(o, "codec:v", arg, options);
 210 }
 211
 212 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 213 {
 214     OptionsContext *o = optctx;
 215     return parse_option(o, "codec:s", arg, options);
 216 }
 217
 218 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 219 {
 220     OptionsContext *o = optctx;
 221     return parse_option(o, "codec:d", arg, options);
 222 }
 223
 224 static int opt_map(void *optctx, const char *opt, const char *arg)
 225 {
 226     OptionsContext *o = optctx;
 227     StreamMap *m = NULL;
 228     int i, negative = 0, file_idx;
 229     int sync_file_idx = -1, sync_stream_idx;
 230     char *p, *sync;
 231     char *map;
 232
 233     if (*arg == '-') {
 234         negative = 1;
 235         arg++;
 236     }
 237     map = av_strdup(arg);
 238     if (!map)
 239         return AVERROR(ENOMEM);
 240
 241     /* parse sync stream first, just pick first matching stream */
 242     if (sync = strchr(map, ',')) {
 243         *sync = 0;
 244         sync_file_idx = strtol(sync + 1, &sync, 0);
 245         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 246             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 247             exit_program(1);
 248         }
 249         if (*sync)
 250             sync++;
 251         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 252             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 253                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 254                 sync_stream_idx = i;
 255                 break;
 256             }
 257         if (i == input_files[sync_file_idx]->nb_streams) {
 258             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 259                                        "match any streams.\n", arg);
 260             exit_program(1);
 261         }
 262     }
 263
 264
 265     if (map[0] == '[') {
 266         /* this mapping refers to lavfi output */
 267         const char *c = map + 1;
 268         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 269         m = &o->stream_maps[o->nb_stream_maps - 1];
 270         m->linklabel = av_get_token(&c, "]");
 271         if (!m->linklabel) {
 272             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 273             exit_program(1);
 274         }
 275     } else {
 276         file_idx = strtol(map, &p, 0);
 277         if (file_idx >= nb_input_files || file_idx < 0) {
 278             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 279             exit_program(1);
 280         }
 281         if (negative)
 282             /* disable some already defined maps */
 283             for (i = 0; i < o->nb_stream_maps; i++) {
 284                 m = &o->stream_maps[i];
 285                 if (file_idx == m->file_index &&
 286                     check_stream_specifier(input_files[m->file_index]->ctx,
 287                                            input_files[m->file_index]->ctx->streams[m->stream_index],
 288                                            *p == ':' ? p + 1 : p) > 0)
 289                     m->disabled = 1;
 290             }
 291         else
 292             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 293                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 294                             *p == ':' ? p + 1 : p) <= 0)
 295                     continue;
 296                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 297                 m = &o->stream_maps[o->nb_stream_maps - 1];
 298
 299                 m->file_index   = file_idx;
 300                 m->stream_index = i;
 301
 302                 if (sync_file_idx >= 0) {
 303                     m->sync_file_index   = sync_file_idx;
 304                     m->sync_stream_index = sync_stream_idx;
 305                 } else {
 306                     m->sync_file_index   = file_idx;
 307                     m->sync_stream_index = i;
 308                 }
 309             }
 310     }
 311
 312     if (!m) {
 313         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 314         exit_program(1);
 315     }
 316
 317     av_freep(&map);
 318     return 0;
 319 }
 320
 321 static int opt_attach(void *optctx, const char *opt, const char *arg)
 322 {
 323     OptionsContext *o = optctx;
 324     GROW_ARRAY(o->attachments, o->nb_attachments);
 325     o->attachments[o->nb_attachments - 1] = arg;
 326     return 0;
 327 }
 328
 329 #if CONFIG_VAAPI
 330 static int opt_vaapi_device(void *optctx, const char *opt, const char *arg)
 331 {
 332     int err;
 333     err = vaapi_device_init(arg);
 334     if (err < 0)
 335         exit_program(1);
 336     return 0;
 337 }
 338 #endif
 339
 340 /**
 341  * Parse a metadata specifier passed as 'arg' parameter.
 342  * @param arg  metadata string to parse
 343  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 344  * @param index for type c/p, chapter/program index is written here
 345  * @param stream_spec for type s, the stream specifier is written here
 346  */
 347 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 348 {
 349     if (*arg) {
 350         *type = *arg;
 351         switch (*arg) {
 352         case 'g':
 353             break;
 354         case 's':
 355             if (*(++arg) && *arg != ':') {
 356                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 357                 exit_program(1);
 358             }
 359             *stream_spec = *arg == ':' ? arg + 1 : "";
 360             break;
 361         case 'c':
 362         case 'p':
 363             if (*(++arg) == ':')
 364                 *index = strtol(++arg, NULL, 0);
 365             break;
 366         default:
 367             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 368             exit_program(1);
 369         }
 370     } else
 371         *type = 'g';
 372 }
 373
 374 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 375 {
 376     AVDictionary **meta_in = NULL;
 377     AVDictionary **meta_out;
 378     int i, ret = 0;
 379     char type_in, type_out;
 380     const char *istream_spec = NULL, *ostream_spec = NULL;
 381     int idx_in = 0, idx_out = 0;
 382
 383     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 384     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 385
 386     if (type_in == 'g' || type_out == 'g')
 387         o->metadata_global_manual = 1;
 388     if (type_in == 's' || type_out == 's')
 389         o->metadata_streams_manual = 1;
 390     if (type_in == 'c' || type_out == 'c')
 391         o->metadata_chapters_manual = 1;
 392
 393     /* ic is NULL when just disabling automatic mappings */
 394     if (!ic)
 395         return 0;
 396
 397 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
 398     if ((index) < 0 || (index) >= (nb_elems)) {\
 399         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
 400                 (desc), (index));\
 401         exit_program(1);\
 402     }
 403
 404 #define SET_DICT(type, meta, context, index)\
 405         switch (type) {\
 406         case 'g':\
 407             meta = &context->metadata;\
 408             break;\
 409         case 'c':\
 410             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
 411             meta = &context->chapters[index]->metadata;\
 412             break;\
 413         case 'p':\
 414             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
 415             meta = &context->programs[index]->metadata;\
 416             break;\
 417         case 's':\
 418             break; /* handled separately below */ \
 419         default: av_assert0(0);\
 420         }\
 421
 422     SET_DICT(type_in, meta_in, ic, idx_in);
 423     SET_DICT(type_out, meta_out, oc, idx_out);
 424
 425     /* for input streams choose first matching stream */
 426     if (type_in == 's') {
 427         for (i = 0; i < ic->nb_streams; i++) {
 428             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
 429                 meta_in = &ic->streams[i]->metadata;
 430                 break;
 431             } else if (ret < 0)
 432                 exit_program(1);
 433         }
 434         if (!meta_in) {
 435             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
 436             exit_program(1);
 437         }
 438     }
 439
 440     if (type_out == 's') {
 441         for (i = 0; i < oc->nb_streams; i++) {
 442             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
 443                 meta_out = &oc->streams[i]->metadata;
 444                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 445             } else if (ret < 0)
 446                 exit_program(1);
 447         }
 448     } else
 449         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 450
 451     return 0;
 452 }
 453
 454 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 455 {
 456     const AVCodecDescriptor *desc;
 457     const char *codec_string = encoder ? "encoder" : "decoder";
 458     AVCodec *codec;
 459
 460     codec = encoder ?
 461         avcodec_find_encoder_by_name(name) :
 462         avcodec_find_decoder_by_name(name);
 463
 464     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
 465         codec = encoder ? avcodec_find_encoder(desc->id) :
 466                           avcodec_find_decoder(desc->id);
 467         if (codec)
 468             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
 469                    codec_string, codec->name, desc->name);
 470     }
 471
 472     if (!codec) {
 473         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
 474         exit_program(1);
 475     }
 476     if (codec->type != type) {
 477         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 478         exit_program(1);
 479     }
 480     return codec;
 481 }
 482
 483 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
 484 {
 485     char *codec_name = NULL;
 486
 487     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
 488     if (codec_name) {
 489         AVCodec *codec = find_codec_or_die(codec_name, st->codecpar->codec_type, 0);
 490         st->codecpar->codec_id = codec->id;
 491         return codec;
 492     } else
 493         return avcodec_find_decoder(st->codecpar->codec_id);
 494 }
 495
 496 /* Add all the streams from the given input file to the global
 497  * list of input streams. */
 498 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 499 {
 500     int i, ret;
 501
 502     for (i = 0; i < ic->nb_streams; i++) {
 503         AVStream *st = ic->streams[i];
 504         AVCodecParameters *par = st->codecpar;
 505         InputStream *ist = av_mallocz(sizeof(*ist));
 506         char *framerate = NULL, *hwaccel = NULL, *hwaccel_device = NULL;
 507         char *hwaccel_output_format = NULL;
 508         char *codec_tag = NULL;
 509         char *next;
 510
 511         if (!ist)
 512             exit_program(1);
 513
 514         GROW_ARRAY(input_streams, nb_input_streams);
 515         input_streams[nb_input_streams - 1] = ist;
 516
 517         ist->st = st;
 518         ist->file_index = nb_input_files;
 519         ist->discard = 1;
 520         st->discard  = AVDISCARD_ALL;
 521         ist->nb_samples = 0;
 522         ist->min_pts = INT64_MAX;
 523         ist->max_pts = INT64_MIN;
 524
 525         ist->ts_scale = 1.0;
 526         MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
 527
 528         ist->autorotate = 1;
 529         MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
 530
 531         MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
 532         if (codec_tag) {
 533             uint32_t tag = strtol(codec_tag, &next, 0);
 534             if (*next)
 535                 tag = AV_RL32(codec_tag);
 536             st->codecpar->codec_tag = tag;
 537         }
 538
 539         ist->dec = choose_decoder(o, ic, st);
 540         ist->decoder_opts = filter_codec_opts(o->g->codec_opts, par->codec_id, ic, st, ist->dec);
 541
 542         ist->dec_ctx = avcodec_alloc_context3(ist->dec);
 543         if (!ist->dec_ctx) {
 544             av_log(NULL, AV_LOG_ERROR, "Error allocating the decoder context.\n");
 545             exit_program(1);
 546         }
 547
 548         ret = avcodec_parameters_to_context(ist->dec_ctx, par);
 549         if (ret < 0) {
 550             av_log(NULL, AV_LOG_ERROR, "Error initializing the decoder context.\n");
 551             exit_program(1);
 552         }
 553
 554         switch (par->codec_type) {
 555         case AVMEDIA_TYPE_VIDEO:
 556             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 557             if (framerate && av_parse_video_rate(&ist->framerate,
 558                                                  framerate) < 0) {
 559                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 560                        framerate);
 561                 exit_program(1);
 562             }
 563
 564             MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
 565             if (hwaccel) {
 566                 if (!strcmp(hwaccel, "none"))
 567                     ist->hwaccel_id = HWACCEL_NONE;
 568                 else if (!strcmp(hwaccel, "auto"))
 569                     ist->hwaccel_id = HWACCEL_AUTO;
 570                 else {
 571                     int i;
 572                     for (i = 0; hwaccels[i].name; i++) {
 573                         if (!strcmp(hwaccels[i].name, hwaccel)) {
 574                             ist->hwaccel_id = hwaccels[i].id;
 575                             break;
 576                         }
 577                     }
 578
 579                     if (!ist->hwaccel_id) {
 580                         av_log(NULL, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
 581                                hwaccel);
 582                         av_log(NULL, AV_LOG_FATAL, "Supported hwaccels: ");
 583                         for (i = 0; hwaccels[i].name; i++)
 584                             av_log(NULL, AV_LOG_FATAL, "%s ", hwaccels[i].name);
 585                         av_log(NULL, AV_LOG_FATAL, "\n");
 586                         exit_program(1);
 587                     }
 588                 }
 589             }
 590
 591             MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
 592             if (hwaccel_device) {
 593                 ist->hwaccel_device = av_strdup(hwaccel_device);
 594                 if (!ist->hwaccel_device)
 595                     exit_program(1);
 596             }
 597
 598             MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
 599                                  hwaccel_output_format, ic, st);
 600             if (hwaccel_output_format) {
 601                 ist->hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
 602                 if (ist->hwaccel_output_format == AV_PIX_FMT_NONE) {
 603                     av_log(NULL, AV_LOG_FATAL, "Unrecognised hwaccel output "
 604                            "format: %s", hwaccel_output_format);
 605                 }
 606             } else {
 607                 ist->hwaccel_output_format = AV_PIX_FMT_NONE;
 608             }
 609
 610             ist->hwaccel_pix_fmt = AV_PIX_FMT_NONE;
 611
 612             break;
 613         case AVMEDIA_TYPE_AUDIO:
 614             guess_input_channel_layout(ist);
 615             break;
 616         case AVMEDIA_TYPE_DATA:
 617         case AVMEDIA_TYPE_SUBTITLE:
 618         case AVMEDIA_TYPE_ATTACHMENT:
 619         case AVMEDIA_TYPE_UNKNOWN:
 620             break;
 621         default:
 622             abort();
 623         }
 624     }
 625 }
 626
 627 static void assert_file_overwrite(const char *filename)
 628 {
 629     if (file_overwrite && file_skip) {
 630         fprintf(stderr, "Error, both -y and -n supplied. Exiting.\n");
 631         exit_program(1);
 632     }
 633
 634     if (!file_overwrite &&
 635         (!strchr(filename, ':') || filename[1] == ':' ||
 636          av_strstart(filename, "file:", NULL))) {
 637         if (avio_check(filename, 0) == 0) {
 638             if (!using_stdin && !file_skip) {
 639                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 640                 fflush(stderr);
 641                 if (!read_yesno()) {
 642                     fprintf(stderr, "Not overwriting - exiting\n");
 643                     exit_program(1);
 644                 }
 645             }
 646             else {
 647                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
 648                 exit_program(1);
 649             }
 650         }
 651     }
 652 }
 653
 654 static void dump_attachment(AVStream *st, const char *filename)
 655 {
 656     int ret;
 657     AVIOContext *out = NULL;
 658     AVDictionaryEntry *e;
 659
 660     if (!st->codecpar->extradata_size) {
 661         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 662                nb_input_files - 1, st->index);
 663         return;
 664     }
 665     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 666         filename = e->value;
 667     if (!*filename) {
 668         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 669                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 670         exit_program(1);
 671     }
 672
 673     assert_file_overwrite(filename);
 674
 675     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 676         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 677                filename);
 678         exit_program(1);
 679     }
 680
 681     avio_write(out, st->codecpar->extradata, st->codecpar->extradata_size);
 682     avio_flush(out);
 683     avio_close(out);
 684 }
 685
 686 static int open_input_file(OptionsContext *o, const char *filename)
 687 {
 688     InputFile *f;
 689     AVFormatContext *ic;
 690     AVInputFormat *file_iformat = NULL;
 691     int err, i, ret;
 692     int64_t timestamp;
 693     uint8_t buf[128];
 694     AVDictionary **opts;
 695     AVDictionary *unused_opts = NULL;
 696     AVDictionaryEntry *e = NULL;
 697     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
 698
 699     if (o->format) {
 700         if (!(file_iformat = av_find_input_format(o->format))) {
 701             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
 702             exit_program(1);
 703         }
 704     }
 705
 706     if (!strcmp(filename, "-"))
 707         filename = "pipe:";
 708
 709     using_stdin |= !strncmp(filename, "pipe:", 5) ||
 710                     !strcmp(filename, "/dev/stdin");
 711
 712     /* get default parameters from command line */
 713     ic = avformat_alloc_context();
 714     if (!ic) {
 715         print_error(filename, AVERROR(ENOMEM));
 716         exit_program(1);
 717     }
 718     if (o->nb_audio_sample_rate) {
 719         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
 720         av_dict_set(&o->g->format_opts, "sample_rate", buf, 0);
 721     }
 722     if (o->nb_audio_channels) {
 723         /* because we set audio_channels based on both the "ac" and
 724          * "channel_layout" options, we need to check that the specified
 725          * demuxer actually has the "channels" option before setting it */
 726         if (file_iformat && file_iformat->priv_class &&
 727             av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
 728                         AV_OPT_SEARCH_FAKE_OBJ)) {
 729             snprintf(buf, sizeof(buf), "%d",
 730                      o->audio_channels[o->nb_audio_channels - 1].u.i);
 731             av_dict_set(&o->g->format_opts, "channels", buf, 0);
 732         }
 733     }
 734     if (o->nb_frame_rates) {
 735         /* set the format-level framerate option;
 736          * this is important for video grabbers, e.g. x11 */
 737         if (file_iformat && file_iformat->priv_class &&
 738             av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
 739                         AV_OPT_SEARCH_FAKE_OBJ)) {
 740             av_dict_set(&o->g->format_opts, "framerate",
 741                         o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
 742         }
 743     }
 744     if (o->nb_frame_sizes) {
 745         av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
 746     }
 747     if (o->nb_frame_pix_fmts)
 748         av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
 749
 750     ic->flags |= AVFMT_FLAG_NONBLOCK;
 751     ic->interrupt_callback = int_cb;
 752
 753     /* open the input file with generic Libav function */
 754     err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
 755     if (err < 0) {
 756         print_error(filename, err);
 757         exit_program(1);
 758     }
 759     assert_avoptions(o->g->format_opts);
 760
 761     /* apply forced codec ids */
 762     for (i = 0; i < ic->nb_streams; i++)
 763         choose_decoder(o, ic, ic->streams[i]);
 764
 765     /* Set AVCodecContext options for avformat_find_stream_info */
 766     opts = setup_find_stream_info_opts(ic, o->g->codec_opts);
 767     orig_nb_streams = ic->nb_streams;
 768
 769     /* If not enough info to get the stream parameters, we decode the
 770        first frames to get it. (used in mpeg case for example) */
 771     ret = avformat_find_stream_info(ic, opts);
 772     if (ret < 0) {
 773         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
 774         avformat_close_input(&ic);
 775         exit_program(1);
 776     }
 777
 778     timestamp = (o->start_time == AV_NOPTS_VALUE) ? 0 : o->start_time;
 779     /* add the stream start time */
 780     if (ic->start_time != AV_NOPTS_VALUE)
 781         timestamp += ic->start_time;
 782
 783     /* if seeking requested, we execute it */
 784     if (o->start_time != AV_NOPTS_VALUE) {
 785         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
 786         if (ret < 0) {
 787             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
 788                    filename, (double)timestamp / AV_TIME_BASE);
 789         }
 790     }
 791
 792     /* update the current parameters so that they match the one of the input stream */
 793     add_input_streams(o, ic);
 794
 795     /* dump the file content */
 796     av_dump_format(ic, nb_input_files, filename, 0);
 797
 798     GROW_ARRAY(input_files, nb_input_files);
 799     f = av_mallocz(sizeof(*f));
 800     if (!f)
 801         exit_program(1);
 802     input_files[nb_input_files - 1] = f;
 803
 804     f->ctx        = ic;
 805     f->ist_index  = nb_input_streams - ic->nb_streams;
 806     f->start_time = o->start_time;
 807     f->recording_time = o->recording_time;
 808     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 809     f->nb_streams = ic->nb_streams;
 810     f->rate_emu   = o->rate_emu;
 811     f->accurate_seek = o->accurate_seek;
 812     f->loop = o->loop;
 813     f->duration = 0;
 814     f->time_base = (AVRational){ 1, 1 };
 815
 816     /* check if all codec options have been used */
 817     unused_opts = strip_specifiers(o->g->codec_opts);
 818     for (i = f->ist_index; i < nb_input_streams; i++) {
 819         e = NULL;
 820         while ((e = av_dict_get(input_streams[i]->decoder_opts, "", e,
 821                                 AV_DICT_IGNORE_SUFFIX)))
 822             av_dict_set(&unused_opts, e->key, NULL, 0);
 823     }
 824
 825     e = NULL;
 826     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
 827         const AVClass *class = avcodec_get_class();
 828         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
 829                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
 830         if (!option)
 831             continue;
 832         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
 833             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
 834                    "input file #%d (%s) is not a decoding option.\n", e->key,
 835                    option->help ? option->help : "", nb_input_files - 1,
 836                    filename);
 837             exit_program(1);
 838         }
 839
 840         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
 841                "input file #%d (%s) has not been used for any stream. The most "
 842                "likely reason is either wrong type (e.g. a video option with "
 843                "no video streams) or that it is a private option of some decoder "
 844                "which was not actually used for any stream.\n", e->key,
 845                option->help ? option->help : "", nb_input_files - 1, filename);
 846     }
 847     av_dict_free(&unused_opts);
 848
 849     for (i = 0; i < o->nb_dump_attachment; i++) {
 850         int j;
 851
 852         for (j = 0; j < ic->nb_streams; j++) {
 853             AVStream *st = ic->streams[j];
 854
 855             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 856                 dump_attachment(st, o->dump_attachment[i].u.str);
 857         }
 858     }
 859
 860     for (i = 0; i < orig_nb_streams; i++)
 861         av_dict_free(&opts[i]);
 862     av_freep(&opts);
 863
 864     return 0;
 865 }
 866
 867 static uint8_t *get_line(AVIOContext *s)
 868 {
 869     AVIOContext *line;
 870     uint8_t *buf;
 871     char c;
 872
 873     if (avio_open_dyn_buf(&line) < 0) {
 874         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 875         exit_program(1);
 876     }
 877
 878     while ((c = avio_r8(s)) && c != '\n')
 879         avio_w8(line, c);
 880     avio_w8(line, 0);
 881     avio_close_dyn_buf(line, &buf);
 882
 883     return buf;
 884 }
 885
 886 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 887 {
 888     int i, ret = -1;
 889     char filename[1000];
 890     const char *base[3] = { getenv("AVCONV_DATADIR"),
 891                             getenv("HOME"),
 892                             AVCONV_DATADIR,
 893                             };
 894
 895     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret < 0; i++) {
 896         if (!base[i])
 897             continue;
 898         if (codec_name) {
 899             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 900                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 901             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 902         }
 903         if (ret < 0) {
 904             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 905                      i != 1 ? "" : "/.avconv", preset_name);
 906             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 907         }
 908     }
 909     return ret;
 910 }
 911
 912 static int choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 913 {
 914     enum AVMediaType type = ost->st->codecpar->codec_type;
 915     char *codec_name = NULL;
 916
 917     if (type == AVMEDIA_TYPE_VIDEO || type == AVMEDIA_TYPE_AUDIO || type == AVMEDIA_TYPE_SUBTITLE) {
 918         MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 919         if (!codec_name) {
 920             ost->st->codecpar->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 921                                                          NULL, ost->st->codecpar->codec_type);
 922             ost->enc = avcodec_find_encoder(ost->st->codecpar->codec_id);
 923             if (!ost->enc) {
 924                 av_log(NULL, AV_LOG_FATAL, "Automatic encoder selection failed for "
 925                        "output stream #%d:%d. Default encoder for format %s is "
 926                        "probably disabled. Please choose an encoder manually.\n",
 927                        ost->file_index, ost->index, s->oformat->name);
 928                 return AVERROR_ENCODER_NOT_FOUND;
 929             }
 930         } else if (!strcmp(codec_name, "copy"))
 931             ost->stream_copy = 1;
 932         else {
 933             ost->enc = find_codec_or_die(codec_name, ost->st->codecpar->codec_type, 1);
 934             ost->st->codecpar->codec_id = ost->enc->id;
 935         }
 936
 937         ost->encoding_needed = !ost->stream_copy;
 938     } else {
 939         /* no encoding supported for other media types */
 940         ost->stream_copy     = 1;
 941         ost->encoding_needed = 0;
 942     }
 943
 944     return 0;
 945 }
 946
 947 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
 948 {
 949     OutputStream *ost;
 950     AVStream *st = avformat_new_stream(oc, NULL);
 951     int idx      = oc->nb_streams - 1, ret = 0;
 952     const char *bsfs = NULL;
 953     char *next, *codec_tag = NULL;
 954     double qscale = -1;
 955
 956     if (!st) {
 957         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 958         exit_program(1);
 959     }
 960
 961     if (oc->nb_streams - 1 < o->nb_streamid_map)
 962         st->id = o->streamid_map[oc->nb_streams - 1];
 963
 964     GROW_ARRAY(output_streams, nb_output_streams);
 965     if (!(ost = av_mallocz(sizeof(*ost))))
 966         exit_program(1);
 967     output_streams[nb_output_streams - 1] = ost;
 968
 969     ost->file_index = nb_output_files - 1;
 970     ost->index      = idx;
 971     ost->st         = st;
 972     st->codecpar->codec_type = type;
 973
 974     ret = choose_encoder(o, oc, ost);
 975     if (ret < 0) {
 976         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
 977                "%d:%d\n", ost->file_index, ost->index);
 978         exit_program(1);
 979     }
 980
 981     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
 982     if (!ost->enc_ctx) {
 983         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
 984         exit_program(1);
 985     }
 986     ost->enc_ctx->codec_type = type;
 987
 988     if (ost->enc) {
 989         AVIOContext *s = NULL;
 990         char *buf = NULL, *arg = NULL, *preset = NULL;
 991
 992         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 993
 994         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 995         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 996             do  {
 997                 buf = get_line(s);
 998                 if (!buf[0] || buf[0] == '#') {
 999                     av_free(buf);
1000                     continue;
1001                 }
1002                 if (!(arg = strchr(buf, '='))) {
1003                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1004                     exit_program(1);
1005                 }
1006                 *arg++ = 0;
1007                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1008                 av_free(buf);
1009             } while (!s->eof_reached);
1010             avio_close(s);
1011         }
1012         if (ret) {
1013             av_log(NULL, AV_LOG_FATAL,
1014                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1015                    preset, ost->file_index, ost->index);
1016             exit_program(1);
1017         }
1018     } else {
1019         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1020     }
1021
1022     ost->max_frames = INT64_MAX;
1023     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1024
1025     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1026     while (bsfs && *bsfs) {
1027         const AVBitStreamFilter *filter;
1028         const char *bsf, *bsf_options_str, *bsf_name;
1029         AVDictionary *bsf_options = NULL;
1030
1031         bsf = bsf_options_str = av_get_token(&bsfs, ",");
1032         if (!bsf)
1033             exit_program(1);
1034         bsf_name = av_get_token(&bsf_options_str, "=");
1035         if (!bsf_name)
1036             exit_program(1);
1037
1038         filter = av_bsf_get_by_name(bsf_name);
1039         if (!filter) {
1040             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1041             exit_program(1);
1042         }
1043         if (*bsf_options_str++) {
1044             ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
1045             if (ret < 0) {
1046                 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1047                 exit_program(1);
1048             }
1049         }
1050         av_freep(&bsf);
1051
1052         ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1053                                         ost->nb_bitstream_filters + 1,
1054                                         sizeof(*ost->bsf_ctx));
1055         if (!ost->bsf_ctx)
1056             exit_program(1);
1057
1058         ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1059         if (ret < 0) {
1060             av_log(NULL, AV_LOG_ERROR, "Error allocating a bistream filter context\n");
1061             exit_program(1);
1062         }
1063         ost->nb_bitstream_filters++;
1064
1065         if (bsf_options) {
1066             ret = av_opt_set_dict(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, &bsf_options);
1067             if (ret < 0) {
1068                 av_log(NULL, AV_LOG_ERROR, "Error setting options for bitstream filter %s\n", bsf_name);
1069                 exit_program(1);
1070             }
1071             assert_avoptions(bsf_options);
1072             av_dict_free(&bsf_options);
1073         }
1074         av_freep(&bsf_name);
1075
1076         if (*bsfs)
1077             bsfs++;
1078     }
1079
1080     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1081     if (codec_tag) {
1082         uint32_t tag = strtol(codec_tag, &next, 0);
1083         if (*next)
1084             tag = AV_RL32(codec_tag);
1085         ost->enc_ctx->codec_tag = tag;
1086     }
1087
1088     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1089     if (qscale >= 0) {
1090         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1091         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1092     }
1093
1094     ost->max_muxing_queue_size = 128;
1095     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1096     ost->max_muxing_queue_size *= sizeof(AVPacket);
1097
1098     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1099         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1100
1101     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1102
1103     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1104
1105     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1106     ost->last_mux_dts = AV_NOPTS_VALUE;
1107
1108     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1109     if (!ost->muxing_queue)
1110         exit_program(1);
1111
1112     return ost;
1113 }
1114
1115 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1116 {
1117     int i;
1118     const char *p = str;
1119     for (i = 0;; i++) {
1120         dest[i] = atoi(p);
1121         if (i == 63)
1122             break;
1123         p = strchr(p, ',');
1124         if (!p) {
1125             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1126             exit_program(1);
1127         }
1128         p++;
1129     }
1130 }
1131
1132 /* read file contents into a string */
1133 static uint8_t *read_file(const char *filename)
1134 {
1135     AVIOContext *pb      = NULL;
1136     AVIOContext *dyn_buf = NULL;
1137     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1138     uint8_t buf[1024], *str;
1139
1140     if (ret < 0) {
1141         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1142         return NULL;
1143     }
1144
1145     ret = avio_open_dyn_buf(&dyn_buf);
1146     if (ret < 0) {
1147         avio_closep(&pb);
1148         return NULL;
1149     }
1150     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1151         avio_write(dyn_buf, buf, ret);
1152     avio_w8(dyn_buf, 0);
1153     avio_closep(&pb);
1154
1155     ret = avio_close_dyn_buf(dyn_buf, &str);
1156     if (ret < 0)
1157         return NULL;
1158     return str;
1159 }
1160
1161 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1162                              OutputStream *ost)
1163 {
1164     AVStream *st = ost->st;
1165     char *filter = NULL, *filter_script = NULL;
1166
1167     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1168     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1169
1170     if (filter_script && filter) {
1171         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1172                "output stream #%d:%d.\n", nb_output_files, st->index);
1173         exit_program(1);
1174     }
1175
1176     if (filter_script)
1177         return read_file(filter_script);
1178     else if (filter)
1179         return av_strdup(filter);
1180
1181     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1182                      "null" : "anull");
1183 }
1184
1185 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1186 {
1187     AVStream *st;
1188     OutputStream *ost;
1189     AVCodecContext *video_enc;
1190     char *frame_aspect_ratio = NULL;
1191
1192     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1193     st  = ost->st;
1194     video_enc = ost->enc_ctx;
1195
1196     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1197     if (frame_aspect_ratio)
1198         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1199
1200     if (!ost->stream_copy) {
1201         const char *p = NULL;
1202         char *frame_rate = NULL, *frame_size = NULL;
1203         char *frame_pix_fmt = NULL;
1204         char *intra_matrix = NULL, *inter_matrix = NULL;
1205         int do_pass = 0;
1206         int i;
1207
1208         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1209         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1210             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1211             exit_program(1);
1212         }
1213
1214         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1215         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1216             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1217             exit_program(1);
1218         }
1219
1220         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1221         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1222             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1223             exit_program(1);
1224         }
1225         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1226
1227         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1228         if (intra_matrix) {
1229             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1230                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1231                 exit_program(1);
1232             }
1233             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1234         }
1235         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1236         if (inter_matrix) {
1237             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1238                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1239                 exit_program(1);
1240             }
1241             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1242         }
1243
1244         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1245         for (i = 0; p; i++) {
1246             int start, end, q;
1247             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1248             if (e != 3) {
1249                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1250                 exit_program(1);
1251             }
1252             video_enc->rc_override =
1253                 av_realloc(video_enc->rc_override,
1254                            sizeof(RcOverride) * (i + 1));
1255             if (!video_enc->rc_override) {
1256                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1257                 exit_program(1);
1258             }
1259             video_enc->rc_override[i].start_frame = start;
1260             video_enc->rc_override[i].end_frame   = end;
1261             if (q > 0) {
1262                 video_enc->rc_override[i].qscale         = q;
1263                 video_enc->rc_override[i].quality_factor = 1.0;
1264             }
1265             else {
1266                 video_enc->rc_override[i].qscale         = 0;
1267                 video_enc->rc_override[i].quality_factor = -q/100.0;
1268             }
1269             p = strchr(p, '/');
1270             if (p) p++;
1271         }
1272         video_enc->rc_override_count = i;
1273         video_enc->intra_dc_precision = intra_dc_precision - 8;
1274
1275         /* two pass mode */
1276         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1277         if (do_pass) {
1278             if (do_pass == 1) {
1279                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1280             } else {
1281                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1282             }
1283         }
1284
1285         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1286         if (ost->logfile_prefix &&
1287             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1288             exit_program(1);
1289
1290         if (do_pass) {
1291             char logfilename[1024];
1292             FILE *f;
1293
1294             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1295                      ost->logfile_prefix ? ost->logfile_prefix :
1296                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1297                      i);
1298             if (!strcmp(ost->enc->name, "libx264")) {
1299                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1300             } else {
1301                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1302                     f = fopen(logfilename, "wb");
1303                     if (!f) {
1304                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1305                                logfilename, strerror(errno));
1306                         exit_program(1);
1307                     }
1308                     ost->logfile = f;
1309                 } else {
1310                     char  *logbuffer = read_file(logfilename);
1311
1312                     if (!logbuffer) {
1313                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1314                                logfilename);
1315                         exit_program(1);
1316                     }
1317                     video_enc->stats_in = logbuffer;
1318                 }
1319             }
1320         }
1321
1322         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1323         if (ost->forced_keyframes)
1324             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1325
1326         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1327
1328         ost->top_field_first = -1;
1329         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1330
1331
1332         ost->avfilter = get_ost_filters(o, oc, ost);
1333         if (!ost->avfilter)
1334             exit_program(1);
1335     } else {
1336         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1337     }
1338
1339     return ost;
1340 }
1341
1342 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1343 {
1344     AVStream *st;
1345     OutputStream *ost;
1346     AVCodecContext *audio_enc;
1347
1348     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1349     st  = ost->st;
1350
1351     audio_enc = ost->enc_ctx;
1352     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1353
1354     if (!ost->stream_copy) {
1355         char *sample_fmt = NULL;
1356
1357         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1358
1359         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1360         if (sample_fmt &&
1361             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1362             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1363             exit_program(1);
1364         }
1365
1366         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1367
1368         ost->avfilter = get_ost_filters(o, oc, ost);
1369         if (!ost->avfilter)
1370             exit_program(1);
1371     }
1372
1373     return ost;
1374 }
1375
1376 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1377 {
1378     OutputStream *ost;
1379
1380     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1381     if (!ost->stream_copy) {
1382         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1383         exit_program(1);
1384     }
1385
1386     return ost;
1387 }
1388
1389 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1390 {
1391     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1392     ost->stream_copy = 1;
1393     ost->finished    = 1;
1394     return ost;
1395 }
1396
1397 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1398 {
1399     OutputStream *ost;
1400     AVCodecContext *subtitle_enc;
1401
1402     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1403     subtitle_enc = ost->enc_ctx;
1404
1405     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1406
1407     return ost;
1408 }
1409
1410 /* arg format is "output-stream-index:streamid-value". */
1411 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1412 {
1413     OptionsContext *o = optctx;
1414     int idx;
1415     char *p;
1416     char idx_str[16];
1417
1418     av_strlcpy(idx_str, arg, sizeof(idx_str));
1419     p = strchr(idx_str, ':');
1420     if (!p) {
1421         av_log(NULL, AV_LOG_FATAL,
1422                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1423                arg, opt);
1424         exit_program(1);
1425     }
1426     *p++ = '\0';
1427     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1428     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1429     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1430     return 0;
1431 }
1432
1433 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1434 {
1435     AVFormatContext *is = ifile->ctx;
1436     AVFormatContext *os = ofile->ctx;
1437     AVChapter **tmp;
1438     int i;
1439
1440     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1441     if (!tmp)
1442         return AVERROR(ENOMEM);
1443     os->chapters = tmp;
1444
1445     for (i = 0; i < is->nb_chapters; i++) {
1446         AVChapter *in_ch = is->chapters[i], *out_ch;
1447         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1448         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1449                                        AV_TIME_BASE_Q, in_ch->time_base);
1450         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1451                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1452
1453
1454         if (in_ch->end < ts_off)
1455             continue;
1456         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1457             break;
1458
1459         out_ch = av_mallocz(sizeof(AVChapter));
1460         if (!out_ch)
1461             return AVERROR(ENOMEM);
1462
1463         out_ch->id        = in_ch->id;
1464         out_ch->time_base = in_ch->time_base;
1465         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1466         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1467
1468         if (copy_metadata)
1469             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1470
1471         os->chapters[os->nb_chapters++] = out_ch;
1472     }
1473     return 0;
1474 }
1475
1476 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1477                                AVFormatContext *oc)
1478 {
1479     OutputStream *ost;
1480
1481     switch (ofilter->type) {
1482     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1483     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1484     default:
1485         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1486                "currently.\n");
1487         exit_program(1);
1488     }
1489
1490     ost->source_index = -1;
1491     ost->filter       = ofilter;
1492
1493     ofilter->ost      = ost;
1494     ofilter->format   = -1;
1495
1496     if (ost->stream_copy) {
1497         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1498                "which is fed from a complex filtergraph. Filtering and streamcopy "
1499                "cannot be used together.\n", ost->file_index, ost->index);
1500         exit_program(1);
1501     }
1502
1503     avfilter_inout_free(&ofilter->out_tmp);
1504 }
1505
1506 static int init_complex_filters(void)
1507 {
1508     int i, ret = 0;
1509
1510     for (i = 0; i < nb_filtergraphs; i++) {
1511         ret = init_complex_filtergraph(filtergraphs[i]);
1512         if (ret < 0)
1513             return ret;
1514     }
1515     return 0;
1516 }
1517
1518 static int open_output_file(OptionsContext *o, const char *filename)
1519 {
1520     AVFormatContext *oc;
1521     int i, j, err;
1522     AVOutputFormat *file_oformat;
1523     OutputFile *of;
1524     OutputStream *ost;
1525     InputStream  *ist;
1526     AVDictionary *unused_opts = NULL;
1527     AVDictionaryEntry *e = NULL;
1528
1529     GROW_ARRAY(output_files, nb_output_files);
1530     of = av_mallocz(sizeof(*of));
1531     if (!of)
1532         exit_program(1);
1533     output_files[nb_output_files - 1] = of;
1534
1535     of->ost_index      = nb_output_streams;
1536     of->recording_time = o->recording_time;
1537     of->start_time     = o->start_time;
1538     of->limit_filesize = o->limit_filesize;
1539     of->shortest       = o->shortest;
1540     av_dict_copy(&of->opts, o->g->format_opts, 0);
1541
1542     if (!strcmp(filename, "-"))
1543         filename = "pipe:";
1544
1545     oc = avformat_alloc_context();
1546     if (!oc) {
1547         print_error(filename, AVERROR(ENOMEM));
1548         exit_program(1);
1549     }
1550     of->ctx = oc;
1551     if (o->recording_time != INT64_MAX)
1552         oc->duration = o->recording_time;
1553
1554     if (o->format) {
1555         file_oformat = av_guess_format(o->format, NULL, NULL);
1556         if (!file_oformat) {
1557             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1558             exit_program(1);
1559         }
1560     } else {
1561         file_oformat = av_guess_format(NULL, filename, NULL);
1562         if (!file_oformat) {
1563             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1564                    filename);
1565             exit_program(1);
1566         }
1567     }
1568
1569     oc->oformat = file_oformat;
1570     oc->interrupt_callback = int_cb;
1571     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1572
1573     /* create streams for all unlabeled output pads */
1574     for (i = 0; i < nb_filtergraphs; i++) {
1575         FilterGraph *fg = filtergraphs[i];
1576         for (j = 0; j < fg->nb_outputs; j++) {
1577             OutputFilter *ofilter = fg->outputs[j];
1578
1579             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1580                 continue;
1581
1582             switch (ofilter->type) {
1583             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1584             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1585             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1586             }
1587             init_output_filter(ofilter, o, oc);
1588         }
1589     }
1590
1591     if (!o->nb_stream_maps) {
1592         /* pick the "best" stream of each type */
1593 #define NEW_STREAM(type, index)\
1594         if (index >= 0) {\
1595             ost = new_ ## type ## _stream(o, oc);\
1596             ost->source_index = index;\
1597             ost->sync_ist     = input_streams[index];\
1598             input_streams[index]->discard = 0;\
1599             input_streams[index]->st->discard = AVDISCARD_NONE;\
1600         }
1601
1602         /* video: highest resolution */
1603         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1604             int area = 0, idx = -1;
1605             for (i = 0; i < nb_input_streams; i++) {
1606                 ist = input_streams[i];
1607                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1608                     ist->st->codecpar->width * ist->st->codecpar->height > area) {
1609                     area = ist->st->codecpar->width * ist->st->codecpar->height;
1610                     idx = i;
1611                 }
1612             }
1613             NEW_STREAM(video, idx);
1614         }
1615
1616         /* audio: most channels */
1617         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1618             int channels = 0, idx = -1;
1619             for (i = 0; i < nb_input_streams; i++) {
1620                 ist = input_streams[i];
1621                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1622                     ist->st->codecpar->channels > channels) {
1623                     channels = ist->st->codecpar->channels;
1624                     idx = i;
1625                 }
1626             }
1627             NEW_STREAM(audio, idx);
1628         }
1629
1630         /* subtitles: pick first */
1631         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1632             for (i = 0; i < nb_input_streams; i++)
1633                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1634                     NEW_STREAM(subtitle, i);
1635                     break;
1636                 }
1637         }
1638         /* do something with data? */
1639     } else {
1640         for (i = 0; i < o->nb_stream_maps; i++) {
1641             StreamMap *map = &o->stream_maps[i];
1642
1643             if (map->disabled)
1644                 continue;
1645
1646             if (map->linklabel) {
1647                 FilterGraph *fg;
1648                 OutputFilter *ofilter = NULL;
1649                 int j, k;
1650
1651                 for (j = 0; j < nb_filtergraphs; j++) {
1652                     fg = filtergraphs[j];
1653                     for (k = 0; k < fg->nb_outputs; k++) {
1654                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1655                         if (out && !strcmp(out->name, map->linklabel)) {
1656                             ofilter = fg->outputs[k];
1657                             goto loop_end;
1658                         }
1659                     }
1660                 }
1661 loop_end:
1662                 if (!ofilter) {
1663                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1664                            "in any defined filter graph.\n", map->linklabel);
1665                     exit_program(1);
1666                 }
1667                 init_output_filter(ofilter, o, oc);
1668             } else {
1669                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1670                 switch (ist->st->codecpar->codec_type) {
1671                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1672                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1673                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1674                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1675                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1676                 default:
1677                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1678                            map->file_index, map->stream_index);
1679                     exit_program(1);
1680                 }
1681
1682                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1683                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1684                                                map->sync_stream_index];
1685                 ist->discard = 0;
1686                 ist->st->discard = AVDISCARD_NONE;
1687             }
1688         }
1689     }
1690
1691     /* handle attached files */
1692     for (i = 0; i < o->nb_attachments; i++) {
1693         AVIOContext *pb;
1694         uint8_t *attachment;
1695         const char *p;
1696         int64_t len;
1697
1698         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1699             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1700                    o->attachments[i]);
1701             exit_program(1);
1702         }
1703         if ((len = avio_size(pb)) <= 0) {
1704             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1705                    o->attachments[i]);
1706             exit_program(1);
1707         }
1708         if (!(attachment = av_malloc(len))) {
1709             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1710                    o->attachments[i]);
1711             exit_program(1);
1712         }
1713         avio_read(pb, attachment, len);
1714
1715         ost = new_attachment_stream(o, oc);
1716         ost->stream_copy               = 0;
1717         ost->source_index              = -1;
1718         ost->attachment_filename       = o->attachments[i];
1719         ost->st->codecpar->extradata      = attachment;
1720         ost->st->codecpar->extradata_size = len;
1721
1722         p = strrchr(o->attachments[i], '/');
1723         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1724         avio_close(pb);
1725     }
1726
1727     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1728         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1729         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1730         exit_program(1);
1731     }
1732
1733     /* check if all codec options have been used */
1734     unused_opts = strip_specifiers(o->g->codec_opts);
1735     for (i = of->ost_index; i < nb_output_streams; i++) {
1736         e = NULL;
1737         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1738                                 AV_DICT_IGNORE_SUFFIX)))
1739             av_dict_set(&unused_opts, e->key, NULL, 0);
1740     }
1741
1742     e = NULL;
1743     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1744         const AVClass *class = avcodec_get_class();
1745         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1746                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1747         if (!option)
1748             continue;
1749         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1750             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1751                    "output file #%d (%s) is not an encoding option.\n", e->key,
1752                    option->help ? option->help : "", nb_output_files - 1,
1753                    filename);
1754             exit_program(1);
1755         }
1756
1757         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1758                "output file #%d (%s) has not been used for any stream. The most "
1759                "likely reason is either wrong type (e.g. a video option with "
1760                "no video streams) or that it is a private option of some encoder "
1761                "which was not actually used for any stream.\n", e->key,
1762                option->help ? option->help : "", nb_output_files - 1, filename);
1763     }
1764     av_dict_free(&unused_opts);
1765
1766     /* set the decoding_needed flags and create simple filtergraphs */
1767     for (i = of->ost_index; i < nb_output_streams; i++) {
1768         OutputStream *ost = output_streams[i];
1769
1770         if (ost->encoding_needed && ost->source_index >= 0) {
1771             InputStream *ist = input_streams[ost->source_index];
1772             ist->decoding_needed = 1;
1773
1774             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1775                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1776                 err = init_simple_filtergraph(ist, ost);
1777                 if (err < 0) {
1778                     av_log(NULL, AV_LOG_ERROR,
1779                            "Error initializing a simple filtergraph between streams "
1780                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1781                            nb_output_files - 1, ost->st->index);
1782                     exit_program(1);
1783                 }
1784             }
1785         }
1786
1787         /*
1788          * We want CFR output if and only if one of those is true:
1789          * 1) user specified output framerate with -r
1790          * 2) user specified -vsync cfr
1791          * 3) output format is CFR and the user didn't force vsync to
1792          *    something else than CFR
1793          *
1794          * in such a case, set ost->frame_rate
1795          */
1796         if (ost->encoding_needed && ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1797             int format_cfr = !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS));
1798             int need_cfr = !!ost->frame_rate.num;
1799
1800             if (video_sync_method == VSYNC_CFR ||
1801                 (video_sync_method == VSYNC_AUTO && format_cfr))
1802                 need_cfr = 1;
1803
1804             if (need_cfr && !ost->frame_rate.num) {
1805                 InputStream *ist = ost->source_index >= 0 ? input_streams[ost->source_index] : NULL;
1806
1807                 if (ist && ist->framerate.num)
1808                     ost->frame_rate = ist->framerate;
1809                 else if (ist && ist->st->avg_frame_rate.num)
1810                     ost->frame_rate = ist->st->avg_frame_rate;
1811                 else {
1812                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1813                            "for the output stream #%d:%d, but no information "
1814                            "about the input framerate is available. Falling "
1815                            "back to a default value of 25fps. Use the -r option "
1816                            "if you want a different framerate.\n",
1817                            ost->file_index, ost->index);
1818                     ost->frame_rate = (AVRational){ 25, 1 };
1819                 }
1820             }
1821
1822             if (need_cfr && ost->enc->supported_framerates && !ost->force_fps) {
1823                 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1824                 ost->frame_rate = ost->enc->supported_framerates[idx];
1825             }
1826         }
1827
1828         /* set the filter output constraints */
1829         if (ost->filter) {
1830             OutputFilter *f = ost->filter;
1831             int count;
1832             switch (ost->enc_ctx->codec_type) {
1833             case AVMEDIA_TYPE_VIDEO:
1834                 f->frame_rate = ost->frame_rate;
1835                 f->width      = ost->enc_ctx->width;
1836                 f->height     = ost->enc_ctx->height;
1837                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
1838                     f->format = ost->enc_ctx->pix_fmt;
1839                 } else if (ost->enc->pix_fmts) {
1840                     count = 0;
1841                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
1842                         count++;
1843                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1844                     if (!f->formats)
1845                         exit_program(1);
1846                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
1847                 }
1848                 break;
1849             case AVMEDIA_TYPE_AUDIO:
1850                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
1851                     f->format = ost->enc_ctx->sample_fmt;
1852                 } else if (ost->enc->sample_fmts) {
1853                     count = 0;
1854                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
1855                         count++;
1856                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1857                     if (!f->formats)
1858                         exit_program(1);
1859                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
1860                 }
1861                 if (ost->enc_ctx->sample_rate) {
1862                     f->sample_rate = ost->enc_ctx->sample_rate;
1863                 } else if (ost->enc->supported_samplerates) {
1864                     count = 0;
1865                     while (ost->enc->supported_samplerates[count])
1866                         count++;
1867                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
1868                     if (!f->sample_rates)
1869                         exit_program(1);
1870                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
1871                            (count + 1) * sizeof(*f->sample_rates));
1872                 }
1873                 if (ost->enc_ctx->channels) {
1874                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
1875                 } else if (ost->enc->channel_layouts) {
1876                     count = 0;
1877                     while (ost->enc->channel_layouts[count])
1878                         count++;
1879                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
1880                     if (!f->channel_layouts)
1881                         exit_program(1);
1882                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
1883                            (count + 1) * sizeof(*f->channel_layouts));
1884                 }
1885                 break;
1886             }
1887         }
1888
1889     }
1890
1891     /* check filename in case of an image number is expected */
1892     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1893         if (!av_filename_number_test(oc->filename)) {
1894             print_error(oc->filename, AVERROR(EINVAL));
1895             exit_program(1);
1896         }
1897     }
1898
1899     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1900         /* test if it already exists to avoid losing precious files */
1901         assert_file_overwrite(filename);
1902
1903         /* open the file */
1904         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1905                               &oc->interrupt_callback,
1906                               &of->opts)) < 0) {
1907             print_error(filename, err);
1908             exit_program(1);
1909         }
1910     }
1911
1912     if (o->mux_preload) {
1913         uint8_t buf[64];
1914         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1915         av_dict_set(&of->opts, "preload", buf, 0);
1916     }
1917     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1918     oc->flags |= AVFMT_FLAG_NONBLOCK;
1919
1920     /* copy metadata */
1921     for (i = 0; i < o->nb_metadata_map; i++) {
1922         char *p;
1923         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1924
1925         if (in_file_index >= nb_input_files) {
1926             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1927             exit_program(1);
1928         }
1929         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1930                       in_file_index >= 0 ?
1931                       input_files[in_file_index]->ctx : NULL, o);
1932     }
1933
1934     /* copy chapters */
1935     if (o->chapters_input_file >= nb_input_files) {
1936         if (o->chapters_input_file == INT_MAX) {
1937             /* copy chapters from the first input file that has them*/
1938             o->chapters_input_file = -1;
1939             for (i = 0; i < nb_input_files; i++)
1940                 if (input_files[i]->ctx->nb_chapters) {
1941                     o->chapters_input_file = i;
1942                     break;
1943                 }
1944         } else {
1945             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1946                    o->chapters_input_file);
1947             exit_program(1);
1948         }
1949     }
1950     if (o->chapters_input_file >= 0)
1951         copy_chapters(input_files[o->chapters_input_file], of,
1952                       !o->metadata_chapters_manual);
1953
1954     /* copy global metadata by default */
1955     if (!o->metadata_global_manual && nb_input_files)
1956         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1957                      AV_DICT_DONT_OVERWRITE);
1958     if (!o->metadata_streams_manual)
1959         for (i = of->ost_index; i < nb_output_streams; i++) {
1960             InputStream *ist;
1961             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1962                 continue;
1963             ist = input_streams[output_streams[i]->source_index];
1964             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1965         }
1966
1967     /* process manually set metadata */
1968     for (i = 0; i < o->nb_metadata; i++) {
1969         AVDictionary **m;
1970         char type, *val;
1971         const char *stream_spec;
1972         int index = 0, j, ret;
1973
1974         val = strchr(o->metadata[i].u.str, '=');
1975         if (!val) {
1976             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1977                    o->metadata[i].u.str);
1978             exit_program(1);
1979         }
1980         *val++ = 0;
1981
1982         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1983         if (type == 's') {
1984             for (j = 0; j < oc->nb_streams; j++) {
1985                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1986                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1987                 } else if (ret < 0)
1988                     exit_program(1);
1989             }
1990         }
1991         else {
1992             switch (type) {
1993             case 'g':
1994                 m = &oc->metadata;
1995                 break;
1996             case 'c':
1997                 if (index < 0 || index >= oc->nb_chapters) {
1998                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1999                     exit_program(1);
2000                 }
2001                 m = &oc->chapters[index]->metadata;
2002                 break;
2003             default:
2004                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2005                 exit_program(1);
2006             }
2007             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2008         }
2009     }
2010
2011     return 0;
2012 }
2013
2014 static int opt_target(void *optctx, const char *opt, const char *arg)
2015 {
2016     OptionsContext *o = optctx;
2017     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2018     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2019
2020     if (!strncmp(arg, "pal-", 4)) {
2021         norm = PAL;
2022         arg += 4;
2023     } else if (!strncmp(arg, "ntsc-", 5)) {
2024         norm = NTSC;
2025         arg += 5;
2026     } else if (!strncmp(arg, "film-", 5)) {
2027         norm = FILM;
2028         arg += 5;
2029     } else {
2030         /* Try to determine PAL/NTSC by peeking in the input files */
2031         if (nb_input_files) {
2032             int i, j, fr;
2033             for (j = 0; j < nb_input_files; j++) {
2034                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2035                     AVStream *st = input_files[j]->ctx->streams[i];
2036                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2037                         continue;
2038                     fr = st->time_base.den * 1000 / st->time_base.num;
2039                     if (fr == 25000) {
2040                         norm = PAL;
2041                         break;
2042                     } else if ((fr == 29970) || (fr == 23976)) {
2043                         norm = NTSC;
2044                         break;
2045                     }
2046                 }
2047                 if (norm != UNKNOWN)
2048                     break;
2049             }
2050         }
2051         if (norm != UNKNOWN)
2052             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2053     }
2054
2055     if (norm == UNKNOWN) {
2056         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2057         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2058         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2059         exit_program(1);
2060     }
2061
2062     if (!strcmp(arg, "vcd")) {
2063         opt_video_codec(o, "c:v", "mpeg1video");
2064         opt_audio_codec(o, "c:a", "mp2");
2065         parse_option(o, "f", "vcd", options);
2066
2067         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2068         parse_option(o, "r", frame_rates[norm], options);
2069         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2070
2071         opt_default(NULL, "b", "1150000");
2072         opt_default(NULL, "maxrate", "1150000");
2073         opt_default(NULL, "minrate", "1150000");
2074         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2075
2076         opt_default(NULL, "b:a", "224000");
2077         parse_option(o, "ar", "44100", options);
2078         parse_option(o, "ac", "2", options);
2079
2080         opt_default(NULL, "packetsize", "2324");
2081         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
2082
2083         /* We have to offset the PTS, so that it is consistent with the SCR.
2084            SCR starts at 36000, but the first two packs contain only padding
2085            and the first pack from the other stream, respectively, may also have
2086            been written before.
2087            So the real data starts at SCR 36000+3*1200. */
2088         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2089     } else if (!strcmp(arg, "svcd")) {
2090
2091         opt_video_codec(o, "c:v", "mpeg2video");
2092         opt_audio_codec(o, "c:a", "mp2");
2093         parse_option(o, "f", "svcd", options);
2094
2095         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2096         parse_option(o, "r", frame_rates[norm], options);
2097         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2098
2099         opt_default(NULL, "b", "2040000");
2100         opt_default(NULL, "maxrate", "2516000");
2101         opt_default(NULL, "minrate", "0"); // 1145000;
2102         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2103         opt_default(NULL, "scan_offset", "1");
2104
2105
2106         opt_default(NULL, "b:a", "224000");
2107         parse_option(o, "ar", "44100", options);
2108
2109         opt_default(NULL, "packetsize", "2324");
2110
2111     } else if (!strcmp(arg, "dvd")) {
2112
2113         opt_video_codec(o, "c:v", "mpeg2video");
2114         opt_audio_codec(o, "c:a", "ac3");
2115         parse_option(o, "f", "dvd", options);
2116
2117         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2118         parse_option(o, "r", frame_rates[norm], options);
2119         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2120
2121         opt_default(NULL, "b", "6000000");
2122         opt_default(NULL, "maxrate", "9000000");
2123         opt_default(NULL, "minrate", "0"); // 1500000;
2124         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2125
2126         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2127         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2128
2129         opt_default(NULL, "b:a", "448000");
2130         parse_option(o, "ar", "48000", options);
2131
2132     } else if (!strncmp(arg, "dv", 2)) {
2133
2134         parse_option(o, "f", "dv", options);
2135
2136         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2137         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2138                           norm == PAL ? "yuv420p" : "yuv411p", options);
2139         parse_option(o, "r", frame_rates[norm], options);
2140
2141         parse_option(o, "ar", "48000", options);
2142         parse_option(o, "ac", "2", options);
2143
2144     } else {
2145         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2146         return AVERROR(EINVAL);
2147     }
2148
2149     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
2150     av_dict_copy(&o->g->format_opts, format_opts, 0);
2151
2152     return 0;
2153 }
2154
2155 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2156 {
2157     av_free (vstats_filename);
2158     vstats_filename = av_strdup (arg);
2159     return 0;
2160 }
2161
2162 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2163 {
2164     char filename[40];
2165     time_t today2 = time(NULL);
2166     struct tm *today = localtime(&today2);
2167
2168     if (!today) { // maybe tomorrow
2169         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2170         exit_program(1);
2171     }
2172
2173     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2174              today->tm_sec);
2175     return opt_vstats_file(NULL, opt, filename);
2176 }
2177
2178 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2179 {
2180     OptionsContext *o = optctx;
2181     return parse_option(o, "frames:v", arg, options);
2182 }
2183
2184 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2185 {
2186     OptionsContext *o = optctx;
2187     return parse_option(o, "frames:a", arg, options);
2188 }
2189
2190 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2191 {
2192     OptionsContext *o = optctx;
2193     return parse_option(o, "frames:d", arg, options);
2194 }
2195
2196 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2197 {
2198     OptionsContext *o = optctx;
2199     return parse_option(o, "tag:v", arg, options);
2200 }
2201
2202 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2203 {
2204     OptionsContext *o = optctx;
2205     return parse_option(o, "tag:a", arg, options);
2206 }
2207
2208 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2209 {
2210     OptionsContext *o = optctx;
2211     return parse_option(o, "tag:s", arg, options);
2212 }
2213
2214 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2215 {
2216     OptionsContext *o = optctx;
2217     return parse_option(o, "filter:v", arg, options);
2218 }
2219
2220 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2221 {
2222     OptionsContext *o = optctx;
2223     return parse_option(o, "filter:a", arg, options);
2224 }
2225
2226 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2227 {
2228     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2229     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2230     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2231
2232     if (video_sync_method == VSYNC_AUTO)
2233         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2234     return 0;
2235 }
2236
2237 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2238 {
2239     OptionsContext *o = optctx;
2240     char layout_str[32];
2241     char *stream_str;
2242     char *ac_str;
2243     int ret, channels, ac_str_size;
2244     uint64_t layout;
2245
2246     layout = av_get_channel_layout(arg);
2247     if (!layout) {
2248         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2249         return AVERROR(EINVAL);
2250     }
2251     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2252     ret = opt_default(NULL, opt, layout_str);
2253     if (ret < 0)
2254         return ret;
2255
2256     /* set 'ac' option based on channel layout */
2257     channels = av_get_channel_layout_nb_channels(layout);
2258     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2259     stream_str = strchr(opt, ':');
2260     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2261     ac_str = av_mallocz(ac_str_size);
2262     if (!ac_str)
2263         return AVERROR(ENOMEM);
2264     av_strlcpy(ac_str, "ac", 3);
2265     if (stream_str)
2266         av_strlcat(ac_str, stream_str, ac_str_size);
2267     ret = parse_option(o, ac_str, layout_str, options);
2268     av_free(ac_str);
2269
2270     return ret;
2271 }
2272
2273 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2274 {
2275     OptionsContext *o = optctx;
2276     return parse_option(o, "q:a", arg, options);
2277 }
2278
2279 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2280 {
2281     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2282     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2283         return AVERROR(ENOMEM);
2284     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2285     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2286     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2287         return AVERROR(ENOMEM);
2288     return 0;
2289 }
2290
2291 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2292 {
2293     uint8_t *graph_desc = read_file(arg);
2294     if (!graph_desc)
2295         return AVERROR(EINVAL);
2296
2297     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2298     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2299         return AVERROR(ENOMEM);
2300     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2301     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2302     return 0;
2303 }
2304
2305 void show_help_default(const char *opt, const char *arg)
2306 {
2307     /* per-file options have at least one of those set */
2308     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2309     int show_advanced = 0, show_avoptions = 0;
2310
2311     if (opt && *opt) {
2312         if (!strcmp(opt, "long"))
2313             show_advanced = 1;
2314         else if (!strcmp(opt, "full"))
2315             show_advanced = show_avoptions = 1;
2316         else
2317             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2318     }
2319
2320     show_usage();
2321
2322     printf("Getting help:\n"
2323            "    -h      -- print basic options\n"
2324            "    -h long -- print more options\n"
2325            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2326            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2327            "    See man %s for detailed description of the options.\n"
2328            "\n", program_name);
2329
2330     show_help_options(options, "Print help / information / capabilities:",
2331                       OPT_EXIT, 0, 0);
2332
2333     show_help_options(options, "Global options (affect whole program "
2334                       "instead of just one file:",
2335                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2336     if (show_advanced)
2337         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2338                           per_file | OPT_EXIT, 0);
2339
2340     show_help_options(options, "Per-file main options:", 0,
2341                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2342                       OPT_EXIT, per_file);
2343     if (show_advanced)
2344         show_help_options(options, "Advanced per-file options:",
2345                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2346
2347     show_help_options(options, "Video options:",
2348                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2349     if (show_advanced)
2350         show_help_options(options, "Advanced Video options:",
2351                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2352
2353     show_help_options(options, "Audio options:",
2354                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2355     if (show_advanced)
2356         show_help_options(options, "Advanced Audio options:",
2357                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2358     show_help_options(options, "Subtitle options:",
2359                       OPT_SUBTITLE, 0, 0);
2360     printf("\n");
2361
2362     if (show_avoptions) {
2363         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2364         show_help_children(avcodec_get_class(), flags);
2365         show_help_children(avformat_get_class(), flags);
2366         show_help_children(sws_get_class(), flags);
2367         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2368     }
2369 }
2370
2371 void show_usage(void)
2372 {
2373     printf("Hyper fast Audio and Video encoder\n");
2374     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2375     printf("\n");
2376 }
2377
2378 enum OptGroup {
2379     GROUP_OUTFILE,
2380     GROUP_INFILE,
2381 };
2382
2383 static const OptionGroupDef groups[] = {
2384     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2385     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2386 };
2387
2388 static int open_files(OptionGroupList *l, const char *inout,
2389                       int (*open_file)(OptionsContext*, const char*))
2390 {
2391     int i, ret;
2392
2393     for (i = 0; i < l->nb_groups; i++) {
2394         OptionGroup *g = &l->groups[i];
2395         OptionsContext o;
2396
2397         init_options(&o);
2398         o.g = g;
2399
2400         ret = parse_optgroup(&o, g);
2401         if (ret < 0) {
2402             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2403                    "%s.\n", inout, g->arg);
2404             return ret;
2405         }
2406
2407         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2408         ret = open_file(&o, g->arg);
2409         uninit_options(&o);
2410         if (ret < 0) {
2411             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2412                    inout, g->arg);
2413             return ret;
2414         }
2415         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2416     }
2417
2418     return 0;
2419 }
2420
2421 int avconv_parse_options(int argc, char **argv)
2422 {
2423     OptionParseContext octx;
2424     uint8_t error[128];
2425     int ret;
2426
2427     memset(&octx, 0, sizeof(octx));
2428
2429     /* split the commandline into an internal representation */
2430     ret = split_commandline(&octx, argc, argv, options, groups,
2431                             FF_ARRAY_ELEMS(groups));
2432     if (ret < 0) {
2433         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2434         goto fail;
2435     }
2436
2437     /* apply global options */
2438     ret = parse_optgroup(NULL, &octx.global_opts);
2439     if (ret < 0) {
2440         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2441         goto fail;
2442     }
2443
2444     /* open input files */
2445     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2446     if (ret < 0) {
2447         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2448         goto fail;
2449     }
2450
2451     /* create the complex filtergraphs */
2452     ret = init_complex_filters();
2453     if (ret < 0) {
2454         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2455         goto fail;
2456     }
2457
2458     /* open output files */
2459     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2460     if (ret < 0) {
2461         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2462         goto fail;
2463     }
2464
2465 fail:
2466     uninit_parse_context(&octx);
2467     if (ret < 0) {
2468         av_strerror(ret, error, sizeof(error));
2469         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2470     }
2471     return ret;
2472 }
2473
2474 #define OFFSET(x) offsetof(OptionsContext, x)
2475 const OptionDef options[] = {
2476     /* main options */
2477 #include "cmdutils_common_opts.h"
2478     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2479                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2480         "force format", "fmt" },
2481     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2482         "overwrite output files" },
2483     { "n",              OPT_BOOL,                                    {              &file_skip },
2484         "never overwrite output files" },
2485     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2486                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2487         "codec name", "codec" },
2488     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2489                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2490         "codec name", "codec" },
2491     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2492                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2493         "preset name", "preset" },
2494     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2495                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2496         "set input stream mapping",
2497         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2498     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2499                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2500         "set metadata information of outfile from infile",
2501         "outfile[,metadata]:infile[,metadata]" },
2502     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2503                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2504         "set chapters mapping", "input_file_index" },
2505     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2506                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2507         "record or transcode \"duration\" seconds of audio/video",
2508         "duration" },
2509     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2510         "set the limit file size in bytes", "limit_size" },
2511     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2512                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2513         "set the start time offset", "time_off" },
2514     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2515                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2516         "enable/disable accurate seeking with -ss" },
2517     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2518                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2519         "set the input ts offset", "time_off" },
2520     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2521                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2522         "set the input ts scale", "scale" },
2523     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2524         "add metadata", "string=string" },
2525     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2526                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2527         "set the number of data frames to record", "number" },
2528     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2529         "add timings for benchmarking" },
2530     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2531         "set max runtime in seconds", "limit" },
2532     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2533         "dump each input packet" },
2534     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2535         "when dumping packets, also dump the payload" },
2536     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2537                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2538         "read input at native frame rate", "" },
2539     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2540         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2541         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2542     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
2543         "video sync method", "" },
2544     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2545         "audio sync method", "" },
2546     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2547         "audio drift threshold", "threshold" },
2548     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2549         "copy timestamps" },
2550     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2551         "copy input stream time base when stream copying" },
2552     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2553                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2554         "finish encoding within shortest input" },
2555     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2556         "timestamp discontinuity delta threshold", "threshold" },
2557     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2558         "exit on error", "error" },
2559     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2560                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2561         "copy initial non-keyframes" },
2562     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2563         "set the number of frames to record", "number" },
2564     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2565                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2566         "force codec tag/fourcc", "fourcc/tag" },
2567     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2568                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2569         "use fixed quality scale (VBR)", "q" },
2570     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2571                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2572         "use fixed quality scale (VBR)", "q" },
2573     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2574         "set stream filterchain", "filter_list" },
2575     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2576         "read stream filtergraph description from a file", "filename" },
2577     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2578         "create a complex filtergraph", "graph_description" },
2579     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2580         "read complex filtergraph description from a file", "filename" },
2581     { "stats",          OPT_BOOL,                                    { &print_stats },
2582         "print progress report during encoding", },
2583     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2584                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2585         "add an attachment to the output file", "filename" },
2586     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2587                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2588         "extract an attachment into a file", "filename" },
2589     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2590                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2591
2592     /* video options */
2593     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2594         "set the number of video frames to record", "number" },
2595     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2596                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2597         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2598     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2599                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2600         "set frame size (WxH or abbreviation)", "size" },
2601     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2602                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2603         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2604     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2605                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2606         "set pixel format", "format" },
2607     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2608         "disable video" },
2609     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2610         "discard threshold", "n" },
2611     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2612                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2613         "rate control override for specific intervals", "override" },
2614     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2615                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2616         "force video codec ('copy' to copy stream)", "codec" },
2617     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2618         "select the pass number (1 or 2)", "n" },
2619     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2620                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2621         "select two pass log file name prefix", "prefix" },
2622     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = &opt_vstats },
2623         "dump video coding statistics to file" },
2624     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
2625         "dump video coding statistics to file", "file" },
2626     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2627         "video filters", "filter list" },
2628     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2629                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2630         "specify intra matrix coeffs", "matrix" },
2631     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2632                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2633         "specify inter matrix coeffs", "matrix" },
2634     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2635                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2636         "top=1/bottom=0/auto=-1 field first", "" },
2637     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2638         "intra_dc_precision", "precision" },
2639     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2640                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2641         "force video tag/fourcc", "fourcc/tag" },
2642     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2643         "show QP histogram" },
2644     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2645                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2646         "force the selected framerate, disable the best supported framerate selection" },
2647     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2648                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2649         "set the value of an outfile streamid", "streamIndex:value" },
2650     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2651                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2652         "force key frames at specified timestamps", "timestamps" },
2653     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2654                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2655         "use HW accelerated decoding", "hwaccel name" },
2656     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2657                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2658         "select a device for HW acceleration", "devicename" },
2659     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2660                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
2661         "select output format used with HW accelerated decoding", "format" },
2662
2663     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
2664         "show available HW acceleration methods" },
2665     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2666                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2667         "automatically insert correct rotate filters" },
2668     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
2669         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2670
2671     /* audio options */
2672     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2673         "set the number of audio frames to record", "number" },
2674     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2675         "set audio quality (codec-specific)", "quality", },
2676     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2677                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2678         "set audio sampling rate (in Hz)", "rate" },
2679     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2680                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2681         "set number of audio channels", "channels" },
2682     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2683         "disable audio" },
2684     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2685                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2686         "force audio codec ('copy' to copy stream)", "codec" },
2687     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2688                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2689         "force audio tag/fourcc", "fourcc/tag" },
2690     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2691         "change audio volume (256=normal)" , "volume" },
2692     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2693                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2694         "set sample format", "format" },
2695     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2696                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2697         "set channel layout", "layout" },
2698     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2699         "audio filters", "filter list" },
2700
2701     /* subtitle options */
2702     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2703         "disable subtitle" },
2704     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2705         "force subtitle codec ('copy' to copy stream)", "codec" },
2706     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2707         , "force subtitle tag/fourcc", "fourcc/tag" },
2708
2709     /* grab options */
2710     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2711
2712     /* muxer options */
2713     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2714         "set the maximum demux-decode delay", "seconds" },
2715     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2716         "set the initial demux-decode delay", "seconds" },
2717
2718     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2719         "A comma-separated list of bitstream filters", "bitstream_filters" },
2720
2721     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
2722         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2723
2724     /* data codec support */
2725     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2726         "force data codec ('copy' to copy stream)", "codec" },
2727
2728 #if CONFIG_VAAPI
2729     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2730         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
2731 #endif
2732
2733     { NULL, },
2734 };