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