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