avconv_opt.c

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