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