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