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