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