git.sesse.net Git - ffmpeg/blob - avconv_opt.c

   1 /*
   2  * avconv option parsing
   3  *
   4  * This file is part of Libav.
   5  *
   6  * Libav is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libav is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with Libav; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include <stdint.h>
  22
  23 #include "avconv.h"
  24 #include "cmdutils.h"
  25
  26 #include "libavformat/avformat.h"
  27
  28 #include "libavcodec/avcodec.h"
  29
  30 #include "libavfilter/avfilter.h"
  31
  32 #include "libavutil/avassert.h"
  33 #include "libavutil/avstring.h"
  34 #include "libavutil/avutil.h"
  35 #include "libavutil/channel_layout.h"
  36 #include "libavutil/intreadwrite.h"
  37 #include "libavutil/fifo.h"
  38 #include "libavutil/mathematics.h"
  39 #include "libavutil/opt.h"
  40 #include "libavutil/parseutils.h"
  41 #include "libavutil/pixdesc.h"
  42 #include "libavutil/pixfmt.h"
  43
  44 #define 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->recording_time = o->recording_time;
 693     f->ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
 694     f->nb_streams = ic->nb_streams;
 695     f->rate_emu   = o->rate_emu;
 696     f->accurate_seek = o->accurate_seek;
 697
 698     /* check if all codec options have been used */
 699     unused_opts = strip_specifiers(o->g->codec_opts);
 700     for (i = f->ist_index; i < nb_input_streams; i++) {
 701         e = NULL;
 702         while ((e = av_dict_get(input_streams[i]->opts, "", e,
 703                                 AV_DICT_IGNORE_SUFFIX)))
 704             av_dict_set(&unused_opts, e->key, NULL, 0);
 705     }
 706
 707     e = NULL;
 708     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
 709         const AVClass *class = avcodec_get_class();
 710         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
 711                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
 712         if (!option)
 713             continue;
 714         if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
 715             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
 716                    "input file #%d (%s) is not a decoding option.\n", e->key,
 717                    option->help ? option->help : "", nb_input_files - 1,
 718                    filename);
 719             exit_program(1);
 720         }
 721
 722         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
 723                "input file #%d (%s) has not been used for any stream. The most "
 724                "likely reason is either wrong type (e.g. a video option with "
 725                "no video streams) or that it is a private option of some decoder "
 726                "which was not actually used for any stream.\n", e->key,
 727                option->help ? option->help : "", nb_input_files - 1, filename);
 728     }
 729     av_dict_free(&unused_opts);
 730
 731     for (i = 0; i < o->nb_dump_attachment; i++) {
 732         int j;
 733
 734         for (j = 0; j < ic->nb_streams; j++) {
 735             AVStream *st = ic->streams[j];
 736
 737             if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
 738                 dump_attachment(st, o->dump_attachment[i].u.str);
 739         }
 740     }
 741
 742     for (i = 0; i < orig_nb_streams; i++)
 743         av_dict_free(&opts[i]);
 744     av_freep(&opts);
 745
 746     return 0;
 747 }
 748
 749 static uint8_t *get_line(AVIOContext *s)
 750 {
 751     AVIOContext *line;
 752     uint8_t *buf;
 753     char c;
 754
 755     if (avio_open_dyn_buf(&line) < 0) {
 756         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 757         exit_program(1);
 758     }
 759
 760     while ((c = avio_r8(s)) && c != '\n')
 761         avio_w8(line, c);
 762     avio_w8(line, 0);
 763     avio_close_dyn_buf(line, &buf);
 764
 765     return buf;
 766 }
 767
 768 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 769 {
 770     int i, ret = 1;
 771     char filename[1000];
 772     const char *base[3] = { getenv("AVCONV_DATADIR"),
 773                             getenv("HOME"),
 774                             AVCONV_DATADIR,
 775                             };
 776
 777     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 778         if (!base[i])
 779             continue;
 780         if (codec_name) {
 781             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 782                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 783             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 784         }
 785         if (ret) {
 786             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 787                      i != 1 ? "" : "/.avconv", preset_name);
 788             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 789         }
 790     }
 791     return ret;
 792 }
 793
 794 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 795 {
 796     char *codec_name = NULL;
 797
 798     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 799     if (!codec_name) {
 800         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 801                                                   NULL, ost->st->codec->codec_type);
 802         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 803     } else if (!strcmp(codec_name, "copy"))
 804         ost->stream_copy = 1;
 805     else {
 806         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 807         ost->st->codec->codec_id = ost->enc->id;
 808     }
 809 }
 810
 811 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
 812 {
 813     OutputStream *ost;
 814     AVStream *st = avformat_new_stream(oc, NULL);
 815     int idx      = oc->nb_streams - 1, ret = 0;
 816     char *bsf = NULL, *next, *codec_tag = NULL;
 817     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 818     double qscale = -1;
 819
 820     if (!st) {
 821         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 822         exit_program(1);
 823     }
 824
 825     if (oc->nb_streams - 1 < o->nb_streamid_map)
 826         st->id = o->streamid_map[oc->nb_streams - 1];
 827
 828     GROW_ARRAY(output_streams, nb_output_streams);
 829     if (!(ost = av_mallocz(sizeof(*ost))))
 830         exit_program(1);
 831     output_streams[nb_output_streams - 1] = ost;
 832
 833     ost->file_index = nb_output_files - 1;
 834     ost->index      = idx;
 835     ost->st         = st;
 836     st->codec->codec_type = type;
 837     choose_encoder(o, oc, ost);
 838     if (ost->enc) {
 839         AVIOContext *s = NULL;
 840         char *buf = NULL, *arg = NULL, *preset = NULL;
 841
 842         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 843
 844         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 845         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 846             do  {
 847                 buf = get_line(s);
 848                 if (!buf[0] || buf[0] == '#') {
 849                     av_free(buf);
 850                     continue;
 851                 }
 852                 if (!(arg = strchr(buf, '='))) {
 853                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 854                     exit_program(1);
 855                 }
 856                 *arg++ = 0;
 857                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 858                 av_free(buf);
 859             } while (!s->eof_reached);
 860             avio_close(s);
 861         }
 862         if (ret) {
 863             av_log(NULL, AV_LOG_FATAL,
 864                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
 865                    preset, ost->file_index, ost->index);
 866             exit_program(1);
 867         }
 868     } else {
 869         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
 870     }
 871
 872     avcodec_get_context_defaults3(st->codec, ost->enc);
 873     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 874
 875     ost->max_frames = INT64_MAX;
 876     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 877
 878     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 879     while (bsf) {
 880         if (next = strchr(bsf, ','))
 881             *next++ = 0;
 882         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 883             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 884             exit_program(1);
 885         }
 886         if (bsfc_prev)
 887             bsfc_prev->next = bsfc;
 888         else
 889             ost->bitstream_filters = bsfc;
 890
 891         bsfc_prev = bsfc;
 892         bsf       = next;
 893     }
 894
 895     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 896     if (codec_tag) {
 897         uint32_t tag = strtol(codec_tag, &next, 0);
 898         if (*next)
 899             tag = AV_RL32(codec_tag);
 900         st->codec->codec_tag = tag;
 901     }
 902
 903     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 904     if (qscale >= 0) {
 905         st->codec->flags |= CODEC_FLAG_QSCALE;
 906         st->codec->global_quality = FF_QP2LAMBDA * qscale;
 907     }
 908
 909     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 910         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
 911
 912     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
 913
 914     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
 915
 916     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
 917     ost->last_mux_dts = AV_NOPTS_VALUE;
 918
 919     return ost;
 920 }
 921
 922 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 923 {
 924     int i;
 925     const char *p = str;
 926     for (i = 0;; i++) {
 927         dest[i] = atoi(p);
 928         if (i == 63)
 929             break;
 930         p = strchr(p, ',');
 931         if (!p) {
 932             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
 933             exit_program(1);
 934         }
 935         p++;
 936     }
 937 }
 938
 939 /* read file contents into a string */
 940 static uint8_t *read_file(const char *filename)
 941 {
 942     AVIOContext *pb      = NULL;
 943     AVIOContext *dyn_buf = NULL;
 944     int ret = avio_open(&pb, filename, AVIO_FLAG_READ);
 945     uint8_t buf[1024], *str;
 946
 947     if (ret < 0) {
 948         av_log(NULL, AV_LOG_ERROR, "Error opening file %s.\n", filename);
 949         return NULL;
 950     }
 951
 952     ret = avio_open_dyn_buf(&dyn_buf);
 953     if (ret < 0) {
 954         avio_closep(&pb);
 955         return NULL;
 956     }
 957     while ((ret = avio_read(pb, buf, sizeof(buf))) > 0)
 958         avio_write(dyn_buf, buf, ret);
 959     avio_w8(dyn_buf, 0);
 960     avio_closep(&pb);
 961
 962     ret = avio_close_dyn_buf(dyn_buf, &str);
 963     if (ret < 0)
 964         return NULL;
 965     return str;
 966 }
 967
 968 static char *get_ost_filters(OptionsContext *o, AVFormatContext *oc,
 969                              OutputStream *ost)
 970 {
 971     AVStream *st = ost->st;
 972     char *filter = NULL, *filter_script = NULL;
 973
 974     MATCH_PER_STREAM_OPT(filter_scripts, str, filter_script, oc, st);
 975     MATCH_PER_STREAM_OPT(filters, str, filter, oc, st);
 976
 977     if (filter_script && filter) {
 978         av_log(NULL, AV_LOG_ERROR, "Both -filter and -filter_script set for "
 979                "output stream #%d:%d.\n", nb_output_files, st->index);
 980         exit_program(1);
 981     }
 982
 983     if (filter_script)
 984         return read_file(filter_script);
 985     else if (filter)
 986         return av_strdup(filter);
 987
 988     return av_strdup(st->codec->codec_type == AVMEDIA_TYPE_VIDEO ?
 989                      "null" : "anull");
 990 }
 991
 992 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
 993 {
 994     AVStream *st;
 995     OutputStream *ost;
 996     AVCodecContext *video_enc;
 997     char *frame_aspect_ratio = NULL;
 998
 999     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
1000     st  = ost->st;
1001     video_enc = st->codec;
1002
1003     MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
1004     if (frame_aspect_ratio)
1005         ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
1006
1007     if (!ost->stream_copy) {
1008         const char *p = NULL;
1009         char *frame_rate = NULL, *frame_size = NULL;
1010         char *frame_pix_fmt = NULL;
1011         char *intra_matrix = NULL, *inter_matrix = NULL;
1012         int do_pass = 0;
1013         int i;
1014
1015         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
1016         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
1017             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
1018             exit_program(1);
1019         }
1020
1021         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
1022         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
1023             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
1024             exit_program(1);
1025         }
1026
1027         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
1028         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
1029             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
1030             exit_program(1);
1031         }
1032         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
1033
1034         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
1035         if (intra_matrix) {
1036             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
1037                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
1038                 exit_program(1);
1039             }
1040             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
1041         }
1042         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
1043         if (inter_matrix) {
1044             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
1045                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
1046                 exit_program(1);
1047             }
1048             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
1049         }
1050
1051         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
1052         for (i = 0; p; i++) {
1053             int start, end, q;
1054             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
1055             if (e != 3) {
1056                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
1057                 exit_program(1);
1058             }
1059             video_enc->rc_override =
1060                 av_realloc(video_enc->rc_override,
1061                            sizeof(RcOverride) * (i + 1));
1062             video_enc->rc_override[i].start_frame = start;
1063             video_enc->rc_override[i].end_frame   = end;
1064             if (q > 0) {
1065                 video_enc->rc_override[i].qscale         = q;
1066                 video_enc->rc_override[i].quality_factor = 1.0;
1067             }
1068             else {
1069                 video_enc->rc_override[i].qscale         = 0;
1070                 video_enc->rc_override[i].quality_factor = -q/100.0;
1071             }
1072             p = strchr(p, '/');
1073             if (p) p++;
1074         }
1075         video_enc->rc_override_count = i;
1076         video_enc->intra_dc_precision = intra_dc_precision - 8;
1077
1078         /* two pass mode */
1079         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
1080         if (do_pass) {
1081             if (do_pass == 1) {
1082                 video_enc->flags |= CODEC_FLAG_PASS1;
1083             } else {
1084                 video_enc->flags |= CODEC_FLAG_PASS2;
1085             }
1086         }
1087
1088         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
1089         if (ost->logfile_prefix &&
1090             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
1091             exit_program(1);
1092
1093         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
1094         if (ost->forced_keyframes)
1095             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
1096
1097         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
1098
1099         ost->top_field_first = -1;
1100         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
1101
1102
1103         ost->avfilter = get_ost_filters(o, oc, ost);
1104         if (!ost->avfilter)
1105             exit_program(1);
1106     } else {
1107         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
1108     }
1109
1110     return ost;
1111 }
1112
1113 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
1114 {
1115     AVStream *st;
1116     OutputStream *ost;
1117     AVCodecContext *audio_enc;
1118
1119     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
1120     st  = ost->st;
1121
1122     audio_enc = st->codec;
1123     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1124
1125     if (!ost->stream_copy) {
1126         char *sample_fmt = NULL;
1127
1128         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1129
1130         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1131         if (sample_fmt &&
1132             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1133             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1134             exit_program(1);
1135         }
1136
1137         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1138
1139         ost->avfilter = get_ost_filters(o, oc, ost);
1140         if (!ost->avfilter)
1141             exit_program(1);
1142     }
1143
1144     return ost;
1145 }
1146
1147 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1148 {
1149     OutputStream *ost;
1150
1151     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1152     if (!ost->stream_copy) {
1153         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1154         exit_program(1);
1155     }
1156
1157     return ost;
1158 }
1159
1160 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1161 {
1162     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1163     ost->stream_copy = 1;
1164     ost->finished    = 1;
1165     return ost;
1166 }
1167
1168 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1169 {
1170     AVStream *st;
1171     OutputStream *ost;
1172     AVCodecContext *subtitle_enc;
1173
1174     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1175     st  = ost->st;
1176     subtitle_enc = st->codec;
1177
1178     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1179
1180     return ost;
1181 }
1182
1183 /* arg format is "output-stream-index:streamid-value". */
1184 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1185 {
1186     OptionsContext *o = optctx;
1187     int idx;
1188     char *p;
1189     char idx_str[16];
1190
1191     av_strlcpy(idx_str, arg, sizeof(idx_str));
1192     p = strchr(idx_str, ':');
1193     if (!p) {
1194         av_log(NULL, AV_LOG_FATAL,
1195                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1196                arg, opt);
1197         exit_program(1);
1198     }
1199     *p++ = '\0';
1200     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1201     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1202     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1203     return 0;
1204 }
1205
1206 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1207 {
1208     AVFormatContext *is = ifile->ctx;
1209     AVFormatContext *os = ofile->ctx;
1210     AVChapter **tmp;
1211     int i;
1212
1213     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1214     if (!tmp)
1215         return AVERROR(ENOMEM);
1216     os->chapters = tmp;
1217
1218     for (i = 0; i < is->nb_chapters; i++) {
1219         AVChapter *in_ch = is->chapters[i], *out_ch;
1220         int64_t start_time = (ofile->start_time == AV_NOPTS_VALUE) ? 0 : ofile->start_time;
1221         int64_t ts_off   = av_rescale_q(start_time - ifile->ts_offset,
1222                                        AV_TIME_BASE_Q, in_ch->time_base);
1223         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1224                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1225
1226
1227         if (in_ch->end < ts_off)
1228             continue;
1229         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1230             break;
1231
1232         out_ch = av_mallocz(sizeof(AVChapter));
1233         if (!out_ch)
1234             return AVERROR(ENOMEM);
1235
1236         out_ch->id        = in_ch->id;
1237         out_ch->time_base = in_ch->time_base;
1238         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1239         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1240
1241         if (copy_metadata)
1242             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1243
1244         os->chapters[os->nb_chapters++] = out_ch;
1245     }
1246     return 0;
1247 }
1248
1249 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1250                                AVFormatContext *oc)
1251 {
1252     OutputStream *ost;
1253
1254     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1255                                   ofilter->out_tmp->pad_idx)) {
1256     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1257     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1258     default:
1259         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1260                "currently.\n");
1261         exit_program(1);
1262     }
1263
1264     ost->source_index = -1;
1265     ost->filter       = ofilter;
1266
1267     ofilter->ost      = ost;
1268
1269     if (ost->stream_copy) {
1270         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1271                "which is fed from a complex filtergraph. Filtering and streamcopy "
1272                "cannot be used together.\n", ost->file_index, ost->index);
1273         exit_program(1);
1274     }
1275
1276     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1277         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1278         exit_program(1);
1279     }
1280     avfilter_inout_free(&ofilter->out_tmp);
1281 }
1282
1283 static int configure_complex_filters(void)
1284 {
1285     int i, ret = 0;
1286
1287     for (i = 0; i < nb_filtergraphs; i++)
1288         if (!filtergraphs[i]->graph &&
1289             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1290             return ret;
1291     return 0;
1292 }
1293
1294 static int open_output_file(OptionsContext *o, const char *filename)
1295 {
1296     AVFormatContext *oc;
1297     int i, j, err;
1298     AVOutputFormat *file_oformat;
1299     OutputFile *of;
1300     OutputStream *ost;
1301     InputStream  *ist;
1302     AVDictionary *unused_opts = NULL;
1303     AVDictionaryEntry *e = NULL;
1304
1305     if (configure_complex_filters() < 0) {
1306         av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
1307         exit_program(1);
1308     }
1309
1310     GROW_ARRAY(output_files, nb_output_files);
1311     of = av_mallocz(sizeof(*of));
1312     if (!of)
1313         exit_program(1);
1314     output_files[nb_output_files - 1] = of;
1315
1316     of->ost_index      = nb_output_streams;
1317     of->recording_time = o->recording_time;
1318     of->start_time     = o->start_time;
1319     of->limit_filesize = o->limit_filesize;
1320     of->shortest       = o->shortest;
1321     av_dict_copy(&of->opts, o->g->format_opts, 0);
1322
1323     if (!strcmp(filename, "-"))
1324         filename = "pipe:";
1325
1326     oc = avformat_alloc_context();
1327     if (!oc) {
1328         print_error(filename, AVERROR(ENOMEM));
1329         exit_program(1);
1330     }
1331     of->ctx = oc;
1332     if (o->recording_time != INT64_MAX)
1333         oc->duration = o->recording_time;
1334
1335     if (o->format) {
1336         file_oformat = av_guess_format(o->format, NULL, NULL);
1337         if (!file_oformat) {
1338             av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
1339             exit_program(1);
1340         }
1341     } else {
1342         file_oformat = av_guess_format(NULL, filename, NULL);
1343         if (!file_oformat) {
1344             av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
1345                    filename);
1346             exit_program(1);
1347         }
1348     }
1349
1350     oc->oformat = file_oformat;
1351     oc->interrupt_callback = int_cb;
1352     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
1353
1354     /* create streams for all unlabeled output pads */
1355     for (i = 0; i < nb_filtergraphs; i++) {
1356         FilterGraph *fg = filtergraphs[i];
1357         for (j = 0; j < fg->nb_outputs; j++) {
1358             OutputFilter *ofilter = fg->outputs[j];
1359
1360             if (!ofilter->out_tmp || ofilter->out_tmp->name)
1361                 continue;
1362
1363             switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1364                                           ofilter->out_tmp->pad_idx)) {
1365             case AVMEDIA_TYPE_VIDEO:    o->video_disable    = 1; break;
1366             case AVMEDIA_TYPE_AUDIO:    o->audio_disable    = 1; break;
1367             case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
1368             }
1369             init_output_filter(ofilter, o, oc);
1370         }
1371     }
1372
1373     if (!o->nb_stream_maps) {
1374         /* pick the "best" stream of each type */
1375 #define NEW_STREAM(type, index)\
1376         if (index >= 0) {\
1377             ost = new_ ## type ## _stream(o, oc);\
1378             ost->source_index = index;\
1379             ost->sync_ist     = input_streams[index];\
1380             input_streams[index]->discard = 0;\
1381             input_streams[index]->st->discard = AVDISCARD_NONE;\
1382         }
1383
1384         /* video: highest resolution */
1385         if (!o->video_disable && oc->oformat->video_codec != AV_CODEC_ID_NONE) {
1386             int area = 0, idx = -1;
1387             for (i = 0; i < nb_input_streams; i++) {
1388                 ist = input_streams[i];
1389                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1390                     ist->st->codec->width * ist->st->codec->height > area) {
1391                     area = ist->st->codec->width * ist->st->codec->height;
1392                     idx = i;
1393                 }
1394             }
1395             NEW_STREAM(video, idx);
1396         }
1397
1398         /* audio: most channels */
1399         if (!o->audio_disable && oc->oformat->audio_codec != AV_CODEC_ID_NONE) {
1400             int channels = 0, idx = -1;
1401             for (i = 0; i < nb_input_streams; i++) {
1402                 ist = input_streams[i];
1403                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
1404                     ist->st->codec->channels > channels) {
1405                     channels = ist->st->codec->channels;
1406                     idx = i;
1407                 }
1408             }
1409             NEW_STREAM(audio, idx);
1410         }
1411
1412         /* subtitles: pick first */
1413         if (!o->subtitle_disable && oc->oformat->subtitle_codec != AV_CODEC_ID_NONE) {
1414             for (i = 0; i < nb_input_streams; i++)
1415                 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1416                     NEW_STREAM(subtitle, i);
1417                     break;
1418                 }
1419         }
1420         /* do something with data? */
1421     } else {
1422         for (i = 0; i < o->nb_stream_maps; i++) {
1423             StreamMap *map = &o->stream_maps[i];
1424
1425             if (map->disabled)
1426                 continue;
1427
1428             if (map->linklabel) {
1429                 FilterGraph *fg;
1430                 OutputFilter *ofilter = NULL;
1431                 int j, k;
1432
1433                 for (j = 0; j < nb_filtergraphs; j++) {
1434                     fg = filtergraphs[j];
1435                     for (k = 0; k < fg->nb_outputs; k++) {
1436                         AVFilterInOut *out = fg->outputs[k]->out_tmp;
1437                         if (out && !strcmp(out->name, map->linklabel)) {
1438                             ofilter = fg->outputs[k];
1439                             goto loop_end;
1440                         }
1441                     }
1442                 }
1443 loop_end:
1444                 if (!ofilter) {
1445                     av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
1446                            "in any defined filter graph.\n", map->linklabel);
1447                     exit_program(1);
1448                 }
1449                 init_output_filter(ofilter, o, oc);
1450             } else {
1451                 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
1452                 switch (ist->st->codec->codec_type) {
1453                 case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
1454                 case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
1455                 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
1456                 case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
1457                 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
1458                 default:
1459                     av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
1460                            map->file_index, map->stream_index);
1461                     exit_program(1);
1462                 }
1463
1464                 ost->source_index = input_files[map->file_index]->ist_index + map->stream_index;
1465                 ost->sync_ist     = input_streams[input_files[map->sync_file_index]->ist_index +
1466                                                map->sync_stream_index];
1467                 ist->discard = 0;
1468                 ist->st->discard = AVDISCARD_NONE;
1469             }
1470         }
1471     }
1472
1473     /* handle attached files */
1474     for (i = 0; i < o->nb_attachments; i++) {
1475         AVIOContext *pb;
1476         uint8_t *attachment;
1477         const char *p;
1478         int64_t len;
1479
1480         if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
1481             av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
1482                    o->attachments[i]);
1483             exit_program(1);
1484         }
1485         if ((len = avio_size(pb)) <= 0) {
1486             av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
1487                    o->attachments[i]);
1488             exit_program(1);
1489         }
1490         if (!(attachment = av_malloc(len))) {
1491             av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
1492                    o->attachments[i]);
1493             exit_program(1);
1494         }
1495         avio_read(pb, attachment, len);
1496
1497         ost = new_attachment_stream(o, oc);
1498         ost->stream_copy               = 0;
1499         ost->source_index              = -1;
1500         ost->attachment_filename       = o->attachments[i];
1501         ost->st->codec->extradata      = attachment;
1502         ost->st->codec->extradata_size = len;
1503
1504         p = strrchr(o->attachments[i], '/');
1505         av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
1506         avio_close(pb);
1507     }
1508
1509     /* check if all codec options have been used */
1510     unused_opts = strip_specifiers(o->g->codec_opts);
1511     for (i = of->ost_index; i < nb_output_streams; i++) {
1512         e = NULL;
1513         while ((e = av_dict_get(output_streams[i]->opts, "", e,
1514                                 AV_DICT_IGNORE_SUFFIX)))
1515             av_dict_set(&unused_opts, e->key, NULL, 0);
1516     }
1517
1518     e = NULL;
1519     while ((e = av_dict_get(unused_opts, "", e, AV_DICT_IGNORE_SUFFIX))) {
1520         const AVClass *class = avcodec_get_class();
1521         const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1522                                              AV_OPT_SEARCH_CHILDREN | AV_OPT_SEARCH_FAKE_OBJ);
1523         if (!option)
1524             continue;
1525         if (!(option->flags & AV_OPT_FLAG_ENCODING_PARAM)) {
1526             av_log(NULL, AV_LOG_ERROR, "Codec AVOption %s (%s) specified for "
1527                    "output file #%d (%s) is not an encoding option.\n", e->key,
1528                    option->help ? option->help : "", nb_output_files - 1,
1529                    filename);
1530             exit_program(1);
1531         }
1532
1533         av_log(NULL, AV_LOG_WARNING, "Codec AVOption %s (%s) specified for "
1534                "output file #%d (%s) has not been used for any stream. The most "
1535                "likely reason is either wrong type (e.g. a video option with "
1536                "no video streams) or that it is a private option of some encoder "
1537                "which was not actually used for any stream.\n", e->key,
1538                option->help ? option->help : "", nb_output_files - 1, filename);
1539     }
1540     av_dict_free(&unused_opts);
1541
1542     /* check filename in case of an image number is expected */
1543     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
1544         if (!av_filename_number_test(oc->filename)) {
1545             print_error(oc->filename, AVERROR(EINVAL));
1546             exit_program(1);
1547         }
1548     }
1549
1550     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
1551         /* test if it already exists to avoid losing precious files */
1552         assert_file_overwrite(filename);
1553
1554         /* open the file */
1555         if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
1556                               &oc->interrupt_callback,
1557                               &of->opts)) < 0) {
1558             print_error(filename, err);
1559             exit_program(1);
1560         }
1561     }
1562
1563     if (o->mux_preload) {
1564         uint8_t buf[64];
1565         snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
1566         av_dict_set(&of->opts, "preload", buf, 0);
1567     }
1568     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
1569     oc->flags |= AVFMT_FLAG_NONBLOCK;
1570
1571     /* copy metadata */
1572     for (i = 0; i < o->nb_metadata_map; i++) {
1573         char *p;
1574         int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
1575
1576         if (in_file_index >= nb_input_files) {
1577             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1578             exit_program(1);
1579         }
1580         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1581                       in_file_index >= 0 ?
1582                       input_files[in_file_index]->ctx : NULL, o);
1583     }
1584
1585     /* copy chapters */
1586     if (o->chapters_input_file >= nb_input_files) {
1587         if (o->chapters_input_file == INT_MAX) {
1588             /* copy chapters from the first input file that has them*/
1589             o->chapters_input_file = -1;
1590             for (i = 0; i < nb_input_files; i++)
1591                 if (input_files[i]->ctx->nb_chapters) {
1592                     o->chapters_input_file = i;
1593                     break;
1594                 }
1595         } else {
1596             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
1597                    o->chapters_input_file);
1598             exit_program(1);
1599         }
1600     }
1601     if (o->chapters_input_file >= 0)
1602         copy_chapters(input_files[o->chapters_input_file], of,
1603                       !o->metadata_chapters_manual);
1604
1605     /* copy global metadata by default */
1606     if (!o->metadata_global_manual && nb_input_files)
1607         av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
1608                      AV_DICT_DONT_OVERWRITE);
1609     if (!o->metadata_streams_manual)
1610         for (i = of->ost_index; i < nb_output_streams; i++) {
1611             InputStream *ist;
1612             if (output_streams[i]->source_index < 0)         /* this is true e.g. for attached files */
1613                 continue;
1614             ist = input_streams[output_streams[i]->source_index];
1615             av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
1616         }
1617
1618     /* process manually set metadata */
1619     for (i = 0; i < o->nb_metadata; i++) {
1620         AVDictionary **m;
1621         char type, *val;
1622         const char *stream_spec;
1623         int index = 0, j, ret;
1624
1625         val = strchr(o->metadata[i].u.str, '=');
1626         if (!val) {
1627             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
1628                    o->metadata[i].u.str);
1629             exit_program(1);
1630         }
1631         *val++ = 0;
1632
1633         parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
1634         if (type == 's') {
1635             for (j = 0; j < oc->nb_streams; j++) {
1636                 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
1637                     av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
1638                 } else if (ret < 0)
1639                     exit_program(1);
1640             }
1641         }
1642         else {
1643             switch (type) {
1644             case 'g':
1645                 m = &oc->metadata;
1646                 break;
1647             case 'c':
1648                 if (index < 0 || index >= oc->nb_chapters) {
1649                     av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
1650                     exit_program(1);
1651                 }
1652                 m = &oc->chapters[index]->metadata;
1653                 break;
1654             default:
1655                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
1656                 exit_program(1);
1657             }
1658             av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
1659         }
1660     }
1661
1662     return 0;
1663 }
1664
1665 static int opt_target(void *optctx, const char *opt, const char *arg)
1666 {
1667     OptionsContext *o = optctx;
1668     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
1669     static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
1670
1671     if (!strncmp(arg, "pal-", 4)) {
1672         norm = PAL;
1673         arg += 4;
1674     } else if (!strncmp(arg, "ntsc-", 5)) {
1675         norm = NTSC;
1676         arg += 5;
1677     } else if (!strncmp(arg, "film-", 5)) {
1678         norm = FILM;
1679         arg += 5;
1680     } else {
1681         /* Try to determine PAL/NTSC by peeking in the input files */
1682         if (nb_input_files) {
1683             int i, j, fr;
1684             for (j = 0; j < nb_input_files; j++) {
1685                 for (i = 0; i < input_files[j]->nb_streams; i++) {
1686                     AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
1687                     if (c->codec_type != AVMEDIA_TYPE_VIDEO)
1688                         continue;
1689                     fr = c->time_base.den * 1000 / c->time_base.num;
1690                     if (fr == 25000) {
1691                         norm = PAL;
1692                         break;
1693                     } else if ((fr == 29970) || (fr == 23976)) {
1694                         norm = NTSC;
1695                         break;
1696                     }
1697                 }
1698                 if (norm != UNKNOWN)
1699                     break;
1700             }
1701         }
1702         if (norm != UNKNOWN)
1703             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
1704     }
1705
1706     if (norm == UNKNOWN) {
1707         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
1708         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
1709         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
1710         exit_program(1);
1711     }
1712
1713     if (!strcmp(arg, "vcd")) {
1714         opt_video_codec(o, "c:v", "mpeg1video");
1715         opt_audio_codec(o, "c:a", "mp2");
1716         parse_option(o, "f", "vcd", options);
1717
1718         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
1719         parse_option(o, "r", frame_rates[norm], options);
1720         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1721
1722         opt_default(NULL, "b", "1150000");
1723         opt_default(NULL, "maxrate", "1150000");
1724         opt_default(NULL, "minrate", "1150000");
1725         opt_default(NULL, "bufsize", "327680"); // 40*1024*8;
1726
1727         opt_default(NULL, "b:a", "224000");
1728         parse_option(o, "ar", "44100", options);
1729         parse_option(o, "ac", "2", options);
1730
1731         opt_default(NULL, "packetsize", "2324");
1732         opt_default(NULL, "muxrate", "1411200"); // 2352 * 75 * 8;
1733
1734         /* We have to offset the PTS, so that it is consistent with the SCR.
1735            SCR starts at 36000, but the first two packs contain only padding
1736            and the first pack from the other stream, respectively, may also have
1737            been written before.
1738            So the real data starts at SCR 36000+3*1200. */
1739         o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
1740     } else if (!strcmp(arg, "svcd")) {
1741
1742         opt_video_codec(o, "c:v", "mpeg2video");
1743         opt_audio_codec(o, "c:a", "mp2");
1744         parse_option(o, "f", "svcd", options);
1745
1746         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
1747         parse_option(o, "r", frame_rates[norm], options);
1748         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1749
1750         opt_default(NULL, "b", "2040000");
1751         opt_default(NULL, "maxrate", "2516000");
1752         opt_default(NULL, "minrate", "0"); // 1145000;
1753         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1754         opt_default(NULL, "flags", "+scan_offset");
1755
1756
1757         opt_default(NULL, "b:a", "224000");
1758         parse_option(o, "ar", "44100", options);
1759
1760         opt_default(NULL, "packetsize", "2324");
1761
1762     } else if (!strcmp(arg, "dvd")) {
1763
1764         opt_video_codec(o, "c:v", "mpeg2video");
1765         opt_audio_codec(o, "c:a", "ac3");
1766         parse_option(o, "f", "dvd", options);
1767
1768         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1769         parse_option(o, "r", frame_rates[norm], options);
1770         opt_default(NULL, "g", norm == PAL ? "15" : "18");
1771
1772         opt_default(NULL, "b", "6000000");
1773         opt_default(NULL, "maxrate", "9000000");
1774         opt_default(NULL, "minrate", "0"); // 1500000;
1775         opt_default(NULL, "bufsize", "1835008"); // 224*1024*8;
1776
1777         opt_default(NULL, "packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
1778         opt_default(NULL, "muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
1779
1780         opt_default(NULL, "b:a", "448000");
1781         parse_option(o, "ar", "48000", options);
1782
1783     } else if (!strncmp(arg, "dv", 2)) {
1784
1785         parse_option(o, "f", "dv", options);
1786
1787         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
1788         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
1789                           norm == PAL ? "yuv420p" : "yuv411p", options);
1790         parse_option(o, "r", frame_rates[norm], options);
1791
1792         parse_option(o, "ar", "48000", options);
1793         parse_option(o, "ac", "2", options);
1794
1795     } else {
1796         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
1797         return AVERROR(EINVAL);
1798     }
1799     return 0;
1800 }
1801
1802 static int opt_vstats_file(void *optctx, const char *opt, const char *arg)
1803 {
1804     av_free (vstats_filename);
1805     vstats_filename = av_strdup (arg);
1806     return 0;
1807 }
1808
1809 static int opt_vstats(void *optctx, const char *opt, const char *arg)
1810 {
1811     char filename[40];
1812     time_t today2 = time(NULL);
1813     struct tm *today = localtime(&today2);
1814
1815     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
1816              today->tm_sec);
1817     return opt_vstats_file(NULL, opt, filename);
1818 }
1819
1820 static int opt_video_frames(void *optctx, const char *opt, const char *arg)
1821 {
1822     OptionsContext *o = optctx;
1823     return parse_option(o, "frames:v", arg, options);
1824 }
1825
1826 static int opt_audio_frames(void *optctx, const char *opt, const char *arg)
1827 {
1828     OptionsContext *o = optctx;
1829     return parse_option(o, "frames:a", arg, options);
1830 }
1831
1832 static int opt_data_frames(void *optctx, const char *opt, const char *arg)
1833 {
1834     OptionsContext *o = optctx;
1835     return parse_option(o, "frames:d", arg, options);
1836 }
1837
1838 static int opt_video_tag(void *optctx, const char *opt, const char *arg)
1839 {
1840     OptionsContext *o = optctx;
1841     return parse_option(o, "tag:v", arg, options);
1842 }
1843
1844 static int opt_audio_tag(void *optctx, const char *opt, const char *arg)
1845 {
1846     OptionsContext *o = optctx;
1847     return parse_option(o, "tag:a", arg, options);
1848 }
1849
1850 static int opt_subtitle_tag(void *optctx, const char *opt, const char *arg)
1851 {
1852     OptionsContext *o = optctx;
1853     return parse_option(o, "tag:s", arg, options);
1854 }
1855
1856 static int opt_video_filters(void *optctx, const char *opt, const char *arg)
1857 {
1858     OptionsContext *o = optctx;
1859     return parse_option(o, "filter:v", arg, options);
1860 }
1861
1862 static int opt_audio_filters(void *optctx, const char *opt, const char *arg)
1863 {
1864     OptionsContext *o = optctx;
1865     return parse_option(o, "filter:a", arg, options);
1866 }
1867
1868 static int opt_vsync(void *optctx, const char *opt, const char *arg)
1869 {
1870     if      (!av_strcasecmp(arg, "cfr"))         video_sync_method = VSYNC_CFR;
1871     else if (!av_strcasecmp(arg, "vfr"))         video_sync_method = VSYNC_VFR;
1872     else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
1873
1874     if (video_sync_method == VSYNC_AUTO)
1875         video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
1876     return 0;
1877 }
1878
1879 int opt_cpuflags(void *optctx, const char *opt, const char *arg)
1880 {
1881     int flags = av_parse_cpu_flags(arg);
1882
1883     if (flags < 0)
1884         return flags;
1885
1886     av_set_cpu_flags_mask(flags);
1887     return 0;
1888 }
1889
1890 static int opt_channel_layout(void *optctx, const char *opt, const char *arg)
1891 {
1892     OptionsContext *o = optctx;
1893     char layout_str[32];
1894     char *stream_str;
1895     char *ac_str;
1896     int ret, channels, ac_str_size;
1897     uint64_t layout;
1898
1899     layout = av_get_channel_layout(arg);
1900     if (!layout) {
1901         av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
1902         return AVERROR(EINVAL);
1903     }
1904     snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
1905     ret = opt_default(NULL, opt, layout_str);
1906     if (ret < 0)
1907         return ret;
1908
1909     /* set 'ac' option based on channel layout */
1910     channels = av_get_channel_layout_nb_channels(layout);
1911     snprintf(layout_str, sizeof(layout_str), "%d", channels);
1912     stream_str = strchr(opt, ':');
1913     ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
1914     ac_str = av_mallocz(ac_str_size);
1915     if (!ac_str)
1916         return AVERROR(ENOMEM);
1917     av_strlcpy(ac_str, "ac", 3);
1918     if (stream_str)
1919         av_strlcat(ac_str, stream_str, ac_str_size);
1920     ret = parse_option(o, ac_str, layout_str, options);
1921     av_free(ac_str);
1922
1923     return ret;
1924 }
1925
1926 static int opt_audio_qscale(void *optctx, const char *opt, const char *arg)
1927 {
1928     OptionsContext *o = optctx;
1929     return parse_option(o, "q:a", arg, options);
1930 }
1931
1932 static int opt_filter_complex(void *optctx, const char *opt, const char *arg)
1933 {
1934     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1935     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1936         return AVERROR(ENOMEM);
1937     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1938     filtergraphs[nb_filtergraphs - 1]->graph_desc = av_strdup(arg);
1939     if (!filtergraphs[nb_filtergraphs - 1]->graph_desc)
1940         return AVERROR(ENOMEM);
1941     return 0;
1942 }
1943
1944 static int opt_filter_complex_script(void *optctx, const char *opt, const char *arg)
1945 {
1946     uint8_t *graph_desc = read_file(arg);
1947     if (!graph_desc)
1948         return AVERROR(EINVAL);
1949
1950     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1951     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1952         return AVERROR(ENOMEM);
1953     filtergraphs[nb_filtergraphs - 1]->index      = nb_filtergraphs - 1;
1954     filtergraphs[nb_filtergraphs - 1]->graph_desc = graph_desc;
1955     return 0;
1956 }
1957
1958 void show_help_default(const char *opt, const char *arg)
1959 {
1960     /* per-file options have at least one of those set */
1961     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1962     int show_advanced = 0, show_avoptions = 0;
1963
1964     if (opt && *opt) {
1965         if (!strcmp(opt, "long"))
1966             show_advanced = 1;
1967         else if (!strcmp(opt, "full"))
1968             show_advanced = show_avoptions = 1;
1969         else
1970             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1971     }
1972
1973     show_usage();
1974
1975     printf("Getting help:\n"
1976            "    -h      -- print basic options\n"
1977            "    -h long -- print more options\n"
1978            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1979            "    See man %s for detailed description of the options.\n"
1980            "\n", program_name);
1981
1982     show_help_options(options, "Print help / information / capabilities:",
1983                       OPT_EXIT, 0, 0);
1984
1985     show_help_options(options, "Global options (affect whole program "
1986                       "instead of just one file:",
1987                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1988     if (show_advanced)
1989         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1990                           per_file | OPT_EXIT, 0);
1991
1992     show_help_options(options, "Per-file main options:", 0,
1993                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1994                       OPT_EXIT, per_file);
1995     if (show_advanced)
1996         show_help_options(options, "Advanced per-file options:",
1997                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1998
1999     show_help_options(options, "Video options:",
2000                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
2001     if (show_advanced)
2002         show_help_options(options, "Advanced Video options:",
2003                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
2004
2005     show_help_options(options, "Audio options:",
2006                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
2007     if (show_advanced)
2008         show_help_options(options, "Advanced Audio options:",
2009                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
2010     show_help_options(options, "Subtitle options:",
2011                       OPT_SUBTITLE, 0, 0);
2012     printf("\n");
2013
2014     if (show_avoptions) {
2015         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
2016         show_help_children(avcodec_get_class(), flags);
2017         show_help_children(avformat_get_class(), flags);
2018         show_help_children(sws_get_class(), flags);
2019         show_help_children(avfilter_get_class(), AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_AUDIO_PARAM);
2020     }
2021 }
2022
2023 void show_usage(void)
2024 {
2025     printf("Hyper fast Audio and Video encoder\n");
2026     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
2027     printf("\n");
2028 }
2029
2030 enum OptGroup {
2031     GROUP_OUTFILE,
2032     GROUP_INFILE,
2033 };
2034
2035 static const OptionGroupDef groups[] = {
2036     [GROUP_OUTFILE] = { "output file",  NULL, OPT_OUTPUT },
2037     [GROUP_INFILE]  = { "input file",   "i",  OPT_INPUT },
2038 };
2039
2040 static int open_files(OptionGroupList *l, const char *inout,
2041                       int (*open_file)(OptionsContext*, const char*))
2042 {
2043     int i, ret;
2044
2045     for (i = 0; i < l->nb_groups; i++) {
2046         OptionGroup *g = &l->groups[i];
2047         OptionsContext o;
2048
2049         init_options(&o);
2050         o.g = g;
2051
2052         ret = parse_optgroup(&o, g);
2053         if (ret < 0) {
2054             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
2055                    "%s.\n", inout, g->arg);
2056             return ret;
2057         }
2058
2059         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
2060         ret = open_file(&o, g->arg);
2061         uninit_options(&o);
2062         if (ret < 0) {
2063             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
2064                    inout, g->arg);
2065             return ret;
2066         }
2067         av_log(NULL, AV_LOG_DEBUG, "Successfully opened the file.\n");
2068     }
2069
2070     return 0;
2071 }
2072
2073 int avconv_parse_options(int argc, char **argv)
2074 {
2075     OptionParseContext octx;
2076     uint8_t error[128];
2077     int ret;
2078
2079     memset(&octx, 0, sizeof(octx));
2080
2081     /* split the commandline into an internal representation */
2082     ret = split_commandline(&octx, argc, argv, options, groups,
2083                             FF_ARRAY_ELEMS(groups));
2084     if (ret < 0) {
2085         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
2086         goto fail;
2087     }
2088
2089     /* apply global options */
2090     ret = parse_optgroup(NULL, &octx.global_opts);
2091     if (ret < 0) {
2092         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
2093         goto fail;
2094     }
2095
2096     /* open input files */
2097     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
2098     if (ret < 0) {
2099         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
2100         goto fail;
2101     }
2102
2103     /* open output files */
2104     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
2105     if (ret < 0) {
2106         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
2107         goto fail;
2108     }
2109
2110 fail:
2111     uninit_parse_context(&octx);
2112     if (ret < 0) {
2113         av_strerror(ret, error, sizeof(error));
2114         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
2115     }
2116     return ret;
2117 }
2118
2119 #define OFFSET(x) offsetof(OptionsContext, x)
2120 const OptionDef options[] = {
2121     /* main options */
2122 #include "cmdutils_common_opts.h"
2123     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET |
2124                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(format) },
2125         "force format", "fmt" },
2126     { "y",              OPT_BOOL,                                    {              &file_overwrite },
2127         "overwrite output files" },
2128     { "n",              OPT_BOOL,                                    {              &file_skip },
2129         "never overwrite output files" },
2130     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC |
2131                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2132         "codec name", "codec" },
2133     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC |
2134                         OPT_INPUT | OPT_OUTPUT,                      { .off       = OFFSET(codec_names) },
2135         "codec name", "codec" },
2136     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC |
2137                         OPT_OUTPUT,                                  { .off       = OFFSET(presets) },
2138         "preset name", "preset" },
2139     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2140                         OPT_OUTPUT,                                  { .func_arg = opt_map },
2141         "set input stream mapping",
2142         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
2143     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC |
2144                         OPT_OUTPUT,                                  { .off       = OFFSET(metadata_map) },
2145         "set metadata information of outfile from infile",
2146         "outfile[,metadata]:infile[,metadata]" },
2147     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET |
2148                         OPT_OUTPUT,                                  { .off = OFFSET(chapters_input_file) },
2149         "set chapters mapping", "input_file_index" },
2150     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET |
2151                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(recording_time) },
2152         "record or transcode \"duration\" seconds of audio/video",
2153         "duration" },
2154     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(limit_filesize) },
2155         "set the limit file size in bytes", "limit_size" },
2156     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET |
2157                         OPT_INPUT | OPT_OUTPUT,                      { .off = OFFSET(start_time) },
2158         "set the start time offset", "time_off" },
2159     { "accurate_seek",  OPT_BOOL | OPT_OFFSET | OPT_EXPERT |
2160                         OPT_INPUT,                                   { .off = OFFSET(accurate_seek) },
2161         "enable/disable accurate seeking with -ss" },
2162     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET |
2163                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(input_ts_offset) },
2164         "set the input ts offset", "time_off" },
2165     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC |
2166                         OPT_EXPERT | OPT_INPUT,                      { .off = OFFSET(ts_scale) },
2167         "set the input ts scale", "scale" },
2168     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(metadata) },
2169         "add metadata", "string=string" },
2170     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2171                         OPT_OUTPUT,                                  { .func_arg = opt_data_frames },
2172         "set the number of data frames to record", "number" },
2173     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
2174         "add timings for benchmarking" },
2175     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
2176         "set max runtime in seconds", "limit" },
2177     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
2178         "dump each input packet" },
2179     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
2180         "when dumping packets, also dump the payload" },
2181     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2182                         OPT_INPUT,                                   { .off = OFFSET(rate_emu) },
2183         "read input at native frame rate", "" },
2184     { "target",         HAS_ARG | OPT_PERFILE | OPT_OUTPUT,          { .func_arg = opt_target },
2185         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
2186         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2187     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2188         "video sync method", "" },
2189     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2190         "audio sync method", "" },
2191     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2192         "audio drift threshold", "threshold" },
2193     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2194         "copy timestamps" },
2195     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2196         "copy input stream time base when stream copying" },
2197     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET |
2198                         OPT_OUTPUT,                                  { .off = OFFSET(shortest) },
2199         "finish encoding within shortest input" },
2200     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2201         "timestamp discontinuity delta threshold", "threshold" },
2202     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2203         "exit on error", "error" },
2204     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC |
2205                         OPT_OUTPUT,                                  { .off = OFFSET(copy_initial_nonkeyframes) },
2206         "copy initial non-keyframes" },
2207     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(max_frames) },
2208         "set the number of frames to record", "number" },
2209     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC |
2210                         OPT_EXPERT | OPT_OUTPUT,                     { .off = OFFSET(codec_tags) },
2211         "force codec tag/fourcc", "fourcc/tag" },
2212     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2213                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2214         "use fixed quality scale (VBR)", "q" },
2215     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE |
2216                         OPT_SPEC | OPT_OUTPUT,                       { .off = OFFSET(qscale) },
2217         "use fixed quality scale (VBR)", "q" },
2218     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filters) },
2219         "set stream filterchain", "filter_list" },
2220     { "filter_script",  HAS_ARG | OPT_STRING | OPT_SPEC | OPT_OUTPUT, { .off = OFFSET(filter_scripts) },
2221         "read stream filtergraph description from a file", "filename" },
2222     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2223         "create a complex filtergraph", "graph_description" },
2224     { "filter_complex_script", HAS_ARG | OPT_EXPERT,                 { .func_arg = opt_filter_complex_script },
2225         "read complex filtergraph description from a file", "filename" },
2226     { "stats",          OPT_BOOL,                                    { &print_stats },
2227         "print progress report during encoding", },
2228     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT |
2229                         OPT_OUTPUT,                                  { .func_arg = opt_attach },
2230         "add an attachment to the output file", "filename" },
2231     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |
2232                          OPT_EXPERT | OPT_INPUT,                     { .off = OFFSET(dump_attachment) },
2233         "extract an attachment into a file", "filename" },
2234     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2235         "set CPU flags mask", "mask" },
2236
2237     /* video options */
2238     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_frames },
2239         "set the number of video frames to record", "number" },
2240     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2241                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_rates) },
2242         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2243     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2244                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_sizes) },
2245         "set frame size (WxH or abbreviation)", "size" },
2246     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC |
2247                       OPT_OUTPUT,                                                { .off = OFFSET(frame_aspect_ratios) },
2248         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2249     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2250                       OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(frame_pix_fmts) },
2251         "set pixel format", "format" },
2252     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET | OPT_OUTPUT,           { .off = OFFSET(video_disable) },
2253         "disable video" },
2254     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2255         "discard threshold", "n" },
2256     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2257                       OPT_OUTPUT,                                                { .off = OFFSET(rc_overrides) },
2258         "rate control override for specific intervals", "override" },
2259     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_INPUT |
2260                       OPT_OUTPUT,                                                { .func_arg = opt_video_codec },
2261         "force video codec ('copy' to copy stream)", "codec" },
2262     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT | OPT_OUTPUT,     { .off = OFFSET(pass) },
2263         "select the pass number (1 or 2)", "n" },
2264     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC |
2265                       OPT_OUTPUT,                                                { .off = OFFSET(passlogfiles) },
2266         "select two pass log file name prefix", "prefix" },
2267     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2268         "dump video coding statistics to file" },
2269     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2270         "dump video coding statistics to file", "file" },
2271     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_video_filters },
2272         "video filters", "filter list" },
2273     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2274                       OPT_OUTPUT,                                                { .off = OFFSET(intra_matrices) },
2275         "specify intra matrix coeffs", "matrix" },
2276     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC |
2277                       OPT_OUTPUT,                                                { .off = OFFSET(inter_matrices) },
2278         "specify inter matrix coeffs", "matrix" },
2279     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC |
2280                       OPT_OUTPUT,                                                { .off = OFFSET(top_field_first) },
2281         "top=1/bottom=0/auto=-1 field first", "" },
2282     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2283         "intra_dc_precision", "precision" },
2284     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE |
2285                       OPT_OUTPUT,                                                { .func_arg = opt_video_tag },
2286         "force video tag/fourcc", "fourcc/tag" },
2287     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2288         "show QP histogram" },
2289     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC |
2290                       OPT_OUTPUT,                                                { .off = OFFSET(force_fps) },
2291         "force the selected framerate, disable the best supported framerate selection" },
2292     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE |
2293                       OPT_OUTPUT,                                                { .func_arg = opt_streamid },
2294         "set the value of an outfile streamid", "streamIndex:value" },
2295     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT |
2296                           OPT_SPEC | OPT_OUTPUT,                                 { .off = OFFSET(forced_key_frames) },
2297         "force key frames at specified timestamps", "timestamps" },
2298
2299     /* audio options */
2300     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_frames },
2301         "set the number of audio frames to record", "number" },
2302     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_qscale },
2303         "set audio quality (codec-specific)", "quality", },
2304     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2305                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_sample_rate) },
2306         "set audio sampling rate (in Hz)", "rate" },
2307     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC |
2308                         OPT_INPUT | OPT_OUTPUT,                                    { .off = OFFSET(audio_channels) },
2309         "set number of audio channels", "channels" },
2310     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT,            { .off = OFFSET(audio_disable) },
2311         "disable audio" },
2312     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE |
2313                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_audio_codec },
2314         "force audio codec ('copy' to copy stream)", "codec" },
2315     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2316                         OPT_OUTPUT,                                                { .func_arg = opt_audio_tag },
2317         "force audio tag/fourcc", "fourcc/tag" },
2318     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2319         "change audio volume (256=normal)" , "volume" },
2320     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC |
2321                         OPT_STRING | OPT_INPUT | OPT_OUTPUT,                       { .off = OFFSET(sample_fmts) },
2322         "set sample format", "format" },
2323     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE |
2324                         OPT_INPUT | OPT_OUTPUT,                                    { .func_arg = opt_channel_layout },
2325         "set channel layout", "layout" },
2326     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE | OPT_OUTPUT,           { .func_arg = opt_audio_filters },
2327         "audio filters", "filter list" },
2328
2329     /* subtitle options */
2330     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(subtitle_disable) },
2331         "disable subtitle" },
2332     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_subtitle_codec },
2333         "force subtitle codec ('copy' to copy stream)", "codec" },
2334     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_subtitle_tag }
2335         , "force subtitle tag/fourcc", "fourcc/tag" },
2336
2337     /* grab options */
2338     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2339
2340     /* muxer options */
2341     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_max_delay) },
2342         "set the maximum demux-decode delay", "seconds" },
2343     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET | OPT_OUTPUT, { .off = OFFSET(mux_preload) },
2344         "set the initial demux-decode delay", "seconds" },
2345
2346     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT | OPT_OUTPUT, { .off = OFFSET(bitstream_filters) },
2347         "A comma-separated list of bitstream filters", "bitstream_filters" },
2348
2349     /* data codec support */
2350     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT | OPT_INPUT | OPT_OUTPUT, { .func_arg = opt_data_codec },
2351         "force data codec ('copy' to copy stream)", "codec" },
2352
2353     { NULL, },
2354 };