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/avassert.h"
  34 #include "libavutil/avstring.h"
  35 #include "libavutil/avutil.h"
  36 #include "libavutil/channel_layout.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 static void uninit_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
 112 static void init_options(OptionsContext *o)
 113 {
 114     memset(o, 0, sizeof(*o));
 115
 116     o->mux_max_delay  = 0.7;
 117     o->recording_time = INT64_MAX;
 118     o->limit_filesize = UINT64_MAX;
 119     o->chapters_input_file = INT_MAX;
 120 }
 121
 122 static double parse_frame_aspect_ratio(const char *arg)
 123 {
 124     int x = 0, y = 0;
 125     double ar = 0;
 126     const char *p;
 127     char *end;
 128
 129     p = strchr(arg, ':');
 130     if (p) {
 131         x = strtol(arg, &end, 10);
 132         if (end == p)
 133             y = strtol(end + 1, &end, 10);
 134         if (x > 0 && y > 0)
 135             ar = (double)x / (double)y;
 136     } else
 137         ar = strtod(arg, NULL);
 138
 139     if (!ar) {
 140         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
 141         exit(1);
 142     }
 143     return ar;
 144 }
 145
 146 static int opt_audio_codec(void *optctx, const char *opt, const char *arg)
 147 {
 148     OptionsContext *o = optctx;
 149     return parse_option(o, "codec:a", arg, options);
 150 }
 151
 152 static int opt_video_codec(void *optctx, const char *opt, const char *arg)
 153 {
 154     OptionsContext *o = optctx;
 155     return parse_option(o, "codec:v", arg, options);
 156 }
 157
 158 static int opt_subtitle_codec(void *optctx, const char *opt, const char *arg)
 159 {
 160     OptionsContext *o = optctx;
 161     return parse_option(o, "codec:s", arg, options);
 162 }
 163
 164 static int opt_data_codec(void *optctx, const char *opt, const char *arg)
 165 {
 166     OptionsContext *o = optctx;
 167     return parse_option(o, "codec:d", arg, options);
 168 }
 169
 170 static int opt_map(void *optctx, const char *opt, const char *arg)
 171 {
 172     OptionsContext *o = optctx;
 173     StreamMap *m = NULL;
 174     int i, negative = 0, file_idx;
 175     int sync_file_idx = -1, sync_stream_idx;
 176     char *p, *sync;
 177     char *map;
 178
 179     if (*arg == '-') {
 180         negative = 1;
 181         arg++;
 182     }
 183     map = av_strdup(arg);
 184
 185     /* parse sync stream first, just pick first matching stream */
 186     if (sync = strchr(map, ',')) {
 187         *sync = 0;
 188         sync_file_idx = strtol(sync + 1, &sync, 0);
 189         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
 190             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
 191             exit(1);
 192         }
 193         if (*sync)
 194             sync++;
 195         for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
 196             if (check_stream_specifier(input_files[sync_file_idx]->ctx,
 197                                        input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
 198                 sync_stream_idx = i;
 199                 break;
 200             }
 201         if (i == input_files[sync_file_idx]->nb_streams) {
 202             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
 203                                        "match any streams.\n", arg);
 204             exit(1);
 205         }
 206     }
 207
 208
 209     if (map[0] == '[') {
 210         /* this mapping refers to lavfi output */
 211         const char *c = map + 1;
 212         GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 213         m = &o->stream_maps[o->nb_stream_maps - 1];
 214         m->linklabel = av_get_token(&c, "]");
 215         if (!m->linklabel) {
 216             av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
 217             exit(1);
 218         }
 219     } else {
 220         file_idx = strtol(map, &p, 0);
 221         if (file_idx >= nb_input_files || file_idx < 0) {
 222             av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
 223             exit(1);
 224         }
 225         if (negative)
 226             /* disable some already defined maps */
 227             for (i = 0; i < o->nb_stream_maps; i++) {
 228                 m = &o->stream_maps[i];
 229                 if (file_idx == m->file_index &&
 230                     check_stream_specifier(input_files[m->file_index]->ctx,
 231                                            input_files[m->file_index]->ctx->streams[m->stream_index],
 232                                            *p == ':' ? p + 1 : p) > 0)
 233                     m->disabled = 1;
 234             }
 235         else
 236             for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
 237                 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
 238                             *p == ':' ? p + 1 : p) <= 0)
 239                     continue;
 240                 GROW_ARRAY(o->stream_maps, o->nb_stream_maps);
 241                 m = &o->stream_maps[o->nb_stream_maps - 1];
 242
 243                 m->file_index   = file_idx;
 244                 m->stream_index = i;
 245
 246                 if (sync_file_idx >= 0) {
 247                     m->sync_file_index   = sync_file_idx;
 248                     m->sync_stream_index = sync_stream_idx;
 249                 } else {
 250                     m->sync_file_index   = file_idx;
 251                     m->sync_stream_index = i;
 252                 }
 253             }
 254     }
 255
 256     if (!m) {
 257         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
 258         exit(1);
 259     }
 260
 261     av_freep(&map);
 262     return 0;
 263 }
 264
 265 static int opt_attach(void *optctx, const char *opt, const char *arg)
 266 {
 267     OptionsContext *o = optctx;
 268     GROW_ARRAY(o->attachments, o->nb_attachments);
 269     o->attachments[o->nb_attachments - 1] = arg;
 270     return 0;
 271 }
 272
 273 /**
 274  * Parse a metadata specifier passed as 'arg' parameter.
 275  * @param arg  metadata string to parse
 276  * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
 277  * @param index for type c/p, chapter/program index is written here
 278  * @param stream_spec for type s, the stream specifier is written here
 279  */
 280 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
 281 {
 282     if (*arg) {
 283         *type = *arg;
 284         switch (*arg) {
 285         case 'g':
 286             break;
 287         case 's':
 288             if (*(++arg) && *arg != ':') {
 289                 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
 290                 exit(1);
 291             }
 292             *stream_spec = *arg == ':' ? arg + 1 : "";
 293             break;
 294         case 'c':
 295         case 'p':
 296             if (*(++arg) == ':')
 297                 *index = strtol(++arg, NULL, 0);
 298             break;
 299         default:
 300             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
 301             exit(1);
 302         }
 303     } else
 304         *type = 'g';
 305 }
 306
 307 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
 308 {
 309     AVDictionary **meta_in = NULL;
 310     AVDictionary **meta_out;
 311     int i, ret = 0;
 312     char type_in, type_out;
 313     const char *istream_spec = NULL, *ostream_spec = NULL;
 314     int idx_in = 0, idx_out = 0;
 315
 316     parse_meta_type(inspec,  &type_in,  &idx_in,  &istream_spec);
 317     parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
 318
 319     if (type_in == 'g' || type_out == 'g')
 320         o->metadata_global_manual = 1;
 321     if (type_in == 's' || type_out == 's')
 322         o->metadata_streams_manual = 1;
 323     if (type_in == 'c' || type_out == 'c')
 324         o->metadata_chapters_manual = 1;
 325
 326     /* ic is NULL when just disabling automatic mappings */
 327     if (!ic)
 328         return 0;
 329
 330 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
 331     if ((index) < 0 || (index) >= (nb_elems)) {\
 332         av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
 333                 (desc), (index));\
 334         exit(1);\
 335     }
 336
 337 #define SET_DICT(type, meta, context, index)\
 338         switch (type) {\
 339         case 'g':\
 340             meta = &context->metadata;\
 341             break;\
 342         case 'c':\
 343             METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
 344             meta = &context->chapters[index]->metadata;\
 345             break;\
 346         case 'p':\
 347             METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
 348             meta = &context->programs[index]->metadata;\
 349             break;\
 350         case 's':\
 351             break; /* handled separately below */ \
 352         default: av_assert0(0);\
 353         }\
 354
 355     SET_DICT(type_in, meta_in, ic, idx_in);
 356     SET_DICT(type_out, meta_out, oc, idx_out);
 357
 358     /* for input streams choose first matching stream */
 359     if (type_in == 's') {
 360         for (i = 0; i < ic->nb_streams; i++) {
 361             if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
 362                 meta_in = &ic->streams[i]->metadata;
 363                 break;
 364             } else if (ret < 0)
 365                 exit(1);
 366         }
 367         if (!meta_in) {
 368             av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match  any streams.\n", istream_spec);
 369             exit(1);
 370         }
 371     }
 372
 373     if (type_out == 's') {
 374         for (i = 0; i < oc->nb_streams; i++) {
 375             if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
 376                 meta_out = &oc->streams[i]->metadata;
 377                 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 378             } else if (ret < 0)
 379                 exit(1);
 380         }
 381     } else
 382         av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
 383
 384     return 0;
 385 }
 386
 387 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
 388 {
 389     const AVCodecDescriptor *desc;
 390     const char *codec_string = encoder ? "encoder" : "decoder";
 391     AVCodec *codec;
 392
 393     codec = encoder ?
 394         avcodec_find_encoder_by_name(name) :
 395         avcodec_find_decoder_by_name(name);
 396
 397     if (!codec && (desc = avcodec_descriptor_get_by_name(name))) {
 398         codec = encoder ? avcodec_find_encoder(desc->id) :
 399                           avcodec_find_decoder(desc->id);
 400         if (codec)
 401             av_log(NULL, AV_LOG_VERBOSE, "Matched %s '%s' for codec '%s'.\n",
 402                    codec_string, codec->name, desc->name);
 403     }
 404
 405     if (!codec) {
 406         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
 407         exit(1);
 408     }
 409     if (codec->type != type) {
 410         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
 411         exit(1);
 412     }
 413     return codec;
 414 }
 415
 416 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
 417 {
 418     char *codec_name = NULL;
 419
 420     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
 421     if (codec_name) {
 422         AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
 423         st->codec->codec_id = codec->id;
 424         return codec;
 425     } else
 426         return avcodec_find_decoder(st->codec->codec_id);
 427 }
 428
 429 /* Add all the streams from the given input file to the global
 430  * list of input streams. */
 431 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
 432 {
 433     int i;
 434
 435     for (i = 0; i < ic->nb_streams; i++) {
 436         AVStream *st = ic->streams[i];
 437         AVCodecContext *dec = st->codec;
 438         InputStream *ist = av_mallocz(sizeof(*ist));
 439         char *framerate = NULL;
 440
 441         if (!ist)
 442             exit(1);
 443
 444         GROW_ARRAY(input_streams, nb_input_streams);
 445         input_streams[nb_input_streams - 1] = ist;
 446
 447         ist->st = st;
 448         ist->file_index = nb_input_files;
 449         ist->discard = 1;
 450         st->discard  = AVDISCARD_ALL;
 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         ist->opts = filter_codec_opts(o->g->codec_opts, ist->st->codec->codec_id, ic, st, ist->dec);
 457
 458         switch (dec->codec_type) {
 459         case AVMEDIA_TYPE_VIDEO:
 460             ist->resample_height  = dec->height;
 461             ist->resample_width   = dec->width;
 462             ist->resample_pix_fmt = dec->pix_fmt;
 463
 464             MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
 465             if (framerate && av_parse_video_rate(&ist->framerate,
 466                                                  framerate) < 0) {
 467                 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
 468                        framerate);
 469                 exit(1);
 470             }
 471
 472             break;
 473         case AVMEDIA_TYPE_AUDIO:
 474             guess_input_channel_layout(ist);
 475
 476             ist->resample_sample_fmt     = dec->sample_fmt;
 477             ist->resample_sample_rate    = dec->sample_rate;
 478             ist->resample_channels       = dec->channels;
 479             ist->resample_channel_layout = dec->channel_layout;
 480
 481             break;
 482         case AVMEDIA_TYPE_DATA:
 483         case AVMEDIA_TYPE_SUBTITLE:
 484         case AVMEDIA_TYPE_ATTACHMENT:
 485         case AVMEDIA_TYPE_UNKNOWN:
 486             break;
 487         default:
 488             abort();
 489         }
 490     }
 491 }
 492
 493 static void assert_file_overwrite(const char *filename)
 494 {
 495     if (!file_overwrite &&
 496         (strchr(filename, ':') == NULL || filename[1] == ':' ||
 497          av_strstart(filename, "file:", NULL))) {
 498         if (avio_check(filename, 0) == 0) {
 499             if (!using_stdin) {
 500                 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
 501                 fflush(stderr);
 502                 if (!read_yesno()) {
 503                     fprintf(stderr, "Not overwriting - exiting\n");
 504                     exit(1);
 505                 }
 506             }
 507             else {
 508                 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
 509                 exit(1);
 510             }
 511         }
 512     }
 513 }
 514
 515 static void dump_attachment(AVStream *st, const char *filename)
 516 {
 517     int ret;
 518     AVIOContext *out = NULL;
 519     AVDictionaryEntry *e;
 520
 521     if (!st->codec->extradata_size) {
 522         av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
 523                nb_input_files - 1, st->index);
 524         return;
 525     }
 526     if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
 527         filename = e->value;
 528     if (!*filename) {
 529         av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
 530                "in stream #%d:%d.\n", nb_input_files - 1, st->index);
 531         exit(1);
 532     }
 533
 534     assert_file_overwrite(filename);
 535
 536     if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
 537         av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
 538                filename);
 539         exit(1);
 540     }
 541
 542     avio_write(out, st->codec->extradata, st->codec->extradata_size);
 543     avio_flush(out);
 544     avio_close(out);
 545 }
 546
 547 static int open_input_file(OptionsContext *o, const char *filename)
 548 {
 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(&o->g->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(&o->g->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(&o->g->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(&o->g->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(&o->g->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, &o->g->format_opts);
 613     if (err < 0) {
 614         print_error(filename, err);
 615         exit(1);
 616     }
 617     assert_avoptions(o->g->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, o->g->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     GROW_ARRAY(input_files, nb_input_files);
 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     return 0;
 682 }
 683
 684 static uint8_t *get_line(AVIOContext *s)
 685 {
 686     AVIOContext *line;
 687     uint8_t *buf;
 688     char c;
 689
 690     if (avio_open_dyn_buf(&line) < 0) {
 691         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
 692         exit(1);
 693     }
 694
 695     while ((c = avio_r8(s)) && c != '\n')
 696         avio_w8(line, c);
 697     avio_w8(line, 0);
 698     avio_close_dyn_buf(line, &buf);
 699
 700     return buf;
 701 }
 702
 703 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
 704 {
 705     int i, ret = 1;
 706     char filename[1000];
 707     const char *base[3] = { getenv("AVCONV_DATADIR"),
 708                             getenv("HOME"),
 709                             AVCONV_DATADIR,
 710                             };
 711
 712     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
 713         if (!base[i])
 714             continue;
 715         if (codec_name) {
 716             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
 717                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
 718             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 719         }
 720         if (ret) {
 721             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
 722                      i != 1 ? "" : "/.avconv", preset_name);
 723             ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
 724         }
 725     }
 726     return ret;
 727 }
 728
 729 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
 730 {
 731     char *codec_name = NULL;
 732
 733     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
 734     if (!codec_name) {
 735         ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
 736                                                   NULL, ost->st->codec->codec_type);
 737         ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
 738     } else if (!strcmp(codec_name, "copy"))
 739         ost->stream_copy = 1;
 740     else {
 741         ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
 742         ost->st->codec->codec_id = ost->enc->id;
 743     }
 744 }
 745
 746 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
 747 {
 748     OutputStream *ost;
 749     AVStream *st = avformat_new_stream(oc, NULL);
 750     int idx      = oc->nb_streams - 1, ret = 0;
 751     char *bsf = NULL, *next, *codec_tag = NULL;
 752     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
 753     double qscale = -1;
 754
 755     if (!st) {
 756         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
 757         exit(1);
 758     }
 759
 760     if (oc->nb_streams - 1 < o->nb_streamid_map)
 761         st->id = o->streamid_map[oc->nb_streams - 1];
 762
 763     GROW_ARRAY(output_streams, nb_output_streams);
 764     if (!(ost = av_mallocz(sizeof(*ost))))
 765         exit(1);
 766     output_streams[nb_output_streams - 1] = ost;
 767
 768     ost->file_index = nb_output_files;
 769     ost->index      = idx;
 770     ost->st         = st;
 771     st->codec->codec_type = type;
 772     choose_encoder(o, oc, ost);
 773     if (ost->enc) {
 774         AVIOContext *s = NULL;
 775         char *buf = NULL, *arg = NULL, *preset = NULL;
 776
 777         ost->opts  = filter_codec_opts(o->g->codec_opts, ost->enc->id, oc, st, ost->enc);
 778
 779         MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
 780         if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
 781             do  {
 782                 buf = get_line(s);
 783                 if (!buf[0] || buf[0] == '#') {
 784                     av_free(buf);
 785                     continue;
 786                 }
 787                 if (!(arg = strchr(buf, '='))) {
 788                     av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
 789                     exit(1);
 790                 }
 791                 *arg++ = 0;
 792                 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
 793                 av_free(buf);
 794             } while (!s->eof_reached);
 795             avio_close(s);
 796         }
 797         if (ret) {
 798             av_log(NULL, AV_LOG_FATAL,
 799                    "Preset %s specified for stream %d:%d, but could not be opened.\n",
 800                    preset, ost->file_index, ost->index);
 801             exit(1);
 802         }
 803     } else {
 804         ost->opts = filter_codec_opts(o->g->codec_opts, AV_CODEC_ID_NONE, oc, st, NULL);
 805     }
 806
 807     avcodec_get_context_defaults3(st->codec, ost->enc);
 808     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
 809
 810     ost->max_frames = INT64_MAX;
 811     MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
 812
 813     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
 814     while (bsf) {
 815         if (next = strchr(bsf, ','))
 816             *next++ = 0;
 817         if (!(bsfc = av_bitstream_filter_init(bsf))) {
 818             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
 819             exit(1);
 820         }
 821         if (bsfc_prev)
 822             bsfc_prev->next = bsfc;
 823         else
 824             ost->bitstream_filters = bsfc;
 825
 826         bsfc_prev = bsfc;
 827         bsf       = next;
 828     }
 829
 830     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
 831     if (codec_tag) {
 832         uint32_t tag = strtol(codec_tag, &next, 0);
 833         if (*next)
 834             tag = AV_RL32(codec_tag);
 835         st->codec->codec_tag = tag;
 836     }
 837
 838     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
 839     if (qscale >= 0) {
 840         st->codec->flags |= CODEC_FLAG_QSCALE;
 841         st->codec->global_quality = FF_QP2LAMBDA * qscale;
 842     }
 843
 844     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 845         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
 846
 847     av_opt_get_int(o->g->sws_opts, "sws_flags", 0, &ost->sws_flags);
 848
 849     av_dict_copy(&ost->resample_opts, o->g->resample_opts, 0);
 850
 851     ost->pix_fmts[0] = ost->pix_fmts[1] = AV_PIX_FMT_NONE;
 852
 853     return ost;
 854 }
 855
 856 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
 857 {
 858     int i;
 859     const char *p = str;
 860     for (i = 0;; i++) {
 861         dest[i] = atoi(p);
 862         if (i == 63)
 863             break;
 864         p = strchr(p, ',');
 865         if (!p) {
 866             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
 867             exit(1);
 868         }
 869         p++;
 870     }
 871 }
 872
 873 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
 874 {
 875     AVStream *st;
 876     OutputStream *ost;
 877     AVCodecContext *video_enc;
 878
 879     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
 880     st  = ost->st;
 881     video_enc = st->codec;
 882
 883     if (!ost->stream_copy) {
 884         const char *p = NULL;
 885         char *frame_rate = NULL, *frame_size = NULL;
 886         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
 887         char *intra_matrix = NULL, *inter_matrix = NULL;
 888         const char *filters = "null";
 889         int do_pass = 0;
 890         int i;
 891
 892         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
 893         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
 894             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
 895             exit(1);
 896         }
 897
 898         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
 899         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
 900             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
 901             exit(1);
 902         }
 903
 904         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
 905         if (frame_aspect_ratio)
 906             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
 907
 908         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
 909         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == AV_PIX_FMT_NONE) {
 910             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
 911             exit(1);
 912         }
 913         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
 914
 915         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
 916         if (intra_matrix) {
 917             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
 918                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
 919                 exit(1);
 920             }
 921             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
 922         }
 923         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
 924         if (inter_matrix) {
 925             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
 926                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
 927                 exit(1);
 928             }
 929             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
 930         }
 931
 932         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
 933         for (i = 0; p; i++) {
 934             int start, end, q;
 935             int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
 936             if (e != 3) {
 937                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
 938                 exit(1);
 939             }
 940             video_enc->rc_override =
 941                 av_realloc(video_enc->rc_override,
 942                            sizeof(RcOverride) * (i + 1));
 943             video_enc->rc_override[i].start_frame = start;
 944             video_enc->rc_override[i].end_frame   = end;
 945             if (q > 0) {
 946                 video_enc->rc_override[i].qscale         = q;
 947                 video_enc->rc_override[i].quality_factor = 1.0;
 948             }
 949             else {
 950                 video_enc->rc_override[i].qscale         = 0;
 951                 video_enc->rc_override[i].quality_factor = -q/100.0;
 952             }
 953             p = strchr(p, '/');
 954             if (p) p++;
 955         }
 956         video_enc->rc_override_count = i;
 957         video_enc->intra_dc_precision = intra_dc_precision - 8;
 958
 959         /* two pass mode */
 960         MATCH_PER_STREAM_OPT(pass, i, do_pass, oc, st);
 961         if (do_pass) {
 962             if (do_pass == 1) {
 963                 video_enc->flags |= CODEC_FLAG_PASS1;
 964             } else {
 965                 video_enc->flags |= CODEC_FLAG_PASS2;
 966             }
 967         }
 968
 969         MATCH_PER_STREAM_OPT(passlogfiles, str, ost->logfile_prefix, oc, st);
 970         if (ost->logfile_prefix &&
 971             !(ost->logfile_prefix = av_strdup(ost->logfile_prefix)))
 972             exit(1);
 973
 974         MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
 975         if (ost->forced_keyframes)
 976             ost->forced_keyframes = av_strdup(ost->forced_keyframes);
 977
 978         MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
 979
 980         ost->top_field_first = -1;
 981         MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
 982
 983         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
 984         ost->avfilter = av_strdup(filters);
 985     } else {
 986         MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
 987     }
 988
 989     return ost;
 990 }
 991
 992 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
 993 {
 994     AVStream *st;
 995     OutputStream *ost;
 996     AVCodecContext *audio_enc;
 997
 998     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
 999     st  = ost->st;
1000
1001     audio_enc = st->codec;
1002     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
1003
1004     if (!ost->stream_copy) {
1005         char *sample_fmt = NULL;
1006         const char *filters = "anull";
1007
1008         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
1009
1010         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
1011         if (sample_fmt &&
1012             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
1013             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
1014             exit(1);
1015         }
1016
1017         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
1018
1019         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
1020         ost->avfilter = av_strdup(filters);
1021     }
1022
1023     return ost;
1024 }
1025
1026 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
1027 {
1028     OutputStream *ost;
1029
1030     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
1031     if (!ost->stream_copy) {
1032         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
1033         exit(1);
1034     }
1035
1036     return ost;
1037 }
1038
1039 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
1040 {
1041     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
1042     ost->stream_copy = 1;
1043     return ost;
1044 }
1045
1046 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
1047 {
1048     AVStream *st;
1049     OutputStream *ost;
1050     AVCodecContext *subtitle_enc;
1051
1052     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
1053     st  = ost->st;
1054     subtitle_enc = st->codec;
1055
1056     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
1057
1058     return ost;
1059 }
1060
1061 /* arg format is "output-stream-index:streamid-value". */
1062 static int opt_streamid(void *optctx, const char *opt, const char *arg)
1063 {
1064     OptionsContext *o = optctx;
1065     int idx;
1066     char *p;
1067     char idx_str[16];
1068
1069     av_strlcpy(idx_str, arg, sizeof(idx_str));
1070     p = strchr(idx_str, ':');
1071     if (!p) {
1072         av_log(NULL, AV_LOG_FATAL,
1073                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
1074                arg, opt);
1075         exit(1);
1076     }
1077     *p++ = '\0';
1078     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
1079     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
1080     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
1081     return 0;
1082 }
1083
1084 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
1085 {
1086     AVFormatContext *is = ifile->ctx;
1087     AVFormatContext *os = ofile->ctx;
1088     AVChapter **tmp;
1089     int i;
1090
1091     tmp = av_realloc(os->chapters, sizeof(*os->chapters) * (is->nb_chapters + os->nb_chapters));
1092     if (!tmp)
1093         return AVERROR(ENOMEM);
1094     os->chapters = tmp;
1095
1096     for (i = 0; i < is->nb_chapters; i++) {
1097         AVChapter *in_ch = is->chapters[i], *out_ch;
1098         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
1099                                        AV_TIME_BASE_Q, in_ch->time_base);
1100         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
1101                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1102
1103
1104         if (in_ch->end < ts_off)
1105             continue;
1106         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1107             break;
1108
1109         out_ch = av_mallocz(sizeof(AVChapter));
1110         if (!out_ch)
1111             return AVERROR(ENOMEM);
1112
1113         out_ch->id        = in_ch->id;
1114         out_ch->time_base = in_ch->time_base;
1115         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
1116         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
1117
1118         if (copy_metadata)
1119             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1120
1121         os->chapters[os->nb_chapters++] = out_ch;
1122     }
1123     return 0;
1124 }
1125
1126 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
1127                                AVFormatContext *oc)
1128 {
1129     OutputStream *ost;
1130
1131     switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
1132                                   ofilter->out_tmp->pad_idx)) {
1133     case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
1134     case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
1135     default:
1136         av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
1137                "currently.\n");
1138         exit(1);
1139     }
1140
1141     ost->source_index = -1;
1142     ost->filter       = ofilter;
1143
1144     ofilter->ost      = ost;
1145
1146     if (ost->stream_copy) {
1147         av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
1148                "which is fed from a complex filtergraph. Filtering and streamcopy "
1149                "cannot be used together.\n", ost->file_index, ost->index);
1150         exit(1);
1151     }
1152
1153     if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
1154         av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
1155         exit(1);
1156     }
1157     avfilter_inout_free(&ofilter->out_tmp);
1158 }
1159
1160 static int configure_complex_filters(void)
1161 {
1162     int i, ret = 0;
1163
1164     for (i = 0; i < nb_filtergraphs; i++)
1165         if (!filtergraphs[i]->graph &&
1166             (ret = configure_filtergraph(filtergraphs[i])) < 0)
1167             return ret;
1168     return 0;
1169 }
1170
1171 static int open_output_file(OptionsContext *o, const char *filename)
1172 {
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     GROW_ARRAY(output_files, nb_output_files);
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, o->g->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 >= nb_input_files) {
1416             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
1417             exit(1);
1418         }
1419         copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc,
1420                       in_file_index >= 0 ?
1421                       input_files[in_file_index]->ctx : NULL, 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     return 0;
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 #if FF_API_DEINTERLACE
1719 static int opt_deinterlace(void *optctx, const char *opt, const char *arg)
1720 {
1721     av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
1722     do_deinterlace = 1;
1723     return 0;
1724 }
1725 #endif
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     GROW_ARRAY(filtergraphs, nb_filtergraphs);
1783     if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
1784         return AVERROR(ENOMEM);
1785     filtergraphs[nb_filtergraphs - 1]->index       = nb_filtergraphs - 1;
1786     filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
1787     return 0;
1788 }
1789
1790 void show_help_default(const char *opt, const char *arg)
1791 {
1792     /* per-file options have at least one of those set */
1793     const int per_file = OPT_SPEC | OPT_OFFSET | OPT_PERFILE;
1794     int show_advanced = 0, show_avoptions = 0;
1795
1796     if (opt && *opt) {
1797         if (!strcmp(opt, "long"))
1798             show_advanced = 1;
1799         else if (!strcmp(opt, "full"))
1800             show_advanced = show_avoptions = 1;
1801         else
1802             av_log(NULL, AV_LOG_ERROR, "Unknown help option '%s'.\n", opt);
1803     }
1804
1805     show_usage();
1806
1807     printf("Getting help:\n"
1808            "    -h      -- print basic options\n"
1809            "    -h long -- print more options\n"
1810            "    -h full -- print all options (including all format and codec specific options, very long)\n"
1811            "    See man %s for detailed description of the options.\n"
1812            "\n", program_name);
1813
1814     show_help_options(options, "Print help / information / capabilities:",
1815                       OPT_EXIT, 0, 0);
1816
1817     show_help_options(options, "Global options (affect whole program "
1818                       "instead of just one file:",
1819                       0, per_file | OPT_EXIT | OPT_EXPERT, 0);
1820     if (show_advanced)
1821         show_help_options(options, "Advanced global options:", OPT_EXPERT,
1822                           per_file | OPT_EXIT, 0);
1823
1824     show_help_options(options, "Per-file main options:", 0,
1825                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE |
1826                       OPT_EXIT, per_file);
1827     if (show_advanced)
1828         show_help_options(options, "Advanced per-file options:",
1829                           OPT_EXPERT, OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE, per_file);
1830
1831     show_help_options(options, "Video options:",
1832                       OPT_VIDEO, OPT_EXPERT | OPT_AUDIO, 0);
1833     if (show_advanced)
1834         show_help_options(options, "Advanced Video options:",
1835                           OPT_EXPERT | OPT_VIDEO, OPT_AUDIO, 0);
1836
1837     show_help_options(options, "Audio options:",
1838                       OPT_AUDIO, OPT_EXPERT | OPT_VIDEO, 0);
1839     if (show_advanced)
1840         show_help_options(options, "Advanced Audio options:",
1841                           OPT_EXPERT | OPT_AUDIO, OPT_VIDEO, 0);
1842     show_help_options(options, "Subtitle options:",
1843                       OPT_SUBTITLE, 0, 0);
1844     printf("\n");
1845
1846     if (show_avoptions) {
1847         int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
1848         show_help_children(avcodec_get_class(), flags);
1849         show_help_children(avformat_get_class(), flags);
1850         show_help_children(sws_get_class(), flags);
1851     }
1852 }
1853
1854 void show_usage(void)
1855 {
1856     printf("Hyper fast Audio and Video encoder\n");
1857     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
1858     printf("\n");
1859 }
1860
1861 enum OptGroup {
1862     GROUP_OUTFILE,
1863     GROUP_INFILE,
1864 };
1865
1866 static const OptionGroupDef groups[] = {
1867     [GROUP_OUTFILE] = { "output file",  NULL },
1868     [GROUP_INFILE]  = { "input file",   "i"  },
1869 };
1870
1871 static int open_files(OptionGroupList *l, const char *inout,
1872                       int (*open_file)(OptionsContext*, const char*))
1873 {
1874     int i, ret;
1875
1876     for (i = 0; i < l->nb_groups; i++) {
1877         OptionGroup *g = &l->groups[i];
1878         OptionsContext o;
1879
1880         init_options(&o);
1881         o.g = g;
1882
1883         ret = parse_optgroup(&o, g);
1884         if (ret < 0) {
1885             av_log(NULL, AV_LOG_ERROR, "Error parsing options for %s file "
1886                    "%s.\n", inout, g->arg);
1887             return ret;
1888         }
1889
1890         av_log(NULL, AV_LOG_DEBUG, "Opening an %s file: %s.\n", inout, g->arg);
1891         ret = open_file(&o, g->arg);
1892         uninit_options(&o);
1893         if (ret < 0) {
1894             av_log(NULL, AV_LOG_ERROR, "Error opening %s file %s.\n",
1895                    inout, g->arg);
1896             return ret;
1897         }
1898         av_log(NULL, AV_LOG_DEBUG, "Successfully openened the file.\n");
1899     }
1900
1901     return 0;
1902 }
1903
1904 int avconv_parse_options(int argc, char **argv)
1905 {
1906     OptionParseContext octx;
1907     uint8_t error[128];
1908     int ret;
1909
1910     memset(&octx, 0, sizeof(octx));
1911
1912     /* split the commandline into an internal representation */
1913     ret = split_commandline(&octx, argc, argv, options, groups,
1914                             FF_ARRAY_ELEMS(groups));
1915     if (ret < 0) {
1916         av_log(NULL, AV_LOG_FATAL, "Error splitting the argument list: ");
1917         goto fail;
1918     }
1919
1920     /* apply global options */
1921     ret = parse_optgroup(NULL, &octx.global_opts);
1922     if (ret < 0) {
1923         av_log(NULL, AV_LOG_FATAL, "Error parsing global options: ");
1924         goto fail;
1925     }
1926
1927     /* open input files */
1928     ret = open_files(&octx.groups[GROUP_INFILE], "input", open_input_file);
1929     if (ret < 0) {
1930         av_log(NULL, AV_LOG_FATAL, "Error opening input files: ");
1931         goto fail;
1932     }
1933
1934     /* open output files */
1935     ret = open_files(&octx.groups[GROUP_OUTFILE], "output", open_output_file);
1936     if (ret < 0) {
1937         av_log(NULL, AV_LOG_FATAL, "Error opening output files: ");
1938         goto fail;
1939     }
1940
1941 fail:
1942     uninit_parse_context(&octx);
1943     if (ret < 0) {
1944         av_strerror(ret, error, sizeof(error));
1945         av_log(NULL, AV_LOG_FATAL, "%s\n", error);
1946     }
1947     return ret;
1948 }
1949
1950 #define OFFSET(x) offsetof(OptionsContext, x)
1951 const OptionDef options[] = {
1952     /* main options */
1953 #include "cmdutils_common_opts.h"
1954     { "f",              HAS_ARG | OPT_STRING | OPT_OFFSET,           { .off       = OFFSET(format) },
1955         "force format", "fmt" },
1956     { "y",              OPT_BOOL,                                    {              &file_overwrite },
1957         "overwrite output files" },
1958     { "c",              HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1959         "codec name", "codec" },
1960     { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(codec_names) },
1961         "codec name", "codec" },
1962     { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(presets) },
1963         "preset name", "preset" },
1964     { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { .func_arg = opt_map },
1965         "set input stream mapping",
1966         "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
1967     { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,             { .off       = OFFSET(metadata_map) },
1968         "set metadata information of outfile from infile",
1969         "outfile[,metadata]:infile[,metadata]" },
1970     { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(chapters_input_file) },
1971         "set chapters mapping", "input_file_index" },
1972     { "t",              HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(recording_time) },
1973         "record or transcode \"duration\" seconds of audio/video",
1974         "duration" },
1975     { "fs",             HAS_ARG | OPT_INT64 | OPT_OFFSET,            { .off = OFFSET(limit_filesize) },
1976         "set the limit file size in bytes", "limit_size" },
1977     { "ss",             HAS_ARG | OPT_TIME | OPT_OFFSET,             { .off = OFFSET(start_time) },
1978         "set the start time offset", "time_off" },
1979     { "itsoffset",      HAS_ARG | OPT_TIME | OPT_OFFSET | OPT_EXPERT,{ .off = OFFSET(input_ts_offset) },
1980         "set the input ts offset", "time_off" },
1981     { "itsscale",       HAS_ARG | OPT_DOUBLE | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(ts_scale) },
1982         "set the input ts scale", "scale" },
1983     { "metadata",       HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(metadata) },
1984         "add metadata", "string=string" },
1985     { "dframes",        HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_data_frames },
1986         "set the number of data frames to record", "number" },
1987     { "benchmark",      OPT_BOOL | OPT_EXPERT,                       { &do_benchmark },
1988         "add timings for benchmarking" },
1989     { "timelimit",      HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_timelimit },
1990         "set max runtime in seconds", "limit" },
1991     { "dump",           OPT_BOOL | OPT_EXPERT,                       { &do_pkt_dump },
1992         "dump each input packet" },
1993     { "hex",            OPT_BOOL | OPT_EXPERT,                       { &do_hex_dump },
1994         "when dumping packets, also dump the payload" },
1995     { "re",             OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(rate_emu) },
1996         "read input at native frame rate", "" },
1997     { "target",         HAS_ARG | OPT_PERFILE,                       { .func_arg = opt_target },
1998         "specify target file type (\"vcd\", \"svcd\", \"dvd\","
1999         " \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
2000     { "vsync",          HAS_ARG | OPT_EXPERT,                        { opt_vsync },
2001         "video sync method", "" },
2002     { "async",          HAS_ARG | OPT_INT | OPT_EXPERT,              { &audio_sync_method },
2003         "audio sync method", "" },
2004     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,          { &audio_drift_threshold },
2005         "audio drift threshold", "threshold" },
2006     { "copyts",         OPT_BOOL | OPT_EXPERT,                       { &copy_ts },
2007         "copy timestamps" },
2008     { "copytb",         OPT_BOOL | OPT_EXPERT,                       { &copy_tb },
2009         "copy input stream time base when stream copying" },
2010     { "shortest",       OPT_BOOL | OPT_EXPERT | OPT_OFFSET,          { .off = OFFSET(shortest) },
2011         "finish encoding within shortest input" },
2012     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT,       { &dts_delta_threshold },
2013         "timestamp discontinuity delta threshold", "threshold" },
2014     { "xerror",         OPT_BOOL | OPT_EXPERT,                       { &exit_on_error },
2015         "exit on error", "error" },
2016     { "copyinkf",       OPT_BOOL | OPT_EXPERT | OPT_SPEC,            { .off = OFFSET(copy_initial_nonkeyframes) },
2017         "copy initial non-keyframes" },
2018     { "frames",         OPT_INT64 | HAS_ARG | OPT_SPEC,              { .off = OFFSET(max_frames) },
2019         "set the number of frames to record", "number" },
2020     { "tag",            OPT_STRING | HAS_ARG | OPT_SPEC | OPT_EXPERT,{ .off = OFFSET(codec_tags) },
2021         "force codec tag/fourcc", "fourcc/tag" },
2022     { "q",              HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2023         "use fixed quality scale (VBR)", "q" },
2024     { "qscale",         HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC,{ .off = OFFSET(qscale) },
2025         "use fixed quality scale (VBR)", "q" },
2026     { "filter",         HAS_ARG | OPT_STRING | OPT_SPEC,             { .off = OFFSET(filters) },
2027         "set stream filterchain", "filter_list" },
2028     { "filter_complex", HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_filter_complex },
2029         "create a complex filtergraph", "graph_description" },
2030     { "stats",          OPT_BOOL,                                    { &print_stats },
2031         "print progress report during encoding", },
2032     { "attach",         HAS_ARG | OPT_PERFILE | OPT_EXPERT,          { .func_arg = opt_attach },
2033         "add an attachment to the output file", "filename" },
2034     { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC |OPT_EXPERT,{ .off = OFFSET(dump_attachment) },
2035         "extract an attachment into a file", "filename" },
2036     { "cpuflags",       HAS_ARG | OPT_EXPERT,                        { .func_arg = opt_cpuflags },
2037         "set CPU flags mask", "mask" },
2038
2039     /* video options */
2040     { "vframes",      OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_frames },
2041         "set the number of video frames to record", "number" },
2042     { "r",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_rates) },
2043         "set frame rate (Hz value, fraction or abbreviation)", "rate" },
2044     { "s",            OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_sizes) },
2045         "set frame size (WxH or abbreviation)", "size" },
2046     { "aspect",       OPT_VIDEO | HAS_ARG  | OPT_STRING | OPT_SPEC,              { .off = OFFSET(frame_aspect_ratios) },
2047         "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
2048     { "pix_fmt",      OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(frame_pix_fmts) },
2049         "set pixel format", "format" },
2050     { "vn",           OPT_VIDEO | OPT_BOOL  | OPT_OFFSET,                        { .off = OFFSET(video_disable) },
2051         "disable video" },
2052     { "vdt",          OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &video_discard },
2053         "discard threshold", "n" },
2054     { "rc_override",  OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(rc_overrides) },
2055         "rate control override for specific intervals", "override" },
2056     { "vcodec",       OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_codec },
2057         "force video codec ('copy' to copy stream)", "codec" },
2058     { "pass",         OPT_VIDEO | HAS_ARG | OPT_SPEC | OPT_INT,                  { .off = OFFSET(pass) },
2059         "select the pass number (1 or 2)", "n" },
2060     { "passlogfile",  OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_EXPERT | OPT_SPEC,  { .off = OFFSET(passlogfiles) },
2061         "select two pass log file name prefix", "prefix" },
2062 #if FF_API_DEINTERLACE
2063     { "deinterlace",  OPT_VIDEO | OPT_EXPERT ,                                   { .func_arg = opt_deinterlace },
2064         "this option is deprecated, use the yadif filter instead" },
2065 #endif
2066     { "vstats",       OPT_VIDEO | OPT_EXPERT ,                                   { &opt_vstats },
2067         "dump video coding statistics to file" },
2068     { "vstats_file",  OPT_VIDEO | HAS_ARG | OPT_EXPERT ,                         { opt_vstats_file },
2069         "dump video coding statistics to file", "file" },
2070     { "vf",           OPT_VIDEO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_video_filters },
2071         "video filters", "filter list" },
2072     { "intra_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(intra_matrices) },
2073         "specify intra matrix coeffs", "matrix" },
2074     { "inter_matrix", OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_STRING | OPT_SPEC, { .off = OFFSET(inter_matrices) },
2075         "specify inter matrix coeffs", "matrix" },
2076     { "top",          OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_INT| OPT_SPEC,     { .off = OFFSET(top_field_first) },
2077         "top=1/bottom=0/auto=-1 field first", "" },
2078     { "dc",           OPT_VIDEO | OPT_INT | HAS_ARG | OPT_EXPERT ,               { &intra_dc_precision },
2079         "intra_dc_precision", "precision" },
2080     { "vtag",         OPT_VIDEO | HAS_ARG | OPT_EXPERT  | OPT_PERFILE,           { .func_arg = opt_video_tag },
2081         "force video tag/fourcc", "fourcc/tag" },
2082     { "qphist",       OPT_VIDEO | OPT_BOOL | OPT_EXPERT ,                        { &qp_hist },
2083         "show QP histogram" },
2084     { "force_fps",    OPT_VIDEO | OPT_BOOL | OPT_EXPERT  | OPT_SPEC,             { .off = OFFSET(force_fps) },
2085         "force the selected framerate, disable the best supported framerate selection" },
2086     { "streamid",     OPT_VIDEO | HAS_ARG | OPT_EXPERT | OPT_PERFILE,            { .func_arg = opt_streamid },
2087         "set the value of an outfile streamid", "streamIndex:value" },
2088     { "force_key_frames", OPT_VIDEO | OPT_STRING | HAS_ARG | OPT_EXPERT  | OPT_SPEC,
2089         { .off = OFFSET(forced_key_frames) }, "force key frames at specified timestamps", "timestamps" },
2090
2091     /* audio options */
2092     { "aframes",        OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_frames },
2093         "set the number of audio frames to record", "number" },
2094     { "aq",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_qscale },
2095         "set audio quality (codec-specific)", "quality", },
2096     { "ar",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_sample_rate) },
2097         "set audio sampling rate (in Hz)", "rate" },
2098     { "ac",             OPT_AUDIO | HAS_ARG  | OPT_INT | OPT_SPEC,                 { .off = OFFSET(audio_channels) },
2099         "set number of audio channels", "channels" },
2100     { "an",             OPT_AUDIO | OPT_BOOL | OPT_OFFSET,                         { .off = OFFSET(audio_disable) },
2101         "disable audio" },
2102     { "acodec",         OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_codec },
2103         "force audio codec ('copy' to copy stream)", "codec" },
2104     { "atag",           OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_audio_tag },
2105         "force audio tag/fourcc", "fourcc/tag" },
2106     { "vol",            OPT_AUDIO | HAS_ARG  | OPT_INT,                            { &audio_volume },
2107         "change audio volume (256=normal)" , "volume" },
2108     { "sample_fmt",     OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_SPEC | OPT_STRING, { .off = OFFSET(sample_fmts) },
2109         "set sample format", "format" },
2110     { "channel_layout", OPT_AUDIO | HAS_ARG  | OPT_EXPERT | OPT_PERFILE,           { .func_arg = opt_channel_layout },
2111         "set channel layout", "layout" },
2112     { "af",             OPT_AUDIO | HAS_ARG  | OPT_PERFILE,                        { .func_arg = opt_audio_filters },
2113         "audio filters", "filter list" },
2114
2115     /* subtitle options */
2116     { "sn",     OPT_SUBTITLE | OPT_BOOL | OPT_OFFSET, { .off = OFFSET(subtitle_disable) },
2117         "disable subtitle" },
2118     { "scodec", OPT_SUBTITLE | HAS_ARG  | OPT_PERFILE, { .func_arg = opt_subtitle_codec },
2119         "force subtitle codec ('copy' to copy stream)", "codec" },
2120     { "stag",   OPT_SUBTITLE | HAS_ARG  | OPT_EXPERT  | OPT_PERFILE, { .func_arg = opt_subtitle_tag }
2121         , "force subtitle tag/fourcc", "fourcc/tag" },
2122
2123     /* grab options */
2124     { "isync", OPT_BOOL | OPT_EXPERT, { &input_sync }, "this option is deprecated and does nothing", "" },
2125
2126     /* muxer options */
2127     { "muxdelay",   OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_max_delay) },
2128         "set the maximum demux-decode delay", "seconds" },
2129     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, { .off = OFFSET(mux_preload) },
2130         "set the initial demux-decode delay", "seconds" },
2131
2132     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC | OPT_EXPERT, { .off = OFFSET(bitstream_filters) },
2133         "A comma-separated list of bitstream filters", "bitstream_filters" },
2134
2135     /* data codec support */
2136     { "dcodec", HAS_ARG | OPT_DATA | OPT_PERFILE | OPT_EXPERT, { .func_arg = opt_data_codec },
2137         "force data codec ('copy' to copy stream)", "codec" },
2138
2139     { NULL, },
2140 };