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