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     int bitrate = 0;
 956
 957     if (!st) {
 958         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 959         exit_program(1);
 960     }
 961
 962     if (oc->nb_streams - 1 < o->nb_streamid_map)
 963         st->id = o->streamid_map[oc->nb_streams - 1];
 964
 965     GROW_ARRAY(output_streams, nb_output_streams);
 966     if (!(ost = av_mallocz(sizeof(*ost))))
 967         exit_program(1);
 968     output_streams[nb_output_streams - 1] = ost;
 969
 970     ost->file_index = nb_output_files - 1;
 971     ost->index      = idx;
 972     ost->st         = st;
 973     st->codecpar->codec_type = type;
 974
 975     ret = choose_encoder(o, oc, ost);
 976     if (ret < 0) {
 977         av_log(NULL, AV_LOG_FATAL, "Error selecting an encoder for stream "
 978                "%d:%d\n", ost->file_index, ost->index);
 979         exit_program(1);
 980     }
 981
 982     ost->enc_ctx = avcodec_alloc_context3(ost->enc);
 983     if (!ost->enc_ctx) {
 984         av_log(NULL, AV_LOG_ERROR, "Error allocating the encoding context.\n");
 985         exit_program(1);
 986     }
 987     ost->enc_ctx->codec_type = type;
 988
 989     if (ost->enc) {
 990         AVIOContext *s = NULL;
 991         char *buf = NULL, *arg = NULL, *preset = NULL;
 992
 993         ost->encoder_opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 994
 995         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 996         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 997             do  {
 998                 buf = get_line(s);
 999                 if (!buf[0] || buf[0] == '#') {
1000                     av_free(buf);
1001                     continue;
1002                 }
1003                 if (!(arg = strchr(buf, '='))) {
1004                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
1005                     exit_program(1);
1006                 }
1007                 *arg++ = 0;
1008                 av_dict_set(&ost->encoder_opts, buf, arg, AV_DICT_DONT_OVERWRITE);
1009                 av_free(buf);
1010             } while (!s->eof_reached);
1011             avio_close(s);
1012         }
1013         if (ret) {
1014             av_log(NULL, AV_LOG_FATAL,
1015                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
1016                    preset, ost->file_index, ost->index);
1017             exit_program(1);
1018         }
1019     } else {
1020         ost->encoder_opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
1021     }
1022
1023     ost->max_frames = INT64_MAX;
1024     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
1025
1026     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, oc, st);
1027     while (bsfs && *bsfs) {
1028         const AVBitStreamFilter *filter;
1029         const char *bsf, *bsf_options_str, *bsf_name;
1030         AVDictionary *bsf_options = NULL;
1031
1032         bsf = bsf_options_str = av_get_token(&bsfs, ",");
1033         if (!bsf)
1034             exit_program(1);
1035         bsf_name = av_get_token(&bsf_options_str, "=");
1036         if (!bsf_name)
1037             exit_program(1);
1038
1039         filter = av_bsf_get_by_name(bsf_name);
1040         if (!filter) {
1041             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf_name);
1042             exit_program(1);
1043         }
1044         if (*bsf_options_str++) {
1045             ret = av_dict_parse_string(&bsf_options, bsf_options_str, "=", ":", 0);
1046             if (ret < 0) {
1047                 av_log(NULL, AV_LOG_ERROR, "Error parsing options for bitstream filter %s\n", bsf_name);
1048                 exit_program(1);
1049             }
1050         }
1051         av_freep(&bsf);
1052
1053         ost->bsf_ctx = av_realloc_array(ost->bsf_ctx,
1054                                         ost->nb_bitstream_filters + 1,
1055                                         sizeof(*ost->bsf_ctx));
1056         if (!ost->bsf_ctx)
1057             exit_program(1);
1058
1059         ret = av_bsf_alloc(filter, &ost->bsf_ctx[ost->nb_bitstream_filters]);
1060         if (ret < 0) {
1061             av_log(NULL, AV_LOG_ERROR, "Error allocating a bistream filter context\n");
1062             exit_program(1);
1063         }
1064         ost->nb_bitstream_filters++;
1065
1066         if (bsf_options) {
1067             ret = av_opt_set_dict(ost->bsf_ctx[ost->nb_bitstream_filters-1]->priv_data, &bsf_options);
1068             if (ret < 0) {
1069                 av_log(NULL, AV_LOG_ERROR, "Error setting options for bitstream filter %s\n", bsf_name);
1070                 exit_program(1);
1071             }
1072             assert_avoptions(bsf_options);
1073             av_dict_free(&bsf_options);
1074         }
1075         av_freep(&bsf_name);
1076
1077         if (*bsfs)
1078             bsfs++;
1079     }
1080
1081     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
1082     if (codec_tag) {
1083         uint32_t tag = strtol(codec_tag, &next, 0);
1084         if (*next)
1085             tag = AV_RL32(codec_tag);
1086         ost->enc_ctx->codec_tag = tag;
1087     }
1088
1089     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
1090     if (qscale >= 0) {
1091         ost->enc_ctx->flags |= AV_CODEC_FLAG_QSCALE;
1092         ost->enc_ctx->global_quality = FF_QP2LAMBDA * qscale;
1093     }
1094
1095     MATCH_PER_STREAM_OPT(bitrates, i, bitrate, oc, st);
1096     if (bitrate > 0) {
1097         if (ost->stream_copy)
1098             ost->bitrate_override = bitrate;
1099         else
1100             ost->enc_ctx->bit_rate = bitrate;
1101     }
1102
1103     ost->max_muxing_queue_size = 128;
1104     MATCH_PER_STREAM_OPT(max_muxing_queue_size, i, ost->max_muxing_queue_size, oc, st);
1105     ost->max_muxing_queue_size *= sizeof(AVPacket);
1106
1107     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
1108         ost->enc_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
1109
1110     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
1111
1112     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
1113
1114     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
1115     ost->last_mux_dts = AV_NOPTS_VALUE;
1116
1117     ost->muxing_queue = av_fifo_alloc(8 * sizeof(AVPacket));
1118     if (!ost->muxing_queue)
1119         exit_program(1);
1120
1121     return ost;
1122 }
1123
1124 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
1125 {
1126     int i;
1127     const char *p = str;
1128     for (i = 0;; i++) {
1129         dest[i] = atoi(p);
1130         if (i == 63)
1131             break;
1132         p = strchr(p, ',');
1133         if (!p) {
1134             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
1135             exit_program(1);
1136         }
1137         p++;
1138     }
1139 }
1140
1141 /* read file contents into a string */
1142 static uint8_t *read_file(const char *filename)
1143 {
1144     AVIOContext *pb      = NULL;
1145     AVIOContext *dyn_buf = NULL;
1146     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
1147     uint8_t buf[1024], *str;
1148
1149     if (ret < 0) {
1150         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
1151         return NULL;
1152     }
1153
1154     ret = avio_open_dyn_buf(&dyn_buf);
1155     if (ret < 0) {
1156         avio_closep(&pb);
1157         return NULL;
1158     }
1159     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
1160         avio_write(dyn_buf, buf, ret);
1161     avio_w8(dyn_buf, 0);
1162     avio_closep(&pb);
1163
1164     ret = avio_close_dyn_buf(dyn_buf, &str);
1165     if (ret < 0)
1166         return NULL;
1167     return str;
1168 }
1169
1170 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
1171                              OutputStream *ost)
1172 {
1173     AVStream *st = ost->st;
1174     char *filter = NULL, *filter_script = NULL;
1175
1176     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
1177     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
1178
1179     if (filter_script && filter) {
1180         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
1181                "output stream #%d:%d.\n", nb_output_files, st->index);
1182         exit_program(1);
1183     }
1184
1185     if (filter_script)
1186         return read_file(filter_script);
1187     else if (filter)
1188         return av_strdup(filter);
1189
1190     return av_strdup(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ?
1191                      "null" : "anull");
1192 }
1193
1194 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
1195 {
1196     AVStream *st;
1197     OutputStream *ost;
1198     AVCodecContext *video_enc;
1199     char *frame_aspect_ratio = NULL;
1200
1201     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1202     st  = ost->st;
1203     video_enc = ost->enc_ctx;
1204
1205     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1206     if (frame_aspect_ratio)
1207         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1208
1209     if (!ost->stream_copy) {
1210         const char *p = NULL;
1211         char *frame_rate = NULL, *frame_size = NULL;
1212         char *frame_pix_fmt = NULL;
1213         char *intra_matrix = NULL, *inter_matrix = NULL;
1214         int do_pass = 0;
1215         int i;
1216
1217         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1218         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1219             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1220             exit_program(1);
1221         }
1222
1223         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1224         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1225             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1226             exit_program(1);
1227         }
1228
1229         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1230         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1231             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1232             exit_program(1);
1233         }
1234         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1235
1236         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1237         if (intra_matrix) {
1238             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1239                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1240                 exit_program(1);
1241             }
1242             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1243         }
1244         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1245         if (inter_matrix) {
1246             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1247                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1248                 exit_program(1);
1249             }
1250             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1251         }
1252
1253         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1254         for (i = 0; p; i++) {
1255             int start, end, q;
1256             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1257             if (e != 3) {
1258                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1259                 exit_program(1);
1260             }
1261             video_enc->rc_override =
1262                 av_realloc(video_enc->rc_override,
1263                            sizeof(RcOverride) * (i + 1));
1264             if (!video_enc->rc_override) {
1265                 av_log(NULL, AV_LOG_FATAL, "Could not (re)allocate memory for rc_override.\n");
1266                 exit_program(1);
1267             }
1268             video_enc->rc_override[i].start_frame = start;
1269             video_enc->rc_override[i].end_frame   = end;
1270             if (q > 0) {
1271                 video_enc->rc_override[i].qscale         = q;
1272                 video_enc->rc_override[i].quality_factor = 1.0;
1273             }
1274             else {
1275                 video_enc->rc_override[i].qscale         = 0;
1276                 video_enc->rc_override[i].quality_factor = -q/100.0;
1277             }
1278             p = strchr(p, '/');
1279             if (p) p++;
1280         }
1281         video_enc->rc_override_count = i;
1282         video_enc->intra_dc_precision = intra_dc_precision - 8;
1283
1284         /* two pass mode */
1285         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1286         if (do_pass) {
1287             if (do_pass == 1) {
1288                 video_enc->flags |= AV_CODEC_FLAG_PASS1;
1289             } else {
1290                 video_enc->flags |= AV_CODEC_FLAG_PASS2;
1291             }
1292         }
1293
1294         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1295         if (ost->logfile_prefix &&
1296             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1297             exit_program(1);
1298
1299         if (do_pass) {
1300             char logfilename[1024];
1301             FILE *f;
1302
1303             snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1304                      ost->logfile_prefix ? ost->logfile_prefix :
1305                                            DEFAULT_PASS_LOGFILENAME_PREFIX,
1306                      i);
1307             if (!strcmp(ost->enc->name, "libx264")) {
1308                 av_dict_set(&ost->encoder_opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1309             } else {
1310                 if (video_enc->flags & AV_CODEC_FLAG_PASS1) {
1311                     f = fopen(logfilename, "wb");
1312                     if (!f) {
1313                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1314                                logfilename, strerror(errno));
1315                         exit_program(1);
1316                     }
1317                     ost->logfile = f;
1318                 } else {
1319                     char  *logbuffer = read_file(logfilename);
1320
1321                     if (!logbuffer) {
1322                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1323                                logfilename);
1324                         exit_program(1);
1325                     }
1326                     video_enc->stats_in = logbuffer;
1327                 }
1328             }
1329         }
1330
1331         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1332         if (ost->forced_keyframes)
1333             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1334
1335         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1336
1337         ost->top_field_first = -1;
1338         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1339
1340
1341         ost->avfilter = get_ost_filters(o, oc, ost);
1342         if (!ost->avfilter)
1343             exit_program(1);
1344     } else {
1345         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1346     }
1347
1348     return ost;
1349 }
1350
1351 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1352 {
1353     AVStream *st;
1354     OutputStream *ost;
1355     AVCodecContext *audio_enc;
1356
1357     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1358     st  = ost->st;
1359
1360     audio_enc = ost->enc_ctx;
1361     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1362
1363     if (!ost->stream_copy) {
1364         char *sample_fmt = NULL;
1365
1366         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1367
1368         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1369         if (sample_fmt &&
1370             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1371             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1372             exit_program(1);
1373         }
1374
1375         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1376
1377         ost->avfilter = get_ost_filters(o, oc, ost);
1378         if (!ost->avfilter)
1379             exit_program(1);
1380     }
1381
1382     return ost;
1383 }
1384
1385 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1386 {
1387     OutputStream *ost;
1388
1389     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1390     if (!ost->stream_copy) {
1391         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1392         exit_program(1);
1393     }
1394
1395     return ost;
1396 }
1397
1398 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1399 {
1400     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1401     ost->stream_copy = 1;
1402     ost->finished    = 1;
1403     return ost;
1404 }
1405
1406 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1407 {
1408     OutputStream *ost;
1409     AVCodecContext *subtitle_enc;
1410
1411     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1412     subtitle_enc = ost->enc_ctx;
1413
1414     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1415
1416     return ost;
1417 }
1418
1419 /* arg format is "output-stream-index:streamid-value". */
1420 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1421 {
1422     OptionsContext *o = optctx;
1423     int idx;
1424     char *p;
1425     char idx_str[16];
1426
1427     av_strlcpy(idx_str, arg, sizeof(idx_str));
1428     p = strchr(idx_str, ':');
1429     if (!p) {
1430         av_log(NULL, AV_LOG_FATAL,
1431                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1432                arg, opt);
1433         exit_program(1);
1434     }
1435     *p++ = '\0';
1436     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1437     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1438     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1439     return 0;
1440 }
1441
1442 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1443 {
1444     AVFormatContext *is = ifile->ctx;
1445     AVFormatContext *os = ofile->ctx;
1446     AVChapter **tmp;
1447     int i;
1448
1449     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1450     if (!tmp)
1451         return AVERROR(ENOMEM);
1452     os->chapters = tmp;
1453
1454     for (i = 0; i < is->nb_chapters; i++) {
1455         AVChapter *in_ch = is->chapters[i], *out_ch;
1456         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1457         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1458                                        AV_TIME_BASE_Q, in_ch->time_base);
1459         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1460                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1461
1462
1463         if (in_ch->end < ts_off)
1464             continue;
1465         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1466             break;
1467
1468         out_ch = av_mallocz(sizeof(AVChapter));
1469         if (!out_ch)
1470             return AVERROR(ENOMEM);
1471
1472         out_ch->id        = in_ch->id;
1473         out_ch->time_base = in_ch->time_base;
1474         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1475         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1476
1477         if (copy_metadata)
1478             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1479
1480         os->chapters[os->nb_chapters++] = out_ch;
1481     }
1482     return 0;
1483 }
1484
1485 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1486                                AVFormatContext *oc)
1487 {
1488     OutputStream *ost;
1489
1490     switch (ofilter->type) {
1491     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1492     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1493     default:
1494         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1495                "currently.\n");
1496         exit_program(1);
1497     }
1498
1499     ost->source_index = -1;
1500     ost->filter       = ofilter;
1501
1502     ofilter->ost      = ost;
1503     ofilter->format   = -1;
1504
1505     if (ost->stream_copy) {
1506         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1507                "which is fed from a complex filtergraph. Filtering and streamcopy "
1508                "cannot be used together.\n", ost->file_index, ost->index);
1509         exit_program(1);
1510     }
1511
1512     avfilter_inout_free(&ofilter->out_tmp);
1513 }
1514
1515 static int init_complex_filters(void)
1516 {
1517     int i, ret = 0;
1518
1519     for (i = 0; i < nb_filtergraphs; i++) {
1520         ret = init_complex_filtergraph(filtergraphs[i]);
1521         if (ret < 0)
1522             return ret;
1523     }
1524     return 0;
1525 }
1526
1527 static int open_output_file(OptionsContext *o, const char *filename)
1528 {
1529     AVFormatContext *oc;
1530     int i, j, err;
1531     AVOutputFormat *file_oformat;
1532     OutputFile *of;
1533     OutputStream *ost;
1534     InputStream  *ist;
1535     AVDictionary *unused_opts = NULL;
1536     AVDictionaryEntry *e = NULL;
1537
1538     GROW_ARRAY(output_files, nb_output_files);
1539     of = av_mallocz(sizeof(*of));
1540     if (!of)
1541         exit_program(1);
1542     output_files[nb_output_files - 1] = of;
1543
1544     of->ost_index      = nb_output_streams;
1545     of->recording_time = o->recording_time;
1546     of->start_time     = o->start_time;
1547     of->limit_filesize = o->limit_filesize;
1548     of->shortest       = o->shortest;
1549     av_dict_copy(&of->opts, o->g->format_opts, 0);
1550
1551     if (!strcmp(filename, "-"))
1552         filename = "pipe:";
1553
1554     oc = avformat_alloc_context();
1555     if (!oc) {
1556         print_error(filename, AVERROR(ENOMEM));
1557         exit_program(1);
1558     }
1559     of->ctx = oc;
1560     if (o->recording_time != INT64_MAX)
1561         oc->duration = o->recording_time;
1562
1563     if (o->format) {
1564         file_oformat = av_guess_format(o->format, NULL, NULL);
1565         if (!file_oformat) {
1566             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1567             exit_program(1);
1568         }
1569     } else {
1570         file_oformat = av_guess_format(NULL, filename, NULL);
1571         if (!file_oformat) {
1572             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1573                    filename);
1574             exit_program(1);
1575         }
1576     }
1577
1578     oc->oformat = file_oformat;
1579     oc->interrupt_callback = int_cb;
1580     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1581
1582     /* create streams for all unlabeled output pads */
1583     for (i = 0; i < nb_filtergraphs; i++) {
1584         FilterGraph *fg = filtergraphs[i];
1585         for (j = 0; j < fg->nb_outputs; j++) {
1586             OutputFilter *ofilter = fg->outputs[j];
1587
1588             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1589                 continue;
1590
1591             switch (ofilter->type) {
1592             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1593             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1594             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1595             }
1596             init_output_filter(ofilter, o, oc);
1597         }
1598     }
1599
1600     if (!o->nb_stream_maps) {
1601         /* pick the "best" stream of each type */
1602 #define NEW_STREAM(type, index)\
1603         if (index >= 0) {\
1604             ost = new_ ## type ## _stream(o, oc);\
1605             ost->source_index = index;\
1606             ost->sync_ist     = input_streams[index];\
1607             input_streams[index]->discard = 0;\
1608             input_streams[index]->st->discard = AVDISCARD_NONE;\
1609         }
1610
1611         /* video: highest resolution */
1612         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1613             int area = 0, idx = -1;
1614             for (i = 0; i < nb_input_streams; i++) {
1615                 ist = input_streams[i];
1616                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1617                     ist->st->codecpar->width * ist->st->codecpar->height > area) {
1618                     area = ist->st->codecpar->width * ist->st->codecpar->height;
1619                     idx = i;
1620                 }
1621             }
1622             NEW_STREAM(video, idx);
1623         }
1624
1625         /* audio: most channels */
1626         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1627             int channels = 0, idx = -1;
1628             for (i = 0; i < nb_input_streams; i++) {
1629                 ist = input_streams[i];
1630                 if (ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO &&
1631                     ist->st->codecpar->channels > channels) {
1632                     channels = ist->st->codecpar->channels;
1633                     idx = i;
1634                 }
1635             }
1636             NEW_STREAM(audio, idx);
1637         }
1638
1639         /* subtitles: pick first */
1640         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1641             for (i = 0; i < nb_input_streams; i++)
1642                 if (input_streams[i]->st->codecpar->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1643                     NEW_STREAM(subtitle, i);
1644                     break;
1645                 }
1646         }
1647         /* do something with data? */
1648     } else {
1649         for (i = 0; i < o->nb_stream_maps; i++) {
1650             StreamMap *map = &o->stream_maps[i];
1651
1652             if (map->disabled)
1653                 continue;
1654
1655             if (map->linklabel) {
1656                 FilterGraph *fg;
1657                 OutputFilter *ofilter = NULL;
1658                 int j, k;
1659
1660                 for (j = 0; j < nb_filtergraphs; j++) {
1661                     fg = filtergraphs[j];
1662                     for (k = 0; k < fg->nb_outputs; k++) {
1663                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1664                         if (out && !strcmp(out->name, map->linklabel)) {
1665                             ofilter = fg->outputs[k];
1666                             goto loop_end;
1667                         }
1668                     }
1669                 }
1670 loop_end:
1671                 if (!ofilter) {
1672                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1673                            "in any defined filter graph.\n", map->linklabel);
1674                     exit_program(1);
1675                 }
1676                 init_output_filter(ofilter, o, oc);
1677             } else {
1678                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1679                 switch (ist->st->codecpar->codec_type) {
1680                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1681                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1682                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1683                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1684                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1685                 default:
1686                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1687                            map->file_index, map->stream_index);
1688                     exit_program(1);
1689                 }
1690
1691                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1692                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1693                                                map->sync_stream_index];
1694                 ist->discard = 0;
1695                 ist->st->discard = AVDISCARD_NONE;
1696             }
1697         }
1698     }
1699
1700     /* handle attached files */
1701     for (i = 0; i < o->nb_attachments; i++) {
1702         AVIOContext *pb;
1703         uint8_t *attachment;
1704         const char *p;
1705         int64_t len;
1706
1707         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1708             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1709                    o->attachments[i]);
1710             exit_program(1);
1711         }
1712         if ((len = avio_size(pb)) <= 0) {
1713             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1714                    o->attachments[i]);
1715             exit_program(1);
1716         }
1717         if (!(attachment = av_malloc(len))) {
1718             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1719                    o->attachments[i]);
1720             exit_program(1);
1721         }
1722         avio_read(pb, attachment, len);
1723
1724         ost = new_attachment_stream(o, oc);
1725         ost->stream_copy               = 0;
1726         ost->source_index              = -1;
1727         ost->attachment_filename       = o->attachments[i];
1728         ost->st->codecpar->extradata      = attachment;
1729         ost->st->codecpar->extradata_size = len;
1730
1731         p = strrchr(o->attachments[i], '/');
1732         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1733         avio_close(pb);
1734     }
1735
1736     if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1737         av_dump_format(oc, nb_output_files - 1, oc->filename, 1);
1738         av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", nb_output_files - 1);
1739         exit_program(1);
1740     }
1741
1742     /* check if all codec options have been used */
1743     unused_opts = strip_specifiers(o->g->codec_opts);
1744     for (i = of->ost_index; i < nb_output_streams; i++) {
1745         e = NULL;
1746         while ((e = av_dict_get(output_streams[i]->encoder_opts, "", e,
1747                                 AV_DICT_IGNORE_SUFFIX)))
1748             av_dict_set(&unused_opts, e->key, NULL, 0);
1749     }
1750
1751     e = NULL;
1752     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1753         const AVClass *class = avcodec_get_class();
1754         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1755                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1756         if (!option)
1757             continue;
1758         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1759             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1760                    "output file #%d (%s) is not an encoding option.\n", e->key,
1761                    option->help ? option->help : "", nb_output_files - 1,
1762                    filename);
1763             exit_program(1);
1764         }
1765
1766         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1767                "output file #%d (%s) has not been used for any stream. The most "
1768                "likely reason is either wrong type (e.g. a video option with "
1769                "no video streams) or that it is a private option of some encoder "
1770                "which was not actually used for any stream.\n", e->key,
1771                option->help ? option->help : "", nb_output_files - 1, filename);
1772     }
1773     av_dict_free(&unused_opts);
1774
1775     /* set the decoding_needed flags and create simple filtergraphs */
1776     for (i = of->ost_index; i < nb_output_streams; i++) {
1777         OutputStream *ost = output_streams[i];
1778
1779         if (ost->encoding_needed && ost->source_index >= 0) {
1780             InputStream *ist = input_streams[ost->source_index];
1781             ist->decoding_needed = 1;
1782
1783             if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ||
1784                 ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
1785                 err = init_simple_filtergraph(ist, ost);
1786                 if (err < 0) {
1787                     av_log(NULL, AV_LOG_ERROR,
1788                            "Error initializing a simple filtergraph between streams "
1789                            "%d:%d->%d:%d\n", ist->file_index, ost->source_index,
1790                            nb_output_files - 1, ost->st->index);
1791                     exit_program(1);
1792                 }
1793             }
1794         }
1795
1796         /*
1797          * We want CFR output if and only if one of those is true:
1798          * 1) user specified output framerate with -r
1799          * 2) user specified -vsync cfr
1800          * 3) output format is CFR and the user didn't force vsync to
1801          *    something else than CFR
1802          *
1803          * in such a case, set ost->frame_rate
1804          */
1805         if (ost->encoding_needed && ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1806             int format_cfr = !(oc->oformat->flags & (AVFMT_NOTIMESTAMPS | AVFMT_VARIABLE_FPS));
1807             int need_cfr = !!ost->frame_rate.num;
1808
1809             if (video_sync_method == VSYNC_CFR ||
1810                 (video_sync_method == VSYNC_AUTO && format_cfr))
1811                 need_cfr = 1;
1812
1813             if (need_cfr && !ost->frame_rate.num) {
1814                 InputStream *ist = ost->source_index >= 0 ? input_streams[ost->source_index] : NULL;
1815
1816                 if (ist && ist->framerate.num)
1817                     ost->frame_rate = ist->framerate;
1818                 else if (ist && ist->st->avg_frame_rate.num)
1819                     ost->frame_rate = ist->st->avg_frame_rate;
1820                 else {
1821                     av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1822                            "for the output stream #%d:%d, but no information "
1823                            "about the input framerate is available. Falling "
1824                            "back to a default value of 25fps. Use the -r option "
1825                            "if you want a different framerate.\n",
1826                            ost->file_index, ost->index);
1827                     ost->frame_rate = (AVRational){ 25, 1 };
1828                 }
1829             }
1830
1831             if (need_cfr && ost->enc->supported_framerates && !ost->force_fps) {
1832                 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
1833                 ost->frame_rate = ost->enc->supported_framerates[idx];
1834             }
1835         }
1836
1837         /* set the filter output constraints */
1838         if (ost->filter) {
1839             OutputFilter *f = ost->filter;
1840             int count;
1841             switch (ost->enc_ctx->codec_type) {
1842             case AVMEDIA_TYPE_VIDEO:
1843                 f->frame_rate = ost->frame_rate;
1844                 f->width      = ost->enc_ctx->width;
1845                 f->height     = ost->enc_ctx->height;
1846                 if (ost->enc_ctx->pix_fmt != AV_PIX_FMT_NONE) {
1847                     f->format = ost->enc_ctx->pix_fmt;
1848                 } else if (ost->enc->pix_fmts) {
1849                     count = 0;
1850                     while (ost->enc->pix_fmts[count] != AV_PIX_FMT_NONE)
1851                         count++;
1852                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1853                     if (!f->formats)
1854                         exit_program(1);
1855                     memcpy(f->formats, ost->enc->pix_fmts, (count + 1) * sizeof(*f->formats));
1856                 }
1857                 break;
1858             case AVMEDIA_TYPE_AUDIO:
1859                 if (ost->enc_ctx->sample_fmt != AV_SAMPLE_FMT_NONE) {
1860                     f->format = ost->enc_ctx->sample_fmt;
1861                 } else if (ost->enc->sample_fmts) {
1862                     count = 0;
1863                     while (ost->enc->sample_fmts[count] != AV_SAMPLE_FMT_NONE)
1864                         count++;
1865                     f->formats = av_mallocz_array(count + 1, sizeof(*f->formats));
1866                     if (!f->formats)
1867                         exit_program(1);
1868                     memcpy(f->formats, ost->enc->sample_fmts, (count + 1) * sizeof(*f->formats));
1869                 }
1870                 if (ost->enc_ctx->sample_rate) {
1871                     f->sample_rate = ost->enc_ctx->sample_rate;
1872                 } else if (ost->enc->supported_samplerates) {
1873                     count = 0;
1874                     while (ost->enc->supported_samplerates[count])
1875                         count++;
1876                     f->sample_rates = av_mallocz_array(count + 1, sizeof(*f->sample_rates));
1877                     if (!f->sample_rates)
1878                         exit_program(1);
1879                     memcpy(f->sample_rates, ost->enc->supported_samplerates,
1880                            (count + 1) * sizeof(*f->sample_rates));
1881                 }
1882                 if (ost->enc_ctx->channels) {
1883                     f->channel_layout = av_get_default_channel_layout(ost->enc_ctx->channels);
1884                 } else if (ost->enc->channel_layouts) {
1885                     count = 0;
1886                     while (ost->enc->channel_layouts[count])
1887                         count++;
1888                     f->channel_layouts = av_mallocz_array(count + 1, sizeof(*f->channel_layouts));
1889                     if (!f->channel_layouts)
1890                         exit_program(1);
1891                     memcpy(f->channel_layouts, ost->enc->channel_layouts,
1892                            (count + 1) * sizeof(*f->channel_layouts));
1893                 }
1894                 break;
1895             }
1896         }
1897
1898     }
1899
1900     /* check filename in case of an image number is expected */
1901     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1902         if (!av_filename_number_test(oc->filename)) {
1903             print_error(oc->filename, AVERROR(EINVAL));
1904             exit_program(1);
1905         }
1906     }
1907
1908     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1909         /* test if it already exists to avoid losing precious files */
1910         assert_file_overwrite(filename);
1911
1912         /* open the file */
1913         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1914                               &oc->interrupt_callback,
1915                               &of->opts)) < 0) {
1916             print_error(filename, err);
1917             exit_program(1);
1918         }
1919     }
1920
1921     if (o->mux_preload) {
1922         uint8_t buf[64];
1923         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1924         av_dict_set(&of->opts, "preload", buf, 0);
1925     }
1926     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1927     oc->flags |= AVFMT_FLAG_NONBLOCK;
1928
1929     /* copy metadata */
1930     for (i = 0; i < o->nb_metadata_map; i++) {
1931         char *p;
1932         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1933
1934         if (in_file_index >= nb_input_files) {
1935             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1936             exit_program(1);
1937         }
1938         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1939                       in_file_index >= 0 ?
1940                       input_files[in_file_index]->ctx : NULL, o);
1941     }
1942
1943     /* copy chapters */
1944     if (o->chapters_input_file >= nb_input_files) {
1945         if (o->chapters_input_file == INT_MAX) {
1946             /* copy chapters from the first input file that has them*/
1947             o->chapters_input_file = -1;
1948             for (i = 0; i < nb_input_files; i++)
1949                 if (input_files[i]->ctx->nb_chapters) {
1950                     o->chapters_input_file = i;
1951                     break;
1952                 }
1953         } else {
1954             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1955                    o->chapters_input_file);
1956             exit_program(1);
1957         }
1958     }
1959     if (o->chapters_input_file >= 0)
1960         copy_chapters(input_files[o->chapters_input_file], of,
1961                       !o->metadata_chapters_manual);
1962
1963     /* copy global metadata by default */
1964     if (!o->metadata_global_manual && nb_input_files)
1965         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1966                      AV_DICT_DONT_OVERWRITE);
1967     if (!o->metadata_streams_manual)
1968         for (i = of->ost_index; i < nb_output_streams; i++) {
1969             InputStream *ist;
1970             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1971                 continue;
1972             ist = input_streams[output_streams[i]->source_index];
1973             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1974         }
1975
1976     /* process manually set metadata */
1977     for (i = 0; i < o->nb_metadata; i++) {
1978         AVDictionary **m;
1979         char type, *val;
1980         const char *stream_spec;
1981         int index = 0, j, ret;
1982
1983         val = strchr(o->metadata[i].u.str, '=');
1984         if (!val) {
1985             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1986                    o->metadata[i].u.str);
1987             exit_program(1);
1988         }
1989         *val++ = 0;
1990
1991         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1992         if (type == 's') {
1993             for (j = 0; j < oc->nb_streams; j++) {
1994                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1995                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1996                 } else if (ret < 0)
1997                     exit_program(1);
1998             }
1999         }
2000         else {
2001             switch (type) {
2002             case 'g':
2003                 m = &oc->metadata;
2004                 break;
2005             case 'c':
2006                 if (index < 0 || index >= oc->nb_chapters) {
2007                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
2008                     exit_program(1);
2009                 }
2010                 m = &oc->chapters[index]->metadata;
2011                 break;
2012             default:
2013                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
2014                 exit_program(1);
2015             }
2016             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
2017         }
2018     }
2019
2020     return 0;
2021 }
2022
2023 static int opt_target(void *optctx, const char *opt, const char *arg)
2024 {
2025     OptionsContext *o = optctx;
2026     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
2027     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
2028
2029     if (!strncmp(arg, "pal-", 4)) {
2030         norm = PAL;
2031         arg += 4;
2032     } else if (!strncmp(arg, "ntsc-", 5)) {
2033         norm = NTSC;
2034         arg += 5;
2035     } else if (!strncmp(arg, "film-", 5)) {
2036         norm = FILM;
2037         arg += 5;
2038     } else {
2039         /* Try to determine PAL/NTSC by peeking in the input files */
2040         if (nb_input_files) {
2041             int i, j, fr;
2042             for (j = 0; j < nb_input_files; j++) {
2043                 for (i = 0; i < input_files[j]->nb_streams; i++) {
2044                     AVStream *st = input_files[j]->ctx->streams[i];
2045                     if (st->codecpar->codec_type != AVMEDIA_TYPE_VIDEO)
2046                         continue;
2047                     fr = st->time_base.den * 1000 / st->time_base.num;
2048                     if (fr == 25000) {
2049                         norm = PAL;
2050                         break;
2051                     } else if ((fr == 29970) || (fr == 23976)) {
2052                         norm = NTSC;
2053                         break;
2054                     }
2055                 }
2056                 if (norm != UNKNOWN)
2057                     break;
2058             }
2059         }
2060         if (norm != UNKNOWN)
2061             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
2062     }
2063
2064     if (norm == UNKNOWN) {
2065         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
2066         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
2067         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
2068         exit_program(1);
2069     }
2070
2071     if (!strcmp(arg, "vcd")) {
2072         opt_video_codec(o, "c:v", "mpeg1video");
2073         opt_audio_codec(o, "c:a", "mp2");
2074         parse_option(o, "f", "vcd", options);
2075
2076         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
2077         parse_option(o, "r", frame_rates[norm], options);
2078         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2079
2080         opt_default(NULL, "b", "1150000");
2081         opt_default(NULL, "maxrate", "1150000");
2082         opt_default(NULL, "minrate", "1150000");
2083         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
2084
2085         opt_default(NULL, "b:a", "224000");
2086         parse_option(o, "ar", "44100", options);
2087         parse_option(o, "ac", "2", options);
2088
2089         opt_default(NULL, "packetsize", "2324");
2090         opt_default(NULL, "muxrate", "3528"); // 2352 * 75 / 50;
2091
2092         /* We have to offset the PTS, so that it is consistent with the SCR.
2093            SCR starts at 36000, but the first two packs contain only padding
2094            and the first pack from the other stream, respectively, may also have
2095            been written before.
2096            So the real data starts at SCR 36000+3*1200. */
2097         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
2098     } else if (!strcmp(arg, "svcd")) {
2099
2100         opt_video_codec(o, "c:v", "mpeg2video");
2101         opt_audio_codec(o, "c:a", "mp2");
2102         parse_option(o, "f", "svcd", options);
2103
2104         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
2105         parse_option(o, "r", frame_rates[norm], options);
2106         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2107
2108         opt_default(NULL, "b", "2040000");
2109         opt_default(NULL, "maxrate", "2516000");
2110         opt_default(NULL, "minrate", "0"); // 1145000;
2111         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2112         opt_default(NULL, "scan_offset", "1");
2113
2114
2115         opt_default(NULL, "b:a", "224000");
2116         parse_option(o, "ar", "44100", options);
2117
2118         opt_default(NULL, "packetsize", "2324");
2119
2120     } else if (!strcmp(arg, "dvd")) {
2121
2122         opt_video_codec(o, "c:v", "mpeg2video");
2123         opt_audio_codec(o, "c:a", "ac3");
2124         parse_option(o, "f", "dvd", options);
2125
2126         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2127         parse_option(o, "r", frame_rates[norm], options);
2128         opt_default(NULL, "g", norm == PAL ? "15" : "18");
2129
2130         opt_default(NULL, "b", "6000000");
2131         opt_default(NULL, "maxrate", "9000000");
2132         opt_default(NULL, "minrate", "0"); // 1500000;
2133         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
2134
2135         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
2136         opt_default(NULL, "muxrate", "25200"); // from mplex project: data_rate = 1260000. mux_rate = data_rate / 50
2137
2138         opt_default(NULL, "b:a", "448000");
2139         parse_option(o, "ar", "48000", options);
2140
2141     } else if (!strncmp(arg, "dv", 2)) {
2142
2143         parse_option(o, "f", "dv", options);
2144
2145         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
2146         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
2147                           norm == PAL ? "yuv420p" : "yuv411p", options);
2148         parse_option(o, "r", frame_rates[norm], options);
2149
2150         parse_option(o, "ar", "48000", options);
2151         parse_option(o, "ac", "2", options);
2152
2153     } else {
2154         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
2155         return AVERROR(EINVAL);
2156     }
2157
2158     av_dict_copy(&o->g->codec_opts,  codec_opts, 0);
2159     av_dict_copy(&o->g->format_opts, format_opts, 0);
2160
2161     return 0;
2162 }
2163
2164 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
2165 {
2166     av_free (vstats_filename);
2167     vstats_filename = av_strdup (arg);
2168     return 0;
2169 }
2170
2171 static int opt_vstats(void *optctx, const char *opt, const char *arg)
2172 {
2173     char filename[40];
2174     time_t today2 = time(NULL);
2175     struct tm *today = localtime(&today2);
2176
2177     if (!today) { // maybe tomorrow
2178         av_log(NULL, AV_LOG_FATAL, "Unable to get current time.\n");
2179         exit_program(1);
2180     }
2181
2182     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
2183              today->tm_sec);
2184     return opt_vstats_file(NULL, opt, filename);
2185 }
2186
2187 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
2188 {
2189     OptionsContext *o = optctx;
2190     return parse_option(o, "frames:v", arg, options);
2191 }
2192
2193 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
2194 {
2195     OptionsContext *o = optctx;
2196     return parse_option(o, "frames:a", arg, options);
2197 }
2198
2199 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
2200 {
2201     OptionsContext *o = optctx;
2202     return parse_option(o, "frames:d", arg, options);
2203 }
2204
2205 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
2206 {
2207     OptionsContext *o = optctx;
2208     return parse_option(o, "tag:v", arg, options);
2209 }
2210
2211 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
2212 {
2213     OptionsContext *o = optctx;
2214     return parse_option(o, "tag:a", arg, options);
2215 }
2216
2217 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
2218 {
2219     OptionsContext *o = optctx;
2220     return parse_option(o, "tag:s", arg, options);
2221 }
2222
2223 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
2224 {
2225     OptionsContext *o = optctx;
2226     return parse_option(o, "filter:v", arg, options);
2227 }
2228
2229 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
2230 {
2231     OptionsContext *o = optctx;
2232     return parse_option(o, "filter:a", arg, options);
2233 }
2234
2235 static int opt_vsync(void *optctx, const char *opt, const char *arg)
2236 {
2237     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
2238     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
2239     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
2240
2241     if (video_sync_method == VSYNC_AUTO)
2242         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
2243     return 0;
2244 }
2245
2246 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
2247 {
2248     OptionsContext *o = optctx;
2249     char layout_str[32];
2250     char *stream_str;
2251     char *ac_str;
2252     int ret, channels, ac_str_size;
2253     uint64_t layout;
2254
2255     layout = av_get_channel_layout(arg);
2256     if (!layout) {
2257         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
2258         return AVERROR(EINVAL);
2259     }
2260     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
2261     ret = opt_default(NULL, opt, layout_str);
2262     if (ret < 0)
2263         return ret;
2264
2265     /* set 'ac' option based on channel layout */
2266     channels = av_get_channel_layout_nb_channels(layout);
2267     snprintf(layout_str, sizeof(layout_str), "%d", channels);
2268     stream_str = strchr(opt, ':');
2269     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
2270     ac_str = av_mallocz(ac_str_size);
2271     if (!ac_str)
2272         return AVERROR(ENOMEM);
2273     av_strlcpy(ac_str, "ac", 3);
2274     if (stream_str)
2275         av_strlcat(ac_str, stream_str, ac_str_size);
2276     ret = parse_option(o, ac_str, layout_str, options);
2277     av_free(ac_str);
2278
2279     return ret;
2280 }
2281
2282 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
2283 {
2284     OptionsContext *o = optctx;
2285     return parse_option(o, "q:a", arg, options);
2286 }
2287
2288 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
2289 {
2290     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2291     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2292         return AVERROR(ENOMEM);
2293     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2294     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
2295     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
2296         return AVERROR(ENOMEM);
2297     return 0;
2298 }
2299
2300 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
2301 {
2302     uint8_t *graph_desc = read_file(arg);
2303     if (!graph_desc)
2304         return AVERROR(EINVAL);
2305
2306     GROW_ARRAY(filtergraphs, nb_filtergraphs);
2307     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
2308         return AVERROR(ENOMEM);
2309     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
2310     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
2311     return 0;
2312 }
2313
2314 void show_help_default(const char *opt, const char *arg)
2315 {
2316     /* per-file options have at least one of those set */
2317     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
2318     int show_advanced = 0, show_avoptions = 0;
2319
2320     if (opt && *opt) {
2321         if (!strcmp(opt, "long"))
2322             show_advanced = 1;
2323         else if (!strcmp(opt, "full"))
2324             show_advanced = show_avoptions = 1;
2325         else
2326             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
2327     }
2328
2329     show_usage();
2330
2331     printf("Getting help:\n"
2332            "    -h      -- print basic options\n"
2333            "    -h long -- print more options\n"
2334            "    -h full -- print all options (including all format and codec specific options, very long)\n"
2335            "    -h type=name -- print all options for the named decoder/encoder/demuxer/muxer/filter\n"
2336            "    See man %s for detailed description of the options.\n"
2337            "\n", program_name);
2338
2339     show_help_options(options, "Print help / information / capabilities:",
2340                       OPT_EXIT, 0, 0);
2341
2342     show_help_options(options, "Global options (affect whole program "
2343                       "instead of just one file:",
2344                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
2345     if (show_advanced)
2346         show_help_options(options, "Advanced global options:", OPT_EXPERT,
2347                           per_file | OPT_EXIT, 0);
2348
2349     show_help_options(options, "Per-file main options:", 0,
2350                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
2351                       OPT_EXIT, per_file);
2352     if (show_advanced)
2353         show_help_options(options, "Advanced per-file options:",
2354                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
2355
2356     show_help_options(options, "Video options:",
2357                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2358     if (show_advanced)
2359         show_help_options(options, "Advanced Video options:",
2360                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2361
2362     show_help_options(options, "Audio options:",
2363                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2364     if (show_advanced)
2365         show_help_options(options, "Advanced Audio options:",
2366                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2367     show_help_options(options, "Subtitle options:",
2368                       OPT_SUBTITLE, 0, 0);
2369     printf("\n");
2370
2371     if (show_avoptions) {
2372         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2373         show_help_children(avcodec_get_class(), flags);
2374         show_help_children(avformat_get_class(), flags);
2375         show_help_children(sws_get_class(), flags);
2376         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2377     }
2378 }
2379
2380 void show_usage(void)
2381 {
2382     printf("Hyper fast Audio and Video encoder\n");
2383     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2384     printf("\n");
2385 }
2386
2387 enum OptGroup {
2388     GROUP_OUTFILE,
2389     GROUP_INFILE,
2390 };
2391
2392 static const OptionGroupDef groups[] = {
2393     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2394     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2395 };
2396
2397 static int open_files(OptionGroupList *l, const char *inout,
2398                       int (*open_file)(OptionsContext*, const char*))
2399 {
2400     int i, ret;
2401
2402     for (i = 0; i < l->nb_groups; i++) {
2403         OptionGroup *g = &l->groups[i];
2404         OptionsContext o;
2405
2406         init_options(&o);
2407         o.g = g;
2408
2409         ret = parse_optgroup(&o, g);
2410         if (ret < 0) {
2411             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2412                    "%s.\n", inout, g->arg);
2413             return ret;
2414         }
2415
2416         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2417         ret = open_file(&o, g->arg);
2418         uninit_options(&o);
2419         if (ret < 0) {
2420             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2421                    inout, g->arg);
2422             return ret;
2423         }
2424         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2425     }
2426
2427     return 0;
2428 }
2429
2430 int avconv_parse_options(int argc, char **argv)
2431 {
2432     OptionParseContext octx;
2433     uint8_t error[128];
2434     int ret;
2435
2436     memset(&octx, 0, sizeof(octx));
2437
2438     /* split the commandline into an internal representation */
2439     ret = split_commandline(&octx, argc, argv, options, groups,
2440                             FF_ARRAY_ELEMS(groups));
2441     if (ret < 0) {
2442         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2443         goto fail;
2444     }
2445
2446     /* apply global options */
2447     ret = parse_optgroup(NULL, &octx.global_opts);
2448     if (ret < 0) {
2449         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2450         goto fail;
2451     }
2452
2453     /* open input files */
2454     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2455     if (ret < 0) {
2456         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2457         goto fail;
2458     }
2459
2460     /* create the complex filtergraphs */
2461     ret = init_complex_filters();
2462     if (ret < 0) {
2463         av_log(NULL, AV_LOG_FATAL, "Error initializing complex filters.\n");
2464         goto fail;
2465     }
2466
2467     /* open output files */
2468     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2469     if (ret < 0) {
2470         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2471         goto fail;
2472     }
2473
2474 fail:
2475     uninit_parse_context(&octx);
2476     if (ret < 0) {
2477         av_strerror(ret, error, sizeof(error));
2478         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2479     }
2480     return ret;
2481 }
2482
2483 #define OFFSET(x) offsetof(OptionsContext, x)
2484 const OptionDef options[] = {
2485     /* main options */
2486     CMDUTILS_COMMON_OPTIONS
2487     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2488                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2489         "force format", "fmt" },
2490     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2491         "overwrite output files" },
2492     { "n",              OPT_BOOL,                                    {              &file_skip },
2493         "never overwrite output files" },
2494     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2495                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2496         "codec name", "codec" },
2497     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2498                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2499         "codec name", "codec" },
2500     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2501                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2502         "preset name", "preset" },
2503     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2504                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2505         "set input stream mapping",
2506         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2507     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2508                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2509         "set metadata information of outfile from infile",
2510         "outfile[,metadata]:infile[,metadata]" },
2511     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2512                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2513         "set chapters mapping", "input_file_index" },
2514     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2515                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2516         "record or transcode \"duration\" seconds of audio/video",
2517         "duration" },
2518     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2519         "set the limit file size in bytes", "limit_size" },
2520     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2521                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2522         "set the start time offset", "time_off" },
2523     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2524                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2525         "enable/disable accurate seeking with -ss" },
2526     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2527                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2528         "set the input ts offset", "time_off" },
2529     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2530                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2531         "set the input ts scale", "scale" },
2532     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2533         "add metadata", "string=string" },
2534     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2535                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2536         "set the number of data frames to record", "number" },
2537     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2538         "add timings for benchmarking" },
2539     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2540         "set max runtime in seconds", "limit" },
2541     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2542         "dump each input packet" },
2543     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2544         "when dumping packets, also dump the payload" },
2545     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2546                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2547         "read input at native frame rate", "" },
2548     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2549         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2550         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2551     { "vsync",          HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_vsync },
2552         "video sync method", "" },
2553     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2554         "audio sync method", "" },
2555     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2556         "audio drift threshold", "threshold" },
2557     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2558         "copy timestamps" },
2559     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2560         "copy input stream time base when stream copying" },
2561     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2562                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2563         "finish encoding within shortest input" },
2564     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2565         "timestamp discontinuity delta threshold", "threshold" },
2566     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2567         "exit on error", "error" },
2568     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2569                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2570         "copy initial non-keyframes" },
2571     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2572         "set the number of frames to record", "number" },
2573     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2574                         OPT_EXPERT | OPT_OUTPUT | OPT_INPUT,         { .off = OFFSET(codec_tags) },
2575         "force codec tag/fourcc", "fourcc/tag" },
2576     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2577                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2578         "use fixed quality scale (VBR)", "q" },
2579     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2580                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2581         "use fixed quality scale (VBR)", "q" },
2582     { "b",              HAS_ARG | OPT_INT | OPT_SPEC | OPT_OUTPUT,    { .off = OFFSET(bitrates) },
2583         "set stream bitrate in bits/second", "bitrate" },
2584     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2585         "set stream filterchain", "filter_list" },
2586     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2587         "read stream filtergraph description from a file", "filename" },
2588     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2589         "create a complex filtergraph", "graph_description" },
2590     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2591         "read complex filtergraph description from a file", "filename" },
2592     { "stats",          OPT_BOOL,                                    { &print_stats },
2593         "print progress report during encoding", },
2594     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2595                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2596         "add an attachment to the output file", "filename" },
2597     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2598                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2599         "extract an attachment into a file", "filename" },
2600     { "loop", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_INPUT |
2601                         OPT_OFFSET,                                  { .off = OFFSET(loop) }, "set number of times input stream shall be looped", "loop count" },
2602
2603     /* video options */
2604     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2605         "set the number of video frames to record", "number" },
2606     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2607                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2608         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2609     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2610                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2611         "set frame size (WxH or abbreviation)", "size" },
2612     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2613                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2614         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2615     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2616                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2617         "set pixel format", "format" },
2618     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2619         "disable video" },
2620     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2621         "discard threshold", "n" },
2622     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2623                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2624         "rate control override for specific intervals", "override" },
2625     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2626                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2627         "force video codec ('copy' to copy stream)", "codec" },
2628     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2629         "select the pass number (1 or 2)", "n" },
2630     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2631                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2632         "select two pass log file name prefix", "prefix" },
2633     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = &opt_vstats },
2634         "dump video coding statistics to file" },
2635     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { .func_arg = opt_vstats_file },
2636         "dump video coding statistics to file", "file" },
2637     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2638         "video filters", "filter list" },
2639     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2640                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2641         "specify intra matrix coeffs", "matrix" },
2642     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2643                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2644         "specify inter matrix coeffs", "matrix" },
2645     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2646                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2647         "top=1/bottom=0/auto=-1 field first", "" },
2648     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2649         "intra_dc_precision", "precision" },
2650     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2651                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2652         "force video tag/fourcc", "fourcc/tag" },
2653     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2654         "show QP histogram" },
2655     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2656                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2657         "force the selected framerate, disable the best supported framerate selection" },
2658     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2659                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2660         "set the value of an outfile streamid", "streamIndex:value" },
2661     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2662                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2663         "force key frames at specified timestamps", "timestamps" },
2664     { "hwaccel",          OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2665                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccels) },
2666         "use HW accelerated decoding", "hwaccel name" },
2667     { "hwaccel_device",   OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2668                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_devices) },
2669         "select a device for HW acceleration", "devicename" },
2670     { "hwaccel_output_format", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2671                           OPT_SPEC | OPT_INPUT,                                  { .off = OFFSET(hwaccel_output_formats) },
2672         "select output format used with HW accelerated decoding", "format" },
2673
2674     { "hwaccels",         OPT_EXIT,                                              { .func_arg = show_hwaccels },
2675         "show available HW acceleration methods" },
2676     { "autorotate",       HAS_ARG | OPT_BOOL | OPT_SPEC |
2677                           OPT_EXPERT | OPT_INPUT,                                { .off = OFFSET(autorotate) },
2678         "automatically insert correct rotate filters" },
2679     { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT,                        { &hwaccel_lax_profile_check},
2680         "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" },
2681
2682     /* audio options */
2683     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2684         "set the number of audio frames to record", "number" },
2685     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2686         "set audio quality (codec-specific)", "quality", },
2687     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2688                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2689         "set audio sampling rate (in Hz)", "rate" },
2690     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2691                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2692         "set number of audio channels", "channels" },
2693     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2694         "disable audio" },
2695     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2696                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2697         "force audio codec ('copy' to copy stream)", "codec" },
2698     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2699                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2700         "force audio tag/fourcc", "fourcc/tag" },
2701     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2702         "change audio volume (256=normal)" , "volume" },
2703     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2704                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2705         "set sample format", "format" },
2706     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2707                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2708         "set channel layout", "layout" },
2709     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2710         "audio filters", "filter list" },
2711
2712     /* subtitle options */
2713     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2714         "disable subtitle" },
2715     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2716         "force subtitle codec ('copy' to copy stream)", "codec" },
2717     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2718         , "force subtitle tag/fourcc", "fourcc/tag" },
2719
2720     /* grab options */
2721     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2722
2723     /* muxer options */
2724     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2725         "set the maximum demux-decode delay", "seconds" },
2726     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2727         "set the initial demux-decode delay", "seconds" },
2728
2729     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2730         "A comma-separated list of bitstream filters", "bitstream_filters" },
2731
2732     { "max_muxing_queue_size", HAS_ARG | OPT_INT | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(max_muxing_queue_size) },
2733         "maximum number of packets that can be buffered while waiting for all streams to initialize", "packets" },
2734
2735     /* data codec support */
2736     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2737         "force data codec ('copy' to copy stream)", "codec" },
2738
2739 #if CONFIG_VAAPI
2740     { "vaapi_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_vaapi_device },
2741         "set VAAPI hardware device (DRM path or X11 display name)", "device" },
2742 #endif
2743
2744     { NULL, },
2745 };