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