git.sesse.net Git - ffmpeg/blob - avconv.c

   1 /*
   2  * ffmpeg main
   3  * Copyright (c) 2000-2003 Fabrice Bellard
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "config.h"
  23 #include <ctype.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <stdlib.h>
  27 #include <errno.h>
  28 #include <signal.h>
  29 #include <limits.h>
  30 #include <unistd.h>
  31 #include "libavformat/avformat.h"
  32 #include "libavdevice/avdevice.h"
  33 #include "libswscale/swscale.h"
  34 #include "libavutil/opt.h"
  35 #include "libavcodec/audioconvert.h"
  36 #include "libavutil/audioconvert.h"
  37 #include "libavutil/parseutils.h"
  38 #include "libavutil/samplefmt.h"
  39 #include "libavutil/colorspace.h"
  40 #include "libavutil/fifo.h"
  41 #include "libavutil/intreadwrite.h"
  42 #include "libavutil/dict.h"
  43 #include "libavutil/mathematics.h"
  44 #include "libavutil/pixdesc.h"
  45 #include "libavutil/avstring.h"
  46 #include "libavutil/libm.h"
  47 #include "libavformat/os_support.h"
  48
  49 #include "libavformat/ffm.h" // not public API
  50
  51 #if CONFIG_AVFILTER
  52 # include "libavfilter/avcodec.h"
  53 # include "libavfilter/avfilter.h"
  54 # include "libavfilter/avfiltergraph.h"
  55 # include "libavfilter/buffersink.h"
  56 # include "libavfilter/vsrc_buffer.h"
  57 #endif
  58
  59 #if HAVE_SYS_RESOURCE_H
  60 #include <sys/types.h>
  61 #include <sys/time.h>
  62 #include <sys/resource.h>
  63 #elif HAVE_GETPROCESSTIMES
  64 #include <windows.h>
  65 #endif
  66 #if HAVE_GETPROCESSMEMORYINFO
  67 #include <windows.h>
  68 #include <psapi.h>
  69 #endif
  70
  71 #if HAVE_SYS_SELECT_H
  72 #include <sys/select.h>
  73 #endif
  74
  75 #if HAVE_TERMIOS_H
  76 #include <fcntl.h>
  77 #include <sys/ioctl.h>
  78 #include <sys/time.h>
  79 #include <termios.h>
  80 #elif HAVE_KBHIT
  81 #include <conio.h>
  82 #endif
  83 #include <time.h>
  84
  85 #include "cmdutils.h"
  86
  87 #include "libavutil/avassert.h"
  88
  89 const char program_name[] = "avconv";
  90 const int program_birth_year = 2000;
  91
  92 /* select an input stream for an output stream */
  93 typedef struct StreamMap {
  94     int disabled;           /** 1 is this mapping is disabled by a negative map */
  95     int file_index;
  96     int stream_index;
  97     int sync_file_index;
  98     int sync_stream_index;
  99 } StreamMap;
 100
 101 /**
 102  * select an input file for an output file
 103  */
 104 typedef struct MetadataMap {
 105     int  file;      ///< file index
 106     char type;      ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
 107     int  index;     ///< stream/chapter/program number
 108 } MetadataMap;
 109
 110 static const OptionDef options[];
 111
 112 #define MAX_STREAMS 1024    /* arbitrary sanity check value */
 113
 114 static int frame_bits_per_raw_sample = 0;
 115 static int video_discard = 0;
 116 static int same_quant = 0;
 117 static int do_deinterlace = 0;
 118 static int intra_dc_precision = 8;
 119 static int qp_hist = 0;
 120
 121 static int file_overwrite = 0;
 122 static int do_benchmark = 0;
 123 static int do_hex_dump = 0;
 124 static int do_pkt_dump = 0;
 125 static int do_pass = 0;
 126 static const char *pass_logfilename_prefix;
 127 static int video_sync_method= -1;
 128 static int audio_sync_method= 0;
 129 static float audio_drift_threshold= 0.1;
 130 static int copy_ts= 0;
 131 static int copy_tb= 0;
 132 static int opt_shortest = 0;
 133 static char *vstats_filename;
 134 static FILE *vstats_file;
 135 static int copy_initial_nonkeyframes = 0;
 136
 137 static int audio_volume = 256;
 138
 139 static int exit_on_error = 0;
 140 static int using_stdin = 0;
 141 static int run_as_daemon  = 0;
 142 static int q_pressed = 0;
 143 static int64_t video_size = 0;
 144 static int64_t audio_size = 0;
 145 static int64_t extra_size = 0;
 146 static int nb_frames_dup = 0;
 147 static int nb_frames_drop = 0;
 148 static int input_sync;
 149
 150 static float dts_delta_threshold = 10;
 151
 152 static int print_stats = 1;
 153
 154 static uint8_t *audio_buf;
 155 static uint8_t *audio_out;
 156 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
 157
 158 static void *samples;
 159
 160 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
 161
 162 typedef struct InputStream {
 163     int file_index;
 164     AVStream *st;
 165     int discard;             /* true if stream data should be discarded */
 166     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 167     AVCodec *dec;
 168
 169     int64_t       start;     /* time when read started */
 170     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 171                                 is not defined */
 172     int64_t       pts;       /* current pts */
 173     double ts_scale;
 174     int is_start;            /* is 1 at the start and after a discontinuity */
 175     int showed_multi_packet_warning;
 176     AVDictionary *opts;
 177 } InputStream;
 178
 179 typedef struct InputFile {
 180     AVFormatContext *ctx;
 181     int eof_reached;      /* true if eof reached */
 182     int ist_index;        /* index of first stream in ist_table */
 183     int buffer_size;      /* current total buffer size */
 184     int64_t ts_offset;
 185     int nb_streams;       /* number of stream that avconv is aware of; may be different
 186                              from ctx.nb_streams if new streams appear during av_read_frame() */
 187     int rate_emu;
 188 } InputFile;
 189
 190 typedef struct OutputStream {
 191     int file_index;          /* file index */
 192     int index;               /* stream index in the output file */
 193     int source_index;        /* InputStream index */
 194     AVStream *st;            /* stream in the output file */
 195     int encoding_needed;     /* true if encoding needed for this stream */
 196     int frame_number;
 197     /* input pts and corresponding output pts
 198        for A/V sync */
 199     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 200     struct InputStream *sync_ist; /* input stream to sync against */
 201     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 202     AVBitStreamFilterContext *bitstream_filters;
 203     AVCodec *enc;
 204     int64_t max_frames;
 205
 206     /* video only */
 207     int video_resample;
 208     AVFrame resample_frame;              /* temporary frame for image resampling */
 209     struct SwsContext *img_resample_ctx; /* for image resampling */
 210     int resample_height;
 211     int resample_width;
 212     int resample_pix_fmt;
 213     AVRational frame_rate;
 214     int force_fps;
 215     int top_field_first;
 216
 217     float frame_aspect_ratio;
 218
 219     /* forced key frames */
 220     int64_t *forced_kf_pts;
 221     int forced_kf_count;
 222     int forced_kf_index;
 223
 224     /* audio only */
 225     int audio_resample;
 226     ReSampleContext *resample; /* for audio resampling */
 227     int resample_sample_fmt;
 228     int resample_channels;
 229     int resample_sample_rate;
 230     int reformat_pair;
 231     AVAudioConvert *reformat_ctx;
 232     AVFifoBuffer *fifo;     /* for compression: one audio fifo per codec */
 233     FILE *logfile;
 234
 235 #if CONFIG_AVFILTER
 236     AVFilterContext *output_video_filter;
 237     AVFilterContext *input_video_filter;
 238     AVFilterBufferRef *picref;
 239     char *avfilter;
 240     AVFilterGraph *graph;
 241 #endif
 242
 243    int64_t sws_flags;
 244    AVDictionary *opts;
 245    int is_past_recording_time;
 246 } OutputStream;
 247
 248 #if HAVE_TERMIOS_H
 249
 250 /* init terminal so that we can grab keys */
 251 static struct termios oldtty;
 252 #endif
 253
 254 typedef struct OutputFile {
 255     AVFormatContext *ctx;
 256     AVDictionary *opts;
 257     int ost_index;       /* index of the first stream in output_streams */
 258     int64_t recording_time; /* desired length of the resulting file in microseconds */
 259     int64_t start_time;     /* start time in microseconds */
 260     uint64_t limit_filesize;
 261 } OutputFile;
 262
 263 static InputStream *input_streams = NULL;
 264 static int         nb_input_streams = 0;
 265 static InputFile   *input_files   = NULL;
 266 static int         nb_input_files   = 0;
 267
 268 static OutputStream *output_streams = NULL;
 269 static int        nb_output_streams = 0;
 270 static OutputFile   *output_files   = NULL;
 271 static int        nb_output_files   = 0;
 272
 273 typedef struct OptionsContext {
 274     /* input/output options */
 275     int64_t start_time;
 276     const char *format;
 277
 278     SpecifierOpt *codec_names;
 279     int        nb_codec_names;
 280     SpecifierOpt *audio_channels;
 281     int        nb_audio_channels;
 282     SpecifierOpt *audio_sample_rate;
 283     int        nb_audio_sample_rate;
 284     SpecifierOpt *frame_rates;
 285     int        nb_frame_rates;
 286     SpecifierOpt *frame_sizes;
 287     int        nb_frame_sizes;
 288     SpecifierOpt *frame_pix_fmts;
 289     int        nb_frame_pix_fmts;
 290
 291     /* input options */
 292     int64_t input_ts_offset;
 293     int rate_emu;
 294
 295     SpecifierOpt *ts_scale;
 296     int        nb_ts_scale;
 297
 298     /* output options */
 299     StreamMap *stream_maps;
 300     int     nb_stream_maps;
 301     /* first item specifies output metadata, second is input */
 302     MetadataMap (*meta_data_maps)[2];
 303     int nb_meta_data_maps;
 304     int metadata_global_manual;
 305     int metadata_streams_manual;
 306     int metadata_chapters_manual;
 307
 308     int chapters_input_file;
 309
 310     int64_t recording_time;
 311     uint64_t limit_filesize;
 312     float mux_preload;
 313     float mux_max_delay;
 314
 315     int video_disable;
 316     int audio_disable;
 317     int subtitle_disable;
 318     int data_disable;
 319
 320     /* indexed by output file stream index */
 321     int   *streamid_map;
 322     int nb_streamid_map;
 323
 324     SpecifierOpt *metadata;
 325     int        nb_metadata;
 326     SpecifierOpt *max_frames;
 327     int        nb_max_frames;
 328     SpecifierOpt *bitstream_filters;
 329     int        nb_bitstream_filters;
 330     SpecifierOpt *codec_tags;
 331     int        nb_codec_tags;
 332     SpecifierOpt *sample_fmts;
 333     int        nb_sample_fmts;
 334     SpecifierOpt *qscale;
 335     int        nb_qscale;
 336     SpecifierOpt *forced_key_frames;
 337     int        nb_forced_key_frames;
 338     SpecifierOpt *force_fps;
 339     int        nb_force_fps;
 340     SpecifierOpt *frame_aspect_ratios;
 341     int        nb_frame_aspect_ratios;
 342     SpecifierOpt *rc_overrides;
 343     int        nb_rc_overrides;
 344     SpecifierOpt *intra_matrices;
 345     int        nb_intra_matrices;
 346     SpecifierOpt *inter_matrices;
 347     int        nb_inter_matrices;
 348     SpecifierOpt *top_field_first;
 349     int        nb_top_field_first;
 350     SpecifierOpt *presets;
 351     int        nb_presets;
 352 #if CONFIG_AVFILTER
 353     SpecifierOpt *filters;
 354     int        nb_filters;
 355 #endif
 356 } OptionsContext;
 357
 358 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
 359 {\
 360     int i, ret;\
 361     for (i = 0; i < o->nb_ ## name; i++) {\
 362         char *spec = o->name[i].specifier;\
 363         if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
 364             outvar = o->name[i].u.type;\
 365         else if (ret < 0)\
 366             exit_program(1);\
 367     }\
 368 }
 369
 370 static void reset_options(OptionsContext *o)
 371 {
 372     const OptionDef *po = options;
 373
 374     /* all OPT_SPEC and OPT_STRING can be freed in generic way */
 375     while (po->name) {
 376         void *dst = (uint8_t*)o + po->u.off;
 377
 378         if (po->flags & OPT_SPEC) {
 379             SpecifierOpt **so = dst;
 380             int i, *count = (int*)(so + 1);
 381             for (i = 0; i < *count; i++) {
 382                 av_freep(&(*so)[i].specifier);
 383                 if (po->flags & OPT_STRING)
 384                     av_freep(&(*so)[i].u.str);
 385             }
 386             av_freep(so);
 387             *count = 0;
 388         } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
 389             av_freep(dst);
 390         po++;
 391     }
 392
 393     av_freep(&o->stream_maps);
 394     av_freep(&o->meta_data_maps);
 395     av_freep(&o->streamid_map);
 396
 397     memset(o, 0, sizeof(*o));
 398
 399     o->mux_preload    = 0.5;
 400     o->mux_max_delay  = 0.7;
 401     o->recording_time = INT64_MAX;
 402     o->limit_filesize = UINT64_MAX;
 403     o->chapters_input_file = INT_MAX;
 404
 405     uninit_opts();
 406     init_opts();
 407 }
 408
 409 #if CONFIG_AVFILTER
 410
 411 static int configure_video_filters(InputStream *ist, OutputStream *ost)
 412 {
 413     AVFilterContext *last_filter, *filter;
 414     /** filter graph containing all filters including input & output */
 415     AVCodecContext *codec = ost->st->codec;
 416     AVCodecContext *icodec = ist->st->codec;
 417     enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
 418     AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
 419     AVRational sample_aspect_ratio;
 420     char args[255];
 421     int ret;
 422
 423     ost->graph = avfilter_graph_alloc();
 424
 425     if (ist->st->sample_aspect_ratio.num){
 426         sample_aspect_ratio = ist->st->sample_aspect_ratio;
 427     }else
 428         sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
 429
 430     snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
 431              ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
 432              sample_aspect_ratio.num, sample_aspect_ratio.den);
 433
 434     ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
 435                                        "src", args, NULL, ost->graph);
 436     if (ret < 0)
 437         return ret;
 438 #if FF_API_OLD_VSINK_API
 439     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 440                                        "out", NULL, pix_fmts, ost->graph);
 441 #else
 442     buffersink_params->pixel_fmts = pix_fmts;
 443     ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
 444                                        "out", NULL, buffersink_params, ost->graph);
 445 #endif
 446     av_freep(&buffersink_params);
 447     if (ret < 0)
 448         return ret;
 449     last_filter = ost->input_video_filter;
 450
 451     if (codec->width  != icodec->width || codec->height != icodec->height) {
 452         snprintf(args, 255, "%d:%d:flags=0x%X",
 453                  codec->width,
 454                  codec->height,
 455                  (unsigned)ost->sws_flags);
 456         if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
 457                                                 NULL, args, NULL, ost->graph)) < 0)
 458             return ret;
 459         if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
 460             return ret;
 461         last_filter = filter;
 462     }
 463
 464     snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
 465     ost->graph->scale_sws_opts = av_strdup(args);
 466
 467     if (ost->avfilter) {
 468         AVFilterInOut *outputs = avfilter_inout_alloc();
 469         AVFilterInOut *inputs  = avfilter_inout_alloc();
 470
 471         outputs->name    = av_strdup("in");
 472         outputs->filter_ctx = last_filter;
 473         outputs->pad_idx = 0;
 474         outputs->next    = NULL;
 475
 476         inputs->name    = av_strdup("out");
 477         inputs->filter_ctx = ost->output_video_filter;
 478         inputs->pad_idx = 0;
 479         inputs->next    = NULL;
 480
 481         if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
 482             return ret;
 483         av_freep(&ost->avfilter);
 484     } else {
 485         if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
 486             return ret;
 487     }
 488
 489     if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
 490         return ret;
 491
 492     codec->width  = ost->output_video_filter->inputs[0]->w;
 493     codec->height = ost->output_video_filter->inputs[0]->h;
 494     codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
 495         ost->frame_aspect_ratio ? // overridden by the -aspect cli option
 496         av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
 497         ost->output_video_filter->inputs[0]->sample_aspect_ratio;
 498
 499     return 0;
 500 }
 501 #endif /* CONFIG_AVFILTER */
 502
 503 static void term_exit(void)
 504 {
 505     av_log(NULL, AV_LOG_QUIET, "%s", "");
 506 #if HAVE_TERMIOS_H
 507     if(!run_as_daemon)
 508         tcsetattr (0, TCSANOW, &oldtty);
 509 #endif
 510 }
 511
 512 static volatile int received_sigterm = 0;
 513
 514 static void
 515 sigterm_handler(int sig)
 516 {
 517     received_sigterm = sig;
 518     q_pressed++;
 519     term_exit();
 520 }
 521
 522 static void term_init(void)
 523 {
 524 #if HAVE_TERMIOS_H
 525     if(!run_as_daemon){
 526     struct termios tty;
 527
 528     tcgetattr (0, &tty);
 529     oldtty = tty;
 530     atexit(term_exit);
 531
 532     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 533                           |INLCR|IGNCR|ICRNL|IXON);
 534     tty.c_oflag |= OPOST;
 535     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 536     tty.c_cflag &= ~(CSIZE|PARENB);
 537     tty.c_cflag |= CS8;
 538     tty.c_cc[VMIN] = 1;
 539     tty.c_cc[VTIME] = 0;
 540
 541     tcsetattr (0, TCSANOW, &tty);
 542     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 543     }
 544 #endif
 545
 546     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 547     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 548 #ifdef SIGXCPU
 549     signal(SIGXCPU, sigterm_handler);
 550 #endif
 551 }
 552
 553 /* read a key without blocking */
 554 static int read_key(void)
 555 {
 556 #if HAVE_TERMIOS_H
 557     int n = 1;
 558     unsigned char ch;
 559     struct timeval tv;
 560     fd_set rfds;
 561
 562     if(run_as_daemon)
 563         return -1;
 564
 565     FD_ZERO(&rfds);
 566     FD_SET(0, &rfds);
 567     tv.tv_sec = 0;
 568     tv.tv_usec = 0;
 569     n = select(1, &rfds, NULL, NULL, &tv);
 570     if (n > 0) {
 571         n = read(0, &ch, 1);
 572         if (n == 1)
 573             return ch;
 574
 575         return n;
 576     }
 577 #elif HAVE_KBHIT
 578     if(kbhit())
 579         return(getch());
 580 #endif
 581     return -1;
 582 }
 583
 584 static int decode_interrupt_cb(void)
 585 {
 586     q_pressed += read_key() == 'q';
 587     return q_pressed > 1;
 588 }
 589
 590 void exit_program(int ret)
 591 {
 592     int i;
 593
 594     /* close files */
 595     for(i=0;i<nb_output_files;i++) {
 596         AVFormatContext *s = output_files[i].ctx;
 597         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 598             avio_close(s->pb);
 599         avformat_free_context(s);
 600         av_dict_free(&output_files[i].opts);
 601     }
 602     for(i=0;i<nb_input_files;i++) {
 603         av_close_input_file(input_files[i].ctx);
 604     }
 605     for (i = 0; i < nb_input_streams; i++)
 606         av_dict_free(&input_streams[i].opts);
 607
 608     if (vstats_file)
 609         fclose(vstats_file);
 610     av_free(vstats_filename);
 611
 612     av_freep(&input_streams);
 613     av_freep(&input_files);
 614     av_freep(&output_streams);
 615     av_freep(&output_files);
 616
 617     uninit_opts();
 618     av_free(audio_buf);
 619     av_free(audio_out);
 620     allocated_audio_buf_size= allocated_audio_out_size= 0;
 621     av_free(samples);
 622
 623 #if CONFIG_AVFILTER
 624     avfilter_uninit();
 625 #endif
 626
 627     if (received_sigterm) {
 628         av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
 629                (int) received_sigterm);
 630         exit (255);
 631     }
 632
 633     exit(ret); /* not all OS-es handle main() return value */
 634 }
 635
 636 static void assert_avoptions(AVDictionary *m)
 637 {
 638     AVDictionaryEntry *t;
 639     if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
 640         av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
 641         exit_program(1);
 642     }
 643 }
 644
 645 static void assert_codec_experimental(AVCodecContext *c, int encoder)
 646 {
 647     const char *codec_string = encoder ? "encoder" : "decoder";
 648     AVCodec *codec;
 649     if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
 650         c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 651         av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
 652                 "results.\nAdd '-strict experimental' if you want to use it.\n",
 653                 codec_string, c->codec->name);
 654         codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
 655         if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
 656             av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
 657                    codec_string, codec->name);
 658         exit_program(1);
 659     }
 660 }
 661
 662 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
 663 {
 664     if(codec && codec->sample_fmts){
 665         const enum AVSampleFormat *p= codec->sample_fmts;
 666         for(; *p!=-1; p++){
 667             if(*p == st->codec->sample_fmt)
 668                 break;
 669         }
 670         if (*p == -1) {
 671             if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
 672                 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
 673             if(av_get_sample_fmt_name(st->codec->sample_fmt))
 674             av_log(NULL, AV_LOG_WARNING,
 675                    "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
 676                    av_get_sample_fmt_name(st->codec->sample_fmt),
 677                    codec->name,
 678                    av_get_sample_fmt_name(codec->sample_fmts[0]));
 679             st->codec->sample_fmt = codec->sample_fmts[0];
 680         }
 681     }
 682 }
 683
 684 static void choose_sample_rate(AVStream *st, AVCodec *codec)
 685 {
 686     if(codec && codec->supported_samplerates){
 687         const int *p= codec->supported_samplerates;
 688         int best=0;
 689         int best_dist=INT_MAX;
 690         for(; *p; p++){
 691             int dist= abs(st->codec->sample_rate - *p);
 692             if(dist < best_dist){
 693                 best_dist= dist;
 694                 best= *p;
 695             }
 696         }
 697         if(best_dist){
 698             av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
 699         }
 700         st->codec->sample_rate= best;
 701     }
 702 }
 703
 704 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
 705 {
 706     if(codec && codec->pix_fmts){
 707         const enum PixelFormat *p= codec->pix_fmts;
 708         if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
 709             if(st->codec->codec_id==CODEC_ID_MJPEG){
 710                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
 711             }else if(st->codec->codec_id==CODEC_ID_LJPEG){
 712                 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
 713             }
 714         }
 715         for(; *p!=-1; p++){
 716             if(*p == st->codec->pix_fmt)
 717                 break;
 718         }
 719         if (*p == -1) {
 720             if(st->codec->pix_fmt != PIX_FMT_NONE)
 721                 av_log(NULL, AV_LOG_WARNING,
 722                         "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
 723                         av_pix_fmt_descriptors[st->codec->pix_fmt].name,
 724                         codec->name,
 725                         av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
 726             st->codec->pix_fmt = codec->pix_fmts[0];
 727         }
 728     }
 729 }
 730
 731 static double
 732 get_sync_ipts(const OutputStream *ost)
 733 {
 734     const InputStream *ist = ost->sync_ist;
 735     OutputFile *of = &output_files[ost->file_index];
 736     return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
 737 }
 738
 739 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 740     int ret;
 741
 742     while(bsfc){
 743         AVPacket new_pkt= *pkt;
 744         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 745                                           &new_pkt.data, &new_pkt.size,
 746                                           pkt->data, pkt->size,
 747                                           pkt->flags & AV_PKT_FLAG_KEY);
 748         if(a>0){
 749             av_free_packet(pkt);
 750             new_pkt.destruct= av_destruct_packet;
 751         } else if(a<0){
 752             av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
 753                    bsfc->filter->name, pkt->stream_index,
 754                    avctx->codec ? avctx->codec->name : "copy");
 755             print_error("", a);
 756             if (exit_on_error)
 757                 exit_program(1);
 758         }
 759         *pkt= new_pkt;
 760
 761         bsfc= bsfc->next;
 762     }
 763
 764     ret= av_interleaved_write_frame(s, pkt);
 765     if(ret < 0){
 766         print_error("av_interleaved_write_frame()", ret);
 767         exit_program(1);
 768     }
 769 }
 770
 771 static void do_audio_out(AVFormatContext *s,
 772                          OutputStream *ost,
 773                          InputStream *ist,
 774                          unsigned char *buf, int size)
 775 {
 776     uint8_t *buftmp;
 777     int64_t audio_out_size, audio_buf_size;
 778     int64_t allocated_for_size= size;
 779
 780     int size_out, frame_bytes, ret, resample_changed;
 781     AVCodecContext *enc= ost->st->codec;
 782     AVCodecContext *dec= ist->st->codec;
 783     int osize = av_get_bytes_per_sample(enc->sample_fmt);
 784     int isize = av_get_bytes_per_sample(dec->sample_fmt);
 785     const int coded_bps = av_get_bits_per_sample(enc->codec->id);
 786
 787 need_realloc:
 788     audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
 789     audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
 790     audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
 791     audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
 792     audio_buf_size*= osize*enc->channels;
 793
 794     audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
 795     if(coded_bps > 8*osize)
 796         audio_out_size= audio_out_size * coded_bps / (8*osize);
 797     audio_out_size += FF_MIN_BUFFER_SIZE;
 798
 799     if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
 800         av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
 801         exit_program(1);
 802     }
 803
 804     av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
 805     av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
 806     if (!audio_buf || !audio_out){
 807         av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
 808         exit_program(1);
 809     }
 810
 811     if (enc->channels != dec->channels)
 812         ost->audio_resample = 1;
 813
 814     resample_changed = ost->resample_sample_fmt  != dec->sample_fmt ||
 815                        ost->resample_channels    != dec->channels   ||
 816                        ost->resample_sample_rate != dec->sample_rate;
 817
 818     if ((ost->audio_resample && !ost->resample) || resample_changed) {
 819         if (resample_changed) {
 820             av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
 821                    ist->file_index, ist->st->index,
 822                    ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
 823                    dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
 824             ost->resample_sample_fmt  = dec->sample_fmt;
 825             ost->resample_channels    = dec->channels;
 826             ost->resample_sample_rate = dec->sample_rate;
 827             if (ost->resample)
 828                 audio_resample_close(ost->resample);
 829         }
 830         /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
 831         if (audio_sync_method <= 1 &&
 832             ost->resample_sample_fmt  == enc->sample_fmt &&
 833             ost->resample_channels    == enc->channels   &&
 834             ost->resample_sample_rate == enc->sample_rate) {
 835             ost->resample = NULL;
 836             ost->audio_resample = 0;
 837         } else {
 838             if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
 839                 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
 840             ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 841                                                    enc->sample_rate, dec->sample_rate,
 842                                                    enc->sample_fmt,  dec->sample_fmt,
 843                                                    16, 10, 0, 0.8);
 844             if (!ost->resample) {
 845                 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 846                        dec->channels, dec->sample_rate,
 847                        enc->channels, enc->sample_rate);
 848                 exit_program(1);
 849             }
 850         }
 851     }
 852
 853 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
 854     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 855         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 856         if (ost->reformat_ctx)
 857             av_audio_convert_free(ost->reformat_ctx);
 858         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 859                                                    dec->sample_fmt, 1, NULL, 0);
 860         if (!ost->reformat_ctx) {
 861             av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
 862                    av_get_sample_fmt_name(dec->sample_fmt),
 863                    av_get_sample_fmt_name(enc->sample_fmt));
 864             exit_program(1);
 865         }
 866         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 867     }
 868
 869     if(audio_sync_method){
 870         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 871                 - av_fifo_size(ost->fifo)/(enc->channels * 2);
 872         double idelta= delta*dec->sample_rate / enc->sample_rate;
 873         int byte_delta= ((int)idelta)*2*dec->channels;
 874
 875         //FIXME resample delay
 876         if(fabs(delta) > 50){
 877             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 878                 if(byte_delta < 0){
 879                     byte_delta= FFMAX(byte_delta, -size);
 880                     size += byte_delta;
 881                     buf  -= byte_delta;
 882                     av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
 883                     if(!size)
 884                         return;
 885                     ist->is_start=0;
 886                 }else{
 887                     static uint8_t *input_tmp= NULL;
 888                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 889
 890                     if(byte_delta > allocated_for_size - size){
 891                         allocated_for_size= byte_delta + (int64_t)size;
 892                         goto need_realloc;
 893                     }
 894                     ist->is_start=0;
 895
 896                     memset(input_tmp, 0, byte_delta);
 897                     memcpy(input_tmp + byte_delta, buf, size);
 898                     buf= input_tmp;
 899                     size += byte_delta;
 900                     av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
 901                 }
 902             }else if(audio_sync_method>1){
 903                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 904                 av_assert0(ost->audio_resample);
 905                 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
 906                        delta, comp, enc->sample_rate);
 907 //                fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
 908                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 909             }
 910         }
 911     }else
 912         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 913                         - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
 914
 915     if (ost->audio_resample) {
 916         buftmp = audio_buf;
 917         size_out = audio_resample(ost->resample,
 918                                   (short *)buftmp, (short *)buf,
 919                                   size / (dec->channels * isize));
 920         size_out = size_out * enc->channels * osize;
 921     } else {
 922         buftmp = buf;
 923         size_out = size;
 924     }
 925
 926     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 927         const void *ibuf[6]= {buftmp};
 928         void *obuf[6]= {audio_buf};
 929         int istride[6]= {isize};
 930         int ostride[6]= {osize};
 931         int len= size_out/istride[0];
 932         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 933             printf("av_audio_convert() failed\n");
 934             if (exit_on_error)
 935                 exit_program(1);
 936             return;
 937         }
 938         buftmp = audio_buf;
 939         size_out = len*osize;
 940     }
 941
 942     /* now encode as many frames as possible */
 943     if (enc->frame_size > 1) {
 944         /* output resampled raw samples */
 945         if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
 946             av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
 947             exit_program(1);
 948         }
 949         av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
 950
 951         frame_bytes = enc->frame_size * osize * enc->channels;
 952
 953         while (av_fifo_size(ost->fifo) >= frame_bytes) {
 954             AVPacket pkt;
 955             av_init_packet(&pkt);
 956
 957             av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
 958
 959             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 960
 961             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 962                                        (short *)audio_buf);
 963             if (ret < 0) {
 964                 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
 965                 exit_program(1);
 966             }
 967             audio_size += ret;
 968             pkt.stream_index= ost->index;
 969             pkt.data= audio_out;
 970             pkt.size= ret;
 971             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 972                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 973             pkt.flags |= AV_PKT_FLAG_KEY;
 974             write_frame(s, &pkt, enc, ost->bitstream_filters);
 975
 976             ost->sync_opts += enc->frame_size;
 977         }
 978     } else {
 979         AVPacket pkt;
 980         av_init_packet(&pkt);
 981
 982         ost->sync_opts += size_out / (osize * enc->channels);
 983
 984         /* output a pcm frame */
 985         /* determine the size of the coded buffer */
 986         size_out /= osize;
 987         if (coded_bps)
 988             size_out = size_out*coded_bps/8;
 989
 990         if(size_out > audio_out_size){
 991             av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
 992             exit_program(1);
 993         }
 994
 995         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 996         ret = avcodec_encode_audio(enc, audio_out, size_out,
 997                                    (short *)buftmp);
 998         if (ret < 0) {
 999             av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1000             exit_program(1);
1001         }
1002         audio_size += ret;
1003         pkt.stream_index= ost->index;
1004         pkt.data= audio_out;
1005         pkt.size= ret;
1006         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1007             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1008         pkt.flags |= AV_PKT_FLAG_KEY;
1009         write_frame(s, &pkt, enc, ost->bitstream_filters);
1010     }
1011 }
1012
1013 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1014 {
1015     AVCodecContext *dec;
1016     AVPicture *picture2;
1017     AVPicture picture_tmp;
1018     uint8_t *buf = 0;
1019
1020     dec = ist->st->codec;
1021
1022     /* deinterlace : must be done before any resize */
1023     if (do_deinterlace) {
1024         int size;
1025
1026         /* create temporary picture */
1027         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028         buf = av_malloc(size);
1029         if (!buf)
1030             return;
1031
1032         picture2 = &picture_tmp;
1033         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1034
1035         if(avpicture_deinterlace(picture2, picture,
1036                                  dec->pix_fmt, dec->width, dec->height) < 0) {
1037             /* if error, do not deinterlace */
1038             av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1039             av_free(buf);
1040             buf = NULL;
1041             picture2 = picture;
1042         }
1043     } else {
1044         picture2 = picture;
1045     }
1046
1047     if (picture != picture2)
1048         *picture = *picture2;
1049     *bufp = buf;
1050 }
1051
1052 static void do_subtitle_out(AVFormatContext *s,
1053                             OutputStream *ost,
1054                             InputStream *ist,
1055                             AVSubtitle *sub,
1056                             int64_t pts)
1057 {
1058     static uint8_t *subtitle_out = NULL;
1059     int subtitle_out_max_size = 1024 * 1024;
1060     int subtitle_out_size, nb, i;
1061     AVCodecContext *enc;
1062     AVPacket pkt;
1063
1064     if (pts == AV_NOPTS_VALUE) {
1065         av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1066         if (exit_on_error)
1067             exit_program(1);
1068         return;
1069     }
1070
1071     enc = ost->st->codec;
1072
1073     if (!subtitle_out) {
1074         subtitle_out = av_malloc(subtitle_out_max_size);
1075     }
1076
1077     /* Note: DVB subtitle need one packet to draw them and one other
1078        packet to clear them */
1079     /* XXX: signal it in the codec context ? */
1080     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1081         nb = 2;
1082     else
1083         nb = 1;
1084
1085     for(i = 0; i < nb; i++) {
1086         sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1087         // start_display_time is required to be 0
1088         sub->pts              += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1089         sub->end_display_time -= sub->start_display_time;
1090         sub->start_display_time = 0;
1091         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1092                                                     subtitle_out_max_size, sub);
1093         if (subtitle_out_size < 0) {
1094             av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1095             exit_program(1);
1096         }
1097
1098         av_init_packet(&pkt);
1099         pkt.stream_index = ost->index;
1100         pkt.data = subtitle_out;
1101         pkt.size = subtitle_out_size;
1102         pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1103         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1104             /* XXX: the pts correction is handled here. Maybe handling
1105                it in the codec would be better */
1106             if (i == 0)
1107                 pkt.pts += 90 * sub->start_display_time;
1108             else
1109                 pkt.pts += 90 * sub->end_display_time;
1110         }
1111         write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1112     }
1113 }
1114
1115 static int bit_buffer_size= 1024*256;
1116 static uint8_t *bit_buffer= NULL;
1117
1118 static void do_video_resample(OutputStream *ost,
1119                               InputStream *ist,
1120                               AVFrame *in_picture,
1121                               AVFrame **out_picture)
1122 {
1123     int resample_changed = 0;
1124     AVCodecContext *dec = ist->st->codec;
1125     AVCodecContext *enc = ost->st->codec;
1126     *out_picture = in_picture;
1127
1128     resample_changed = ost->resample_width   != dec->width  ||
1129                        ost->resample_height  != dec->height ||
1130                        ost->resample_pix_fmt != dec->pix_fmt;
1131
1132 #if !CONFIG_AVFILTER
1133     if (resample_changed) {
1134         av_log(NULL, AV_LOG_INFO,
1135                "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136                ist->file_index, ist->st->index,
1137                ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1138                dec->width         , dec->height         , av_get_pix_fmt_name(dec->pix_fmt));
1139         ost->resample_width   = dec->width;
1140         ost->resample_height  = dec->height;
1141         ost->resample_pix_fmt = dec->pix_fmt;
1142     }
1143
1144     ost->video_resample = dec->width   != enc->width  ||
1145                           dec->height  != enc->height ||
1146                           dec->pix_fmt != enc->pix_fmt;
1147
1148     if (ost->video_resample) {
1149         *out_picture = &ost->resample_frame;
1150         if (!ost->img_resample_ctx || resample_changed) {
1151             /* initialize the destination picture */
1152             if (!ost->resample_frame.data[0]) {
1153                 avcodec_get_frame_defaults(&ost->resample_frame);
1154                 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1155                                     enc->width, enc->height)) {
1156                     fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1157                     exit_program(1);
1158                 }
1159             }
1160             /* initialize a new scaler context */
1161             sws_freeContext(ost->img_resample_ctx);
1162             ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1163                                                    enc->width, enc->height, enc->pix_fmt,
1164                                                    ost->sws_flags, NULL, NULL, NULL);
1165             if (ost->img_resample_ctx == NULL) {
1166                 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1167                 exit_program(1);
1168             }
1169         }
1170         sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1171               0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1172     }
1173 #else
1174     if (resample_changed) {
1175         avfilter_graph_free(&ost->graph);
1176         if (configure_video_filters(ist, ost)) {
1177             av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1178             exit_program(1);
1179         }
1180     }
1181 #endif
1182     if (resample_changed) {
1183         ost->resample_width   = dec->width;
1184         ost->resample_height  = dec->height;
1185         ost->resample_pix_fmt = dec->pix_fmt;
1186     }
1187 }
1188
1189
1190 static void do_video_out(AVFormatContext *s,
1191                          OutputStream *ost,
1192                          InputStream *ist,
1193                          AVFrame *in_picture,
1194                          int *frame_size, float quality)
1195 {
1196     int nb_frames, i, ret, format_video_sync;
1197     AVFrame *final_picture;
1198     AVCodecContext *enc;
1199     double sync_ipts;
1200
1201     enc = ost->st->codec;
1202
1203     sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1204
1205     /* by default, we output a single frame */
1206     nb_frames = 1;
1207
1208     *frame_size = 0;
1209
1210     format_video_sync = video_sync_method;
1211     if (format_video_sync < 0)
1212         format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1213
1214     if (format_video_sync) {
1215         double vdelta = sync_ipts - ost->sync_opts;
1216         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1217         if (vdelta < -1.1)
1218             nb_frames = 0;
1219         else if (format_video_sync == 2) {
1220             if(vdelta<=-0.6){
1221                 nb_frames=0;
1222             }else if(vdelta>0.6)
1223                 ost->sync_opts= lrintf(sync_ipts);
1224         }else if (vdelta > 1.1)
1225             nb_frames = lrintf(vdelta);
1226 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1227         if (nb_frames == 0){
1228             ++nb_frames_drop;
1229             av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1230         }else if (nb_frames > 1) {
1231             nb_frames_dup += nb_frames - 1;
1232             av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1233         }
1234     }else
1235         ost->sync_opts= lrintf(sync_ipts);
1236
1237     nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1238     if (nb_frames <= 0)
1239         return;
1240
1241     do_video_resample(ost, ist, in_picture, &final_picture);
1242
1243     /* duplicates frame if needed */
1244     for(i=0;i<nb_frames;i++) {
1245         AVPacket pkt;
1246         av_init_packet(&pkt);
1247         pkt.stream_index= ost->index;
1248
1249         if (s->oformat->flags & AVFMT_RAWPICTURE) {
1250             /* raw pictures are written as AVPicture structure to
1251                avoid any copies. We support temporarily the older
1252                method. */
1253             enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1254             enc->coded_frame->top_field_first  = in_picture->top_field_first;
1255             pkt.data= (uint8_t *)final_picture;
1256             pkt.size=  sizeof(AVPicture);
1257             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1258             pkt.flags |= AV_PKT_FLAG_KEY;
1259
1260             write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1261         } else {
1262             AVFrame big_picture;
1263
1264             big_picture= *final_picture;
1265             /* better than nothing: use input picture interlaced
1266                settings */
1267             big_picture.interlaced_frame = in_picture->interlaced_frame;
1268             if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1269                 if (ost->top_field_first == -1)
1270                     big_picture.top_field_first = in_picture->top_field_first;
1271                 else
1272                     big_picture.top_field_first = !!ost->top_field_first;
1273             }
1274
1275             /* handles same_quant here. This is not correct because it may
1276                not be a global option */
1277             big_picture.quality = quality;
1278             if (!enc->me_threshold)
1279                 big_picture.pict_type = 0;
1280 //            big_picture.pts = AV_NOPTS_VALUE;
1281             big_picture.pts= ost->sync_opts;
1282 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1283 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1284             if (ost->forced_kf_index < ost->forced_kf_count &&
1285                 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1286                 big_picture.pict_type = AV_PICTURE_TYPE_I;
1287                 ost->forced_kf_index++;
1288             }
1289             ret = avcodec_encode_video(enc,
1290                                        bit_buffer, bit_buffer_size,
1291                                        &big_picture);
1292             if (ret < 0) {
1293                 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1294                 exit_program(1);
1295             }
1296
1297             if(ret>0){
1298                 pkt.data= bit_buffer;
1299                 pkt.size= ret;
1300                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1301                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1302 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1303    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1304    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1305
1306                 if(enc->coded_frame->key_frame)
1307                     pkt.flags |= AV_PKT_FLAG_KEY;
1308                 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1309                 *frame_size = ret;
1310                 video_size += ret;
1311                 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1312                 //        enc->frame_number-1, ret, enc->pict_type);
1313                 /* if two pass, output log */
1314                 if (ost->logfile && enc->stats_out) {
1315                     fprintf(ost->logfile, "%s", enc->stats_out);
1316                 }
1317             }
1318         }
1319         ost->sync_opts++;
1320         ost->frame_number++;
1321     }
1322 }
1323
1324 static double psnr(double d){
1325     return -10.0*log(d)/log(10.0);
1326 }
1327
1328 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1329                            int frame_size)
1330 {
1331     AVCodecContext *enc;
1332     int frame_number;
1333     double ti1, bitrate, avg_bitrate;
1334
1335     /* this is executed just the first time do_video_stats is called */
1336     if (!vstats_file) {
1337         vstats_file = fopen(vstats_filename, "w");
1338         if (!vstats_file) {
1339             perror("fopen");
1340             exit_program(1);
1341         }
1342     }
1343
1344     enc = ost->st->codec;
1345     if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346         frame_number = ost->frame_number;
1347         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348         if (enc->flags&CODEC_FLAG_PSNR)
1349             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1350
1351         fprintf(vstats_file,"f_size= %6d ", frame_size);
1352         /* compute pts value */
1353         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1354         if (ti1 < 0.01)
1355             ti1 = 0.01;
1356
1357         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1358         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1359         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1360             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1361         fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1362     }
1363 }
1364
1365 static void print_report(OutputFile *output_files,
1366                          OutputStream *ost_table, int nb_ostreams,
1367                          int is_last_report, int64_t timer_start)
1368 {
1369     char buf[1024];
1370     OutputStream *ost;
1371     AVFormatContext *oc;
1372     int64_t total_size;
1373     AVCodecContext *enc;
1374     int frame_number, vid, i;
1375     double bitrate;
1376     int64_t pts = INT64_MAX;
1377     static int64_t last_time = -1;
1378     static int qp_histogram[52];
1379     int hours, mins, secs, us;
1380
1381     if (!print_stats && !is_last_report)
1382         return;
1383
1384     if (!is_last_report) {
1385         int64_t cur_time;
1386         /* display the report every 0.5 seconds */
1387         cur_time = av_gettime();
1388         if (last_time == -1) {
1389             last_time = cur_time;
1390             return;
1391         }
1392         if ((cur_time - last_time) < 500000)
1393             return;
1394         last_time = cur_time;
1395     }
1396
1397
1398     oc = output_files[0].ctx;
1399
1400     total_size = avio_size(oc->pb);
1401     if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1402         total_size= avio_tell(oc->pb);
1403
1404     buf[0] = '\0';
1405     vid = 0;
1406     for(i=0;i<nb_ostreams;i++) {
1407         float q = -1;
1408         ost = &ost_table[i];
1409         enc = ost->st->codec;
1410         if (!ost->st->stream_copy && enc->coded_frame)
1411             q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1412         if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1413             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1414         }
1415         if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416             float t = (av_gettime()-timer_start) / 1000000.0;
1417
1418             frame_number = ost->frame_number;
1419             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1420                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1421             if(is_last_report)
1422                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1423             if(qp_hist){
1424                 int j;
1425                 int qp = lrintf(q);
1426                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1427                     qp_histogram[qp]++;
1428                 for(j=0; j<32; j++)
1429                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1430             }
1431             if (enc->flags&CODEC_FLAG_PSNR){
1432                 int j;
1433                 double error, error_sum=0;
1434                 double scale, scale_sum=0;
1435                 char type[3]= {'Y','U','V'};
1436                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1437                 for(j=0; j<3; j++){
1438                     if(is_last_report){
1439                         error= enc->error[j];
1440                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1441                     }else{
1442                         error= enc->coded_frame->error[j];
1443                         scale= enc->width*enc->height*255.0*255.0;
1444                     }
1445                     if(j) scale/=4;
1446                     error_sum += error;
1447                     scale_sum += scale;
1448                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1449                 }
1450                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1451             }
1452             vid = 1;
1453         }
1454         /* compute min output value */
1455         pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1456                                       ost->st->time_base, AV_TIME_BASE_Q));
1457     }
1458
1459     secs = pts / AV_TIME_BASE;
1460     us = pts % AV_TIME_BASE;
1461     mins = secs / 60;
1462     secs %= 60;
1463     hours = mins / 60;
1464     mins %= 60;
1465
1466     bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1467
1468     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469              "size=%8.0fkB time=", total_size / 1024.0);
1470     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1471              "%02d:%02d:%02d.%02d ", hours, mins, secs,
1472              (100 * us) / AV_TIME_BASE);
1473     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474              "bitrate=%6.1fkbits/s", bitrate);
1475
1476     if (nb_frames_dup || nb_frames_drop)
1477         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1478                 nb_frames_dup, nb_frames_drop);
1479
1480     av_log(NULL, AV_LOG_INFO, "%s    \r", buf);
1481
1482     fflush(stderr);
1483
1484     if (is_last_report) {
1485         int64_t raw= audio_size + video_size + extra_size;
1486         av_log(NULL, AV_LOG_INFO, "\n");
1487         av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1488                video_size/1024.0,
1489                audio_size/1024.0,
1490                extra_size/1024.0,
1491                100.0*(total_size - raw)/raw
1492         );
1493     }
1494 }
1495
1496 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1497 {
1498     int fill_char = 0x00;
1499     if (sample_fmt == AV_SAMPLE_FMT_U8)
1500         fill_char = 0x80;
1501     memset(buf, fill_char, size);
1502 }
1503
1504 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1505 {
1506     int i, ret;
1507
1508     for (i = 0; i < nb_ostreams; i++) {
1509         OutputStream   *ost = &ost_table[i];
1510         AVCodecContext *enc = ost->st->codec;
1511         AVFormatContext *os = output_files[ost->file_index].ctx;
1512
1513         if (!ost->encoding_needed)
1514             continue;
1515
1516         if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1517             continue;
1518         if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1519             continue;
1520
1521         for(;;) {
1522             AVPacket pkt;
1523             int fifo_bytes;
1524             av_init_packet(&pkt);
1525             pkt.stream_index= ost->index;
1526
1527             switch (ost->st->codec->codec_type) {
1528             case AVMEDIA_TYPE_AUDIO:
1529                 fifo_bytes = av_fifo_size(ost->fifo);
1530                 ret = 0;
1531                 /* encode any samples remaining in fifo */
1532                 if (fifo_bytes > 0) {
1533                     int osize = av_get_bytes_per_sample(enc->sample_fmt);
1534                     int fs_tmp = enc->frame_size;
1535
1536                     av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1537                     if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1538                         enc->frame_size = fifo_bytes / (osize * enc->channels);
1539                     } else { /* pad */
1540                         int frame_bytes = enc->frame_size*osize*enc->channels;
1541                         if (allocated_audio_buf_size < frame_bytes)
1542                             exit_program(1);
1543                         generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1544                     }
1545
1546                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1547                     pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1548                                               ost->st->time_base.num, enc->sample_rate);
1549                     enc->frame_size = fs_tmp;
1550                 }
1551                 if (ret <= 0) {
1552                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1553                 }
1554                 if (ret < 0) {
1555                     av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1556                     exit_program(1);
1557                 }
1558                 audio_size += ret;
1559                 pkt.flags |= AV_PKT_FLAG_KEY;
1560                 break;
1561             case AVMEDIA_TYPE_VIDEO:
1562                 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1563                 if (ret < 0) {
1564                     av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1565                     exit_program(1);
1566                 }
1567                 video_size += ret;
1568                 if(enc->coded_frame && enc->coded_frame->key_frame)
1569                     pkt.flags |= AV_PKT_FLAG_KEY;
1570                 if (ost->logfile && enc->stats_out) {
1571                     fprintf(ost->logfile, "%s", enc->stats_out);
1572                 }
1573                 break;
1574             default:
1575                 ret=-1;
1576             }
1577
1578             if (ret <= 0)
1579                 break;
1580             pkt.data = bit_buffer;
1581             pkt.size = ret;
1582             if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1583                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1584             write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1585         }
1586     }
1587 }
1588
1589 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1590 static int output_packet(InputStream *ist, int ist_index,
1591                          OutputStream *ost_table, int nb_ostreams,
1592                          const AVPacket *pkt)
1593 {
1594     AVFormatContext *os;
1595     OutputStream *ost;
1596     int ret = 0, i;
1597     int got_output;
1598     void *buffer_to_free = NULL;
1599     static unsigned int samples_size= 0;
1600     AVSubtitle subtitle, *subtitle_to_free;
1601     int64_t pkt_pts = AV_NOPTS_VALUE;
1602 #if CONFIG_AVFILTER
1603     int frame_available;
1604 #endif
1605     float quality;
1606
1607     AVPacket avpkt;
1608     int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1609
1610     if(ist->next_pts == AV_NOPTS_VALUE)
1611         ist->next_pts= ist->pts;
1612
1613     if (pkt == NULL) {
1614         /* EOF handling */
1615         av_init_packet(&avpkt);
1616         avpkt.data = NULL;
1617         avpkt.size = 0;
1618         goto handle_eof;
1619     } else {
1620         avpkt = *pkt;
1621     }
1622
1623     if(pkt->dts != AV_NOPTS_VALUE)
1624         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1625     if(pkt->pts != AV_NOPTS_VALUE)
1626         pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1627
1628     //while we have more to decode or while the decoder did output something on EOF
1629     while (avpkt.size > 0 || (!pkt && got_output)) {
1630         uint8_t *data_buf, *decoded_data_buf;
1631         int data_size, decoded_data_size;
1632         AVFrame *decoded_frame, *filtered_frame;
1633     handle_eof:
1634         ist->pts= ist->next_pts;
1635
1636         if(avpkt.size && avpkt.size != pkt->size)
1637             av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1638                    "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1639             ist->showed_multi_packet_warning=1;
1640
1641         /* decode the packet if needed */
1642         decoded_frame    = filtered_frame = NULL;
1643         decoded_data_buf = NULL; /* fail safe */
1644         decoded_data_size= 0;
1645         data_buf  = avpkt.data;
1646         data_size = avpkt.size;
1647         subtitle_to_free = NULL;
1648         if (ist->decoding_needed) {
1649             switch(ist->st->codec->codec_type) {
1650             case AVMEDIA_TYPE_AUDIO:{
1651                 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1652                     samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1653                     av_free(samples);
1654                     samples= av_malloc(samples_size);
1655                 }
1656                 decoded_data_size= samples_size;
1657                     /* XXX: could avoid copy if PCM 16 bits with same
1658                        endianness as CPU */
1659                 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1660                                             &avpkt);
1661                 if (ret < 0)
1662                     return ret;
1663                 avpkt.data += ret;
1664                 avpkt.size -= ret;
1665                 data_size   = ret;
1666                 got_output  = decoded_data_size > 0;
1667                 /* Some bug in mpeg audio decoder gives */
1668                 /* decoded_data_size < 0, it seems they are overflows */
1669                 if (!got_output) {
1670                     /* no audio frame */
1671                     continue;
1672                 }
1673                 decoded_data_buf = (uint8_t *)samples;
1674                 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1675                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1676                 break;}
1677             case AVMEDIA_TYPE_VIDEO:
1678                     if (!(decoded_frame = avcodec_alloc_frame()))
1679                         return AVERROR(ENOMEM);
1680                     avpkt.pts = pkt_pts;
1681                     avpkt.dts = ist->pts;
1682                     pkt_pts = AV_NOPTS_VALUE;
1683
1684                     ret = avcodec_decode_video2(ist->st->codec,
1685                                                 decoded_frame, &got_output, &avpkt);
1686                     quality = same_quant ? decoded_frame->quality : 0;
1687                     if (ret < 0)
1688                         goto fail;
1689                     if (!got_output) {
1690                         /* no picture yet */
1691                         av_freep(&decoded_frame);
1692                         goto discard_packet;
1693                     }
1694                     ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1695                     if (ist->st->codec->time_base.num != 0) {
1696                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1697                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1698                                           ist->st->codec->time_base.num * ticks) /
1699                             ist->st->codec->time_base.den;
1700                     }
1701                     avpkt.size = 0;
1702                     buffer_to_free = NULL;
1703                     pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1704                     break;
1705             case AVMEDIA_TYPE_SUBTITLE:
1706                 ret = avcodec_decode_subtitle2(ist->st->codec,
1707                                                &subtitle, &got_output, &avpkt);
1708                 if (ret < 0)
1709                     return ret;
1710                 if (!got_output) {
1711                     goto discard_packet;
1712                 }
1713                 subtitle_to_free = &subtitle;
1714                 avpkt.size = 0;
1715                 break;
1716             default:
1717                 return -1;
1718             }
1719         } else {
1720             switch(ist->st->codec->codec_type) {
1721             case AVMEDIA_TYPE_AUDIO:
1722                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1723                     ist->st->codec->sample_rate;
1724                 break;
1725             case AVMEDIA_TYPE_VIDEO:
1726                 if (ist->st->codec->time_base.num != 0) {
1727                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1728                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1729                                       ist->st->codec->time_base.num * ticks) /
1730                         ist->st->codec->time_base.den;
1731                 }
1732                 break;
1733             }
1734             avpkt.size = 0;
1735         }
1736
1737         // preprocess audio (volume)
1738         if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1739             if (audio_volume != 256) {
1740                 switch (ist->st->codec->sample_fmt) {
1741                 case AV_SAMPLE_FMT_U8:
1742                 {
1743                     uint8_t *volp = samples;
1744                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1745                         int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1746                         *volp++ = av_clip_uint8(v);
1747                     }
1748                     break;
1749                 }
1750                 case AV_SAMPLE_FMT_S16:
1751                 {
1752                     int16_t *volp = samples;
1753                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1754                         int v = ((*volp) * audio_volume + 128) >> 8;
1755                         *volp++ = av_clip_int16(v);
1756                     }
1757                     break;
1758                 }
1759                 case AV_SAMPLE_FMT_S32:
1760                 {
1761                     int32_t *volp = samples;
1762                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1763                         int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1764                         *volp++ = av_clipl_int32(v);
1765                     }
1766                     break;
1767                 }
1768                 case AV_SAMPLE_FMT_FLT:
1769                 {
1770                     float *volp = samples;
1771                     float scale = audio_volume / 256.f;
1772                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1773                         *volp++ *= scale;
1774                     }
1775                     break;
1776                 }
1777                 case AV_SAMPLE_FMT_DBL:
1778                 {
1779                     double *volp = samples;
1780                     double scale = audio_volume / 256.;
1781                     for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1782                         *volp++ *= scale;
1783                     }
1784                     break;
1785                 }
1786                 default:
1787                     av_log(NULL, AV_LOG_FATAL,
1788                            "Audio volume adjustment on sample format %s is not supported.\n",
1789                            av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1790                     exit_program(1);
1791                 }
1792             }
1793         }
1794
1795         /* frame rate emulation */
1796         if (input_files[ist->file_index].rate_emu) {
1797             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1798             int64_t now = av_gettime() - ist->start;
1799             if (pts > now)
1800                 usleep(pts - now);
1801         }
1802         /* if output time reached then transcode raw format,
1803            encode packets and output them */
1804         for (i = 0; i < nb_ostreams; i++) {
1805             OutputFile *of = &output_files[ost_table[i].file_index];
1806             int frame_size;
1807
1808             ost = &ost_table[i];
1809             if (ost->source_index != ist_index)
1810                 continue;
1811
1812             if (of->start_time && ist->pts < of->start_time)
1813                 continue;
1814
1815             if (of->recording_time != INT64_MAX &&
1816                 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1817                               (AVRational){1, 1000000}) >= 0) {
1818                 ost->is_past_recording_time = 1;
1819                 continue;
1820             }
1821
1822 #if CONFIG_AVFILTER
1823             if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1824                 ost->input_video_filter) {
1825                 if (!decoded_frame->sample_aspect_ratio.num)
1826                     decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1827                 decoded_frame->pts = ist->pts;
1828
1829                 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1830                 if (!(filtered_frame = avcodec_alloc_frame())) {
1831                     ret = AVERROR(ENOMEM);
1832                     goto fail;
1833                 }
1834             }
1835             frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1836                 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1837             while (frame_available) {
1838                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1839                     AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1840                     if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1841                         goto cont;
1842                     if (ost->picref) {
1843                         avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1844                         ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1845                     }
1846                 }
1847 #else
1848                 filtered_frame = decoded_frame;
1849 #endif
1850                 os = output_files[ost->file_index].ctx;
1851
1852                 /* set the input output pts pairs */
1853                 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1854
1855                 if (ost->encoding_needed) {
1856                     av_assert0(ist->decoding_needed);
1857                     switch(ost->st->codec->codec_type) {
1858                     case AVMEDIA_TYPE_AUDIO:
1859                         do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1860                         break;
1861                     case AVMEDIA_TYPE_VIDEO:
1862 #if CONFIG_AVFILTER
1863                         if (ost->picref->video && !ost->frame_aspect_ratio)
1864                             ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1865 #endif
1866                         do_video_out(os, ost, ist, filtered_frame, &frame_size,
1867                                      same_quant ? quality : ost->st->codec->global_quality);
1868                         if (vstats_filename && frame_size)
1869                             do_video_stats(os, ost, frame_size);
1870                         break;
1871                     case AVMEDIA_TYPE_SUBTITLE:
1872                         do_subtitle_out(os, ost, ist, &subtitle,
1873                                         pkt->pts);
1874                         break;
1875                     default:
1876                         abort();
1877                     }
1878                 } else {
1879                     AVPicture pict;
1880                     AVPacket opkt;
1881                     int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1882                     av_init_packet(&opkt);
1883
1884                     if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1885 #if !CONFIG_AVFILTER
1886                         continue;
1887 #else
1888                         goto cont;
1889 #endif
1890
1891                     /* no reencoding needed : output the packet directly */
1892                     /* force the input stream PTS */
1893
1894                     if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1895                         audio_size += data_size;
1896                     else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1897                         video_size += data_size;
1898                         ost->sync_opts++;
1899                     }
1900
1901                     opkt.stream_index= ost->index;
1902                     if(pkt->pts != AV_NOPTS_VALUE)
1903                         opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1904                     else
1905                         opkt.pts= AV_NOPTS_VALUE;
1906
1907                     if (pkt->dts == AV_NOPTS_VALUE)
1908                         opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1909                     else
1910                         opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1911                     opkt.dts -= ost_tb_start_time;
1912
1913                     opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1914                     opkt.flags= pkt->flags;
1915
1916                     //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1917                     if(   ost->st->codec->codec_id != CODEC_ID_H264
1918                        && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1919                        && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1920                        ) {
1921                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1922                             opkt.destruct= av_destruct_packet;
1923                     } else {
1924                         opkt.data = data_buf;
1925                         opkt.size = data_size;
1926                     }
1927
1928                     if (os->oformat->flags & AVFMT_RAWPICTURE) {
1929                         /* store AVPicture in AVPacket, as expected by the output format */
1930                         avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1931                         opkt.data = (uint8_t *)&pict;
1932                         opkt.size = sizeof(AVPicture);
1933                         opkt.flags |= AV_PKT_FLAG_KEY;
1934                     }
1935                     write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1936                     ost->st->codec->frame_number++;
1937                     ost->frame_number++;
1938                     av_free_packet(&opkt);
1939                 }
1940 #if CONFIG_AVFILTER
1941                 cont:
1942                 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1943                                    ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1944                 if (ost->picref)
1945                     avfilter_unref_buffer(ost->picref);
1946             }
1947             av_freep(&filtered_frame);
1948 #endif
1949             }
1950
1951 fail:
1952         av_free(buffer_to_free);
1953         /* XXX: allocate the subtitles in the codec ? */
1954         if (subtitle_to_free) {
1955             avsubtitle_free(subtitle_to_free);
1956             subtitle_to_free = NULL;
1957         }
1958         av_freep(&decoded_frame);
1959         if (ret < 0)
1960             return ret;
1961     }
1962  discard_packet:
1963
1964     return 0;
1965 }
1966
1967 static void print_sdp(OutputFile *output_files, int n)
1968 {
1969     char sdp[2048];
1970     int i;
1971     AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1972
1973     if (!avc)
1974         exit_program(1);
1975     for (i = 0; i < n; i++)
1976         avc[i] = output_files[i].ctx;
1977
1978     av_sdp_create(avc, n, sdp, sizeof(sdp));
1979     printf("SDP:\n%s\n", sdp);
1980     fflush(stdout);
1981     av_freep(&avc);
1982 }
1983
1984 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1985                              char *error, int error_len)
1986 {
1987     int i;
1988     InputStream *ist = &input_streams[ist_index];
1989     if (ist->decoding_needed) {
1990         AVCodec *codec = ist->dec;
1991         if (!codec) {
1992             snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1993                     ist->st->codec->codec_id, ist->file_index, ist->st->index);
1994             return AVERROR(EINVAL);
1995         }
1996
1997         if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1998             snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1999                     ist->file_index, ist->st->index);
2000             return AVERROR(EINVAL);
2001         }
2002         assert_codec_experimental(ist->st->codec, 0);
2003         assert_avoptions(ist->opts);
2004     }
2005
2006     ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2007     ist->next_pts = AV_NOPTS_VALUE;
2008     ist->is_start = 1;
2009
2010     return 0;
2011 }
2012
2013 static int transcode_init(OutputFile *output_files,
2014                           int nb_output_files,
2015                           InputFile *input_files,
2016                           int nb_input_files)
2017 {
2018     int ret = 0, i, j, k;
2019     AVFormatContext *os;
2020     AVCodecContext *codec, *icodec;
2021     OutputStream *ost;
2022     InputStream *ist;
2023     char error[1024];
2024     int want_sdp = 1;
2025
2026     /* init framerate emulation */
2027     for (i = 0; i < nb_input_files; i++) {
2028         InputFile *ifile = &input_files[i];
2029         if (ifile->rate_emu)
2030             for (j = 0; j < ifile->nb_streams; j++)
2031                 input_streams[j + ifile->ist_index].start = av_gettime();
2032     }
2033
2034     /* output stream init */
2035     for(i=0;i<nb_output_files;i++) {
2036         os = output_files[i].ctx;
2037         if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2038             av_dump_format(os, i, os->filename, 1);
2039             av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2040             return AVERROR(EINVAL);
2041         }
2042     }
2043
2044     /* for each output stream, we compute the right encoding parameters */
2045     for (i = 0; i < nb_output_streams; i++) {
2046         ost = &output_streams[i];
2047         os = output_files[ost->file_index].ctx;
2048         ist = &input_streams[ost->source_index];
2049
2050         codec = ost->st->codec;
2051         icodec = ist->st->codec;
2052
2053         ost->st->disposition = ist->st->disposition;
2054         codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2055         codec->chroma_sample_location = icodec->chroma_sample_location;
2056
2057         if (ost->st->stream_copy) {
2058             uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2059
2060             if (extra_size > INT_MAX) {
2061                 return AVERROR(EINVAL);
2062             }
2063
2064             /* if stream_copy is selected, no need to decode or encode */
2065             codec->codec_id = icodec->codec_id;
2066             codec->codec_type = icodec->codec_type;
2067
2068             if(!codec->codec_tag){
2069                 if(   !os->oformat->codec_tag
2070                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2071                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2072                     codec->codec_tag = icodec->codec_tag;
2073             }
2074
2075             codec->bit_rate = icodec->bit_rate;
2076             codec->rc_max_rate    = icodec->rc_max_rate;
2077             codec->rc_buffer_size = icodec->rc_buffer_size;
2078             codec->extradata= av_mallocz(extra_size);
2079             if (!codec->extradata) {
2080                 return AVERROR(ENOMEM);
2081             }
2082             memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2083             codec->extradata_size= icodec->extradata_size;
2084
2085             codec->time_base = ist->st->time_base;
2086             if(!strcmp(os->oformat->name, "avi")) {
2087                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2088                     codec->time_base = icodec->time_base;
2089                     codec->time_base.num *= icodec->ticks_per_frame;
2090                     codec->time_base.den *= 2;
2091                 }
2092             } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2093                 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2094                     codec->time_base = icodec->time_base;
2095                     codec->time_base.num *= icodec->ticks_per_frame;
2096                 }
2097             }
2098             av_reduce(&codec->time_base.num, &codec->time_base.den,
2099                         codec->time_base.num, codec->time_base.den, INT_MAX);
2100
2101             switch(codec->codec_type) {
2102             case AVMEDIA_TYPE_AUDIO:
2103                 if(audio_volume != 256) {
2104                     av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2105                     exit_program(1);
2106                 }
2107                 codec->channel_layout = icodec->channel_layout;
2108                 codec->sample_rate = icodec->sample_rate;
2109                 codec->channels = icodec->channels;
2110                 codec->frame_size = icodec->frame_size;
2111                 codec->audio_service_type = icodec->audio_service_type;
2112                 codec->block_align= icodec->block_align;
2113                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2114                     codec->block_align= 0;
2115                 if(codec->codec_id == CODEC_ID_AC3)
2116                     codec->block_align= 0;
2117                 break;
2118             case AVMEDIA_TYPE_VIDEO:
2119                 codec->pix_fmt = icodec->pix_fmt;
2120                 codec->width = icodec->width;
2121                 codec->height = icodec->height;
2122                 codec->has_b_frames = icodec->has_b_frames;
2123                 if (!codec->sample_aspect_ratio.num) {
2124                     codec->sample_aspect_ratio =
2125                     ost->st->sample_aspect_ratio =
2126                         ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2127                         ist->st->codec->sample_aspect_ratio.num ?
2128                         ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2129                 }
2130                 break;
2131             case AVMEDIA_TYPE_SUBTITLE:
2132                 codec->width = icodec->width;
2133                 codec->height = icodec->height;
2134                 break;
2135             case AVMEDIA_TYPE_DATA:
2136             case AVMEDIA_TYPE_ATTACHMENT:
2137                 break;
2138             default:
2139                 abort();
2140             }
2141         } else {
2142             if (!ost->enc)
2143                 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2144             ist->decoding_needed = 1;
2145             ost->encoding_needed = 1;
2146             switch(codec->codec_type) {
2147             case AVMEDIA_TYPE_AUDIO:
2148                 ost->fifo= av_fifo_alloc(1024);
2149                 if (!ost->fifo) {
2150                     return AVERROR(ENOMEM);
2151                 }
2152                 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2153                 if (!codec->sample_rate) {
2154                     codec->sample_rate = icodec->sample_rate;
2155                 }
2156                 choose_sample_rate(ost->st, ost->enc);
2157                 codec->time_base = (AVRational){1, codec->sample_rate};
2158                 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2159                     codec->sample_fmt = icodec->sample_fmt;
2160                 choose_sample_fmt(ost->st, ost->enc);
2161                 if (!codec->channels) {
2162                     codec->channels = icodec->channels;
2163                     codec->channel_layout = icodec->channel_layout;
2164                 }
2165                 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2166                     codec->channel_layout = 0;
2167                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2168                 icodec->request_channels = codec->channels;
2169                 ost->resample_sample_fmt  = icodec->sample_fmt;
2170                 ost->resample_sample_rate = icodec->sample_rate;
2171                 ost->resample_channels    = icodec->channels;
2172                 break;
2173             case AVMEDIA_TYPE_VIDEO:
2174                 if (codec->pix_fmt == PIX_FMT_NONE)
2175                     codec->pix_fmt = icodec->pix_fmt;
2176                 choose_pixel_fmt(ost->st, ost->enc);
2177
2178                 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2179                     av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2180                     exit_program(1);
2181                 }
2182
2183                 if (!codec->width || !codec->height) {
2184                     codec->width  = icodec->width;
2185                     codec->height = icodec->height;
2186                 }
2187
2188                 ost->video_resample = codec->width   != icodec->width  ||
2189                                       codec->height  != icodec->height ||
2190                                       codec->pix_fmt != icodec->pix_fmt;
2191                 if (ost->video_resample) {
2192                     codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2193                 }
2194
2195                 ost->resample_height = icodec->height;
2196                 ost->resample_width  = icodec->width;
2197                 ost->resample_pix_fmt= icodec->pix_fmt;
2198
2199                 if (!ost->frame_rate.num)
2200                     ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2201                 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2202                     int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2203                     ost->frame_rate = ost->enc->supported_framerates[idx];
2204                 }
2205                 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2206                 if(   av_q2d(codec->time_base) < 0.001 && video_sync_method
2207                    && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2208                     av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2209                                                "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2210                 }
2211
2212 #if CONFIG_AVFILTER
2213                 if (configure_video_filters(ist, ost)) {
2214                     av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2215                     exit(1);
2216                 }
2217 #endif
2218                 break;
2219             case AVMEDIA_TYPE_SUBTITLE:
2220                 break;
2221             default:
2222                 abort();
2223                 break;
2224             }
2225             /* two pass mode */
2226             if (codec->codec_id != CODEC_ID_H264 &&
2227                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2228                 char logfilename[1024];
2229                 FILE *f;
2230
2231                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2232                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2233                          i);
2234                 if (codec->flags & CODEC_FLAG_PASS1) {
2235                     f = fopen(logfilename, "wb");
2236                     if (!f) {
2237                         av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2238                                logfilename, strerror(errno));
2239                         exit_program(1);
2240                     }
2241                     ost->logfile = f;
2242                 } else {
2243                     char  *logbuffer;
2244                     size_t logbuffer_size;
2245                     if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2246                         av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2247                                logfilename);
2248                         exit_program(1);
2249                     }
2250                     codec->stats_in = logbuffer;
2251                 }
2252             }
2253         }
2254         if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2255             /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2256             int size= codec->width * codec->height;
2257             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2258         }
2259     }
2260
2261     if (!bit_buffer)
2262         bit_buffer = av_malloc(bit_buffer_size);
2263     if (!bit_buffer) {
2264         av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2265                bit_buffer_size);
2266         return AVERROR(ENOMEM);
2267     }
2268
2269     /* open each encoder */
2270     for (i = 0; i < nb_output_streams; i++) {
2271         ost = &output_streams[i];
2272         if (ost->encoding_needed) {
2273             AVCodec *codec = ost->enc;
2274             AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2275             if (!codec) {
2276                 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2277                          ost->st->codec->codec_id, ost->file_index, ost->index);
2278                 ret = AVERROR(EINVAL);
2279                 goto dump_format;
2280             }
2281             if (dec->subtitle_header) {
2282                 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2283                 if (!ost->st->codec->subtitle_header) {
2284                     ret = AVERROR(ENOMEM);
2285                     goto dump_format;
2286                 }
2287                 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2288                 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2289             }
2290             if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2291                 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2292                         ost->file_index, ost->index);
2293                 ret = AVERROR(EINVAL);
2294                 goto dump_format;
2295             }
2296             assert_codec_experimental(ost->st->codec, 1);
2297             assert_avoptions(ost->opts);
2298             if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2299                 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2300                                              "It takes bits/s as argument, not kbits/s\n");
2301             extra_size += ost->st->codec->extradata_size;
2302
2303             if (ost->st->codec->me_threshold)
2304                 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2305         }
2306     }
2307
2308     /* init input streams */
2309     for (i = 0; i < nb_input_streams; i++)
2310         if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2311             goto dump_format;
2312
2313     /* discard unused programs */
2314     for (i = 0; i < nb_input_files; i++) {
2315         InputFile *ifile = &input_files[i];
2316         for (j = 0; j < ifile->ctx->nb_programs; j++) {
2317             AVProgram *p = ifile->ctx->programs[j];
2318             int discard  = AVDISCARD_ALL;
2319
2320             for (k = 0; k < p->nb_stream_indexes; k++)
2321                 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2322                     discard = AVDISCARD_DEFAULT;
2323                     break;
2324                 }
2325             p->discard = discard;
2326         }
2327     }
2328
2329     /* open files and write file headers */
2330     for (i = 0; i < nb_output_files; i++) {
2331         os = output_files[i].ctx;
2332         if (avformat_write_header(os, &output_files[i].opts) < 0) {
2333             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2334             ret = AVERROR(EINVAL);
2335             goto dump_format;
2336         }
2337 //        assert_avoptions(output_files[i].opts);
2338         if (strcmp(os->oformat->name, "rtp")) {
2339             want_sdp = 0;
2340         }
2341     }
2342
2343  dump_format:
2344     /* dump the file output parameters - cannot be done before in case
2345        of stream copy */
2346     for(i=0;i<nb_output_files;i++) {
2347         av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2348     }
2349
2350     /* dump the stream mapping */
2351     av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2352     for (i = 0; i < nb_output_streams; i++) {
2353         ost = &output_streams[i];
2354         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d -> #%d.%d",
2355                input_streams[ost->source_index].file_index,
2356                input_streams[ost->source_index].st->index,
2357                ost->file_index,
2358                ost->index);
2359         if (ost->sync_ist != &input_streams[ost->source_index])
2360             av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2361                    ost->sync_ist->file_index,
2362                    ost->sync_ist->st->index);
2363         if (ost->st->stream_copy)
2364             av_log(NULL, AV_LOG_INFO, " (copy)");
2365         else
2366             av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2367                    input_streams[ost->source_index].dec->name : "?",
2368                    ost->enc ? ost->enc->name : "?");
2369         av_log(NULL, AV_LOG_INFO, "\n");
2370     }
2371
2372     if (ret) {
2373         av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2374         return ret;
2375     }
2376
2377     if (want_sdp) {
2378         print_sdp(output_files, nb_output_files);
2379     }
2380
2381     return 0;
2382 }
2383
2384 /*
2385  * The following code is the main loop of the file converter
2386  */
2387 static int transcode(OutputFile *output_files,
2388                      int nb_output_files,
2389                      InputFile *input_files,
2390                      int nb_input_files)
2391 {
2392     int ret, i;
2393     AVFormatContext *is, *os;
2394     OutputStream *ost;
2395     InputStream *ist;
2396     uint8_t *no_packet;
2397     int no_packet_count=0;
2398     int64_t timer_start;
2399     int key;
2400
2401     if (!(no_packet = av_mallocz(nb_input_files)))
2402         exit_program(1);
2403
2404     ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2405     if (ret < 0)
2406         goto fail;
2407
2408     if (!using_stdin) {
2409         av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2410         avio_set_interrupt_cb(decode_interrupt_cb);
2411     }
2412     term_init();
2413
2414     timer_start = av_gettime();
2415
2416     for(; received_sigterm == 0;) {
2417         int file_index, ist_index;
2418         AVPacket pkt;
2419         int64_t ipts_min;
2420         double opts_min;
2421
2422         ipts_min = INT64_MAX;
2423         opts_min= 1e100;
2424         /* if 'q' pressed, exits */
2425         if (!using_stdin) {
2426             if (q_pressed)
2427                 break;
2428             /* read_key() returns 0 on EOF */
2429             key = read_key();
2430             if (key == 'q')
2431                 break;
2432             if (key == '+') av_log_set_level(av_log_get_level()+10);
2433             if (key == '-') av_log_set_level(av_log_get_level()-10);
2434             if (key == 's') qp_hist     ^= 1;
2435             if (key == 'h'){
2436                 if (do_hex_dump){
2437                     do_hex_dump = do_pkt_dump = 0;
2438                 } else if(do_pkt_dump){
2439                     do_hex_dump = 1;
2440                 } else
2441                     do_pkt_dump = 1;
2442                 av_log_set_level(AV_LOG_DEBUG);
2443             }
2444             if (key == 'd' || key == 'D'){
2445                 int debug=0;
2446                 if(key == 'D') {
2447                     debug = input_streams[0].st->codec->debug<<1;
2448                     if(!debug) debug = 1;
2449                     while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2450                         debug += debug;
2451                 }else
2452                     scanf("%d", &debug);
2453                 for(i=0;i<nb_input_streams;i++) {
2454                     input_streams[i].st->codec->debug = debug;
2455                 }
2456                 for(i=0;i<nb_output_streams;i++) {
2457                     ost = &output_streams[i];
2458                     ost->st->codec->debug = debug;
2459                 }
2460                 if(debug) av_log_set_level(AV_LOG_DEBUG);
2461                 fprintf(stderr,"debug=%d\n", debug);
2462             }
2463             if (key == '?'){
2464                 fprintf(stderr, "key    function\n"
2465                                 "?      show this help\n"
2466                                 "+      increase verbosity\n"
2467                                 "-      decrease verbosity\n"
2468                                 "D      cycle through available debug modes\n"
2469                                 "h      dump packets/hex press to cycle through the 3 states\n"
2470                                 "q      quit\n"
2471                                 "s      Show QP histogram\n"
2472                 );
2473             }
2474         }
2475
2476         /* select the stream that we must read now by looking at the
2477            smallest output pts */
2478         file_index = -1;
2479         for (i = 0; i < nb_output_streams; i++) {
2480             OutputFile *of;
2481             int64_t ipts;
2482             double  opts;
2483             ost = &output_streams[i];
2484             of = &output_files[ost->file_index];
2485             os = output_files[ost->file_index].ctx;
2486             ist = &input_streams[ost->source_index];
2487             if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2488                 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2489                 continue;
2490             opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2491             ipts = ist->pts;
2492             if (!input_files[ist->file_index].eof_reached){
2493                 if(ipts < ipts_min) {
2494                     ipts_min = ipts;
2495                     if(input_sync ) file_index = ist->file_index;
2496                 }
2497                 if(opts < opts_min) {
2498                     opts_min = opts;
2499                     if(!input_sync) file_index = ist->file_index;
2500                 }
2501             }
2502             if (ost->frame_number >= ost->max_frames) {
2503                 int j;
2504                 for (j = 0; j < of->ctx->nb_streams; j++)
2505                     output_streams[of->ost_index + j].is_past_recording_time = 1;
2506                 continue;
2507             }
2508         }
2509         /* if none, if is finished */
2510         if (file_index < 0) {
2511             if(no_packet_count){
2512                 no_packet_count=0;
2513                 memset(no_packet, 0, nb_input_files);
2514                 usleep(10000);
2515                 continue;
2516             }
2517             break;
2518         }
2519
2520         /* read a frame from it and output it in the fifo */
2521         is = input_files[file_index].ctx;
2522         ret= av_read_frame(is, &pkt);
2523         if(ret == AVERROR(EAGAIN)){
2524             no_packet[file_index]=1;
2525             no_packet_count++;
2526             continue;
2527         }
2528         if (ret < 0) {
2529             input_files[file_index].eof_reached = 1;
2530             if (opt_shortest)
2531                 break;
2532             else
2533                 continue;
2534         }
2535
2536         no_packet_count=0;
2537         memset(no_packet, 0, nb_input_files);
2538
2539         if (do_pkt_dump) {
2540             av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2541                              is->streams[pkt.stream_index]);
2542         }
2543         /* the following test is needed in case new streams appear
2544            dynamically in stream : we ignore them */
2545         if (pkt.stream_index >= input_files[file_index].nb_streams)
2546             goto discard_packet;
2547         ist_index = input_files[file_index].ist_index + pkt.stream_index;
2548         ist = &input_streams[ist_index];
2549         if (ist->discard)
2550             goto discard_packet;
2551
2552         if (pkt.dts != AV_NOPTS_VALUE)
2553             pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2554         if (pkt.pts != AV_NOPTS_VALUE)
2555             pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2556
2557         if(pkt.pts != AV_NOPTS_VALUE)
2558             pkt.pts *= ist->ts_scale;
2559         if(pkt.dts != AV_NOPTS_VALUE)
2560             pkt.dts *= ist->ts_scale;
2561
2562 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2563         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2564             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2565             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2566             int64_t delta= pkt_dts - ist->next_pts;
2567             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2568                 input_files[ist->file_index].ts_offset -= delta;
2569                 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2570                        delta, input_files[ist->file_index].ts_offset);
2571                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2572                 if(pkt.pts != AV_NOPTS_VALUE)
2573                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2574             }
2575         }
2576
2577         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2578         if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2579
2580             av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2581                    ist->file_index, ist->st->index);
2582             if (exit_on_error)
2583                 exit_program(1);
2584             av_free_packet(&pkt);
2585             continue;
2586         }
2587
2588     discard_packet:
2589         av_free_packet(&pkt);
2590
2591         /* dump report by using the output first video and audio streams */
2592         print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2593     }
2594
2595     /* at the end of stream, we must flush the decoder buffers */
2596     for (i = 0; i < nb_input_streams; i++) {
2597         ist = &input_streams[i];
2598         if (ist->decoding_needed) {
2599             output_packet(ist, i, output_streams, nb_output_streams, NULL);
2600         }
2601     }
2602     flush_encoders(output_streams, nb_output_streams);
2603
2604     term_exit();
2605
2606     /* write the trailer if needed and close file */
2607     for(i=0;i<nb_output_files;i++) {
2608         os = output_files[i].ctx;
2609         av_write_trailer(os);
2610     }
2611
2612     /* dump report by using the first video and audio streams */
2613     print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2614
2615     /* close each encoder */
2616     for (i = 0; i < nb_output_streams; i++) {
2617         ost = &output_streams[i];
2618         if (ost->encoding_needed) {
2619             av_freep(&ost->st->codec->stats_in);
2620             avcodec_close(ost->st->codec);
2621         }
2622 #if CONFIG_AVFILTER
2623         avfilter_graph_free(&ost->graph);
2624 #endif
2625     }
2626
2627     /* close each decoder */
2628     for (i = 0; i < nb_input_streams; i++) {
2629         ist = &input_streams[i];
2630         if (ist->decoding_needed) {
2631             avcodec_close(ist->st->codec);
2632         }
2633     }
2634
2635     /* finished ! */
2636     ret = 0;
2637
2638  fail:
2639     av_freep(&bit_buffer);
2640     av_freep(&no_packet);
2641
2642     if (output_streams) {
2643         for (i = 0; i < nb_output_streams; i++) {
2644             ost = &output_streams[i];
2645             if (ost) {
2646                 if (ost->st->stream_copy)
2647                     av_freep(&ost->st->codec->extradata);
2648                 if (ost->logfile) {
2649                     fclose(ost->logfile);
2650                     ost->logfile = NULL;
2651                 }
2652                 av_fifo_free(ost->fifo); /* works even if fifo is not
2653                                              initialized but set to zero */
2654                 av_freep(&ost->st->codec->subtitle_header);
2655                 av_free(ost->resample_frame.data[0]);
2656                 av_free(ost->forced_kf_pts);
2657                 if (ost->video_resample)
2658                     sws_freeContext(ost->img_resample_ctx);
2659                 if (ost->resample)
2660                     audio_resample_close(ost->resample);
2661                 if (ost->reformat_ctx)
2662                     av_audio_convert_free(ost->reformat_ctx);
2663                 av_dict_free(&ost->opts);
2664             }
2665         }
2666     }
2667     return ret;
2668 }
2669
2670 static double parse_frame_aspect_ratio(const char *arg)
2671 {
2672     int x = 0, y = 0;
2673     double ar = 0;
2674     const char *p;
2675     char *end;
2676
2677     p = strchr(arg, ':');
2678     if (p) {
2679         x = strtol(arg, &end, 10);
2680         if (end == p)
2681             y = strtol(end+1, &end, 10);
2682         if (x > 0 && y > 0)
2683             ar = (double)x / (double)y;
2684     } else
2685         ar = strtod(arg, NULL);
2686
2687     if (!ar) {
2688         av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2689         exit_program(1);
2690     }
2691     return ar;
2692 }
2693
2694 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2695 {
2696     return parse_option(o, "codec:a", arg, options);
2697 }
2698
2699 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2700 {
2701     return parse_option(o, "codec:v", arg, options);
2702 }
2703
2704 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2705 {
2706     return parse_option(o, "codec:s", arg, options);
2707 }
2708
2709 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2710 {
2711     return parse_option(o, "codec:d", arg, options);
2712 }
2713
2714 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2715 {
2716     StreamMap *m = NULL;
2717     int i, negative = 0, file_idx;
2718     int sync_file_idx = -1, sync_stream_idx;
2719     char *p, *sync;
2720     char *map;
2721
2722     if (*arg == '-') {
2723         negative = 1;
2724         arg++;
2725     }
2726     map = av_strdup(arg);
2727
2728     /* parse sync stream first, just pick first matching stream */
2729     if (sync = strchr(map, ',')) {
2730         *sync = 0;
2731         sync_file_idx = strtol(sync + 1, &sync, 0);
2732         if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2733             av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2734             exit_program(1);
2735         }
2736         if (*sync)
2737             sync++;
2738         for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2739             if (check_stream_specifier(input_files[sync_file_idx].ctx,
2740                                        input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2741                 sync_stream_idx = i;
2742                 break;
2743             }
2744         if (i == input_files[sync_file_idx].nb_streams) {
2745             av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2746                                        "match any streams.\n", arg);
2747             exit_program(1);
2748         }
2749     }
2750
2751
2752     file_idx = strtol(map, &p, 0);
2753     if (file_idx >= nb_input_files || file_idx < 0) {
2754         av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2755         exit_program(1);
2756     }
2757     if (negative)
2758         /* disable some already defined maps */
2759         for (i = 0; i < o->nb_stream_maps; i++) {
2760             m = &o->stream_maps[i];
2761             if (check_stream_specifier(input_files[m->file_index].ctx,
2762                                        input_files[m->file_index].ctx->streams[m->stream_index],
2763                                        *p == ':' ? p + 1 : p) > 0)
2764                 m->disabled = 1;
2765         }
2766     else
2767         for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2768             if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2769                         *p == ':' ? p + 1 : p) <= 0)
2770                 continue;
2771             o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2772                                         &o->nb_stream_maps, o->nb_stream_maps + 1);
2773             m = &o->stream_maps[o->nb_stream_maps - 1];
2774
2775             m->file_index   = file_idx;
2776             m->stream_index = i;
2777
2778             if (sync_file_idx >= 0) {
2779                 m->sync_file_index   = sync_file_idx;
2780                 m->sync_stream_index = sync_stream_idx;
2781             } else {
2782                 m->sync_file_index   = file_idx;
2783                 m->sync_stream_index = i;
2784             }
2785         }
2786
2787     if (!m) {
2788         av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2789         exit_program(1);
2790     }
2791
2792     av_freep(&map);
2793     return 0;
2794 }
2795
2796 static void parse_meta_type(char *arg, char *type, int *index)
2797 {
2798     if (*arg) {
2799         *type = *arg;
2800         switch (*arg) {
2801         case 'g':
2802             break;
2803         case 's':
2804         case 'c':
2805         case 'p':
2806             if (*(++arg) == ':')
2807                 *index = strtol(++arg, NULL, 0);
2808             break;
2809         default:
2810             av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2811             exit_program(1);
2812         }
2813     } else
2814         *type = 'g';
2815 }
2816
2817 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2818 {
2819     MetadataMap *m, *m1;
2820     char *p;
2821
2822     o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2823                                    &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2824
2825     m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2826     m->file = strtol(arg, &p, 0);
2827     parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2828
2829     m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2830     if (p = strchr(opt, ':'))
2831         parse_meta_type(p + 1, &m1->type, &m1->index);
2832     else
2833         m1->type = 'g';
2834
2835     if (m->type == 'g' || m1->type == 'g')
2836         o->metadata_global_manual = 1;
2837     if (m->type == 's' || m1->type == 's')
2838         o->metadata_streams_manual = 1;
2839     if (m->type == 'c' || m1->type == 'c')
2840         o->metadata_chapters_manual = 1;
2841
2842     return 0;
2843 }
2844
2845 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2846 {
2847     const char *codec_string = encoder ? "encoder" : "decoder";
2848     AVCodec *codec;
2849
2850     if(!name)
2851         return CODEC_ID_NONE;
2852     codec = encoder ?
2853         avcodec_find_encoder_by_name(name) :
2854         avcodec_find_decoder_by_name(name);
2855     if(!codec) {
2856         av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2857         exit_program(1);
2858     }
2859     if(codec->type != type) {
2860         av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2861         exit_program(1);
2862     }
2863     return codec->id;
2864 }
2865
2866 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2867 {
2868     char *codec_name = NULL;
2869
2870     MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2871
2872     if (!codec_name) {
2873         if (s->oformat) {
2874             st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2875             return avcodec_find_encoder(st->codec->codec_id);
2876         }
2877     } else if (!strcmp(codec_name, "copy"))
2878         st->stream_copy = 1;
2879     else {
2880         st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2881         return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2882                             avcodec_find_decoder_by_name(codec_name);
2883     }
2884
2885     return NULL;
2886 }
2887
2888 /**
2889  * Add all the streams from the given input file to the global
2890  * list of input streams.
2891  */
2892 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2893 {
2894     int i, rfps, rfps_base;
2895
2896     for (i = 0; i < ic->nb_streams; i++) {
2897         AVStream *st = ic->streams[i];
2898         AVCodecContext *dec = st->codec;
2899         InputStream *ist;
2900         double scale = 1.0;
2901
2902         input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2903         ist = &input_streams[nb_input_streams - 1];
2904         ist->st = st;
2905         ist->file_index = nb_input_files;
2906         ist->discard = 1;
2907         ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2908
2909         MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2910         ist->ts_scale = scale;
2911
2912         ist->dec = choose_codec(o, ic, st, dec->codec_type);
2913         if (!ist->dec)
2914             ist->dec = avcodec_find_decoder(dec->codec_id);
2915
2916         switch (dec->codec_type) {
2917         case AVMEDIA_TYPE_AUDIO:
2918             if(!ist->dec)
2919                 ist->dec = avcodec_find_decoder(dec->codec_id);
2920             if(o->audio_disable)
2921                 st->discard= AVDISCARD_ALL;
2922             break;
2923         case AVMEDIA_TYPE_VIDEO:
2924             if(!ist->dec)
2925                 ist->dec = avcodec_find_decoder(dec->codec_id);
2926             rfps      = ic->streams[i]->r_frame_rate.num;
2927             rfps_base = ic->streams[i]->r_frame_rate.den;
2928             if (dec->lowres) {
2929                 dec->flags |= CODEC_FLAG_EMU_EDGE;
2930             }
2931
2932             if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2933
2934                 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2935                        i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2936                        (float)rfps / rfps_base, rfps, rfps_base);
2937             }
2938
2939             if (o->video_disable)
2940                 st->discard= AVDISCARD_ALL;
2941             else if(video_discard)
2942                 st->discard= video_discard;
2943             break;
2944         case AVMEDIA_TYPE_DATA:
2945             break;
2946         case AVMEDIA_TYPE_SUBTITLE:
2947             if(!ist->dec)
2948                 ist->dec = avcodec_find_decoder(dec->codec_id);
2949             if(o->subtitle_disable)
2950                 st->discard = AVDISCARD_ALL;
2951             break;
2952         case AVMEDIA_TYPE_ATTACHMENT:
2953         case AVMEDIA_TYPE_UNKNOWN:
2954             break;
2955         default:
2956             abort();
2957         }
2958     }
2959 }
2960
2961 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2962 {
2963     AVFormatContext *ic;
2964     AVInputFormat *file_iformat = NULL;
2965     int err, i, ret;
2966     int64_t timestamp;
2967     uint8_t buf[128];
2968     AVDictionary **opts;
2969     int orig_nb_streams;                     // number of streams before avformat_find_stream_info
2970
2971     if (o->format) {
2972         if (!(file_iformat = av_find_input_format(o->format))) {
2973             av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2974             exit_program(1);
2975         }
2976     }
2977
2978     if (!strcmp(filename, "-"))
2979         filename = "pipe:";
2980
2981     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2982                     !strcmp(filename, "/dev/stdin");
2983
2984     /* get default parameters from command line */
2985     ic = avformat_alloc_context();
2986     if (!ic) {
2987         print_error(filename, AVERROR(ENOMEM));
2988         exit_program(1);
2989     }
2990     if (o->nb_audio_sample_rate) {
2991         snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2992         av_dict_set(&format_opts, "sample_rate", buf, 0);
2993     }
2994     if (o->nb_audio_channels) {
2995         snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2996         av_dict_set(&format_opts, "channels", buf, 0);
2997     }
2998     if (o->nb_frame_rates) {
2999         av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3000     }
3001     if (o->nb_frame_sizes) {
3002         av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3003     }
3004     if (o->nb_frame_pix_fmts)
3005         av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3006
3007     ic->flags |= AVFMT_FLAG_NONBLOCK;
3008
3009     /* open the input file with generic libav function */
3010     err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3011     if (err < 0) {
3012         print_error(filename, err);
3013         exit_program(1);
3014     }
3015     assert_avoptions(format_opts);
3016
3017     /* apply forced codec ids */
3018     for (i = 0; i < ic->nb_streams; i++)
3019         choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3020
3021     /* Set AVCodecContext options for avformat_find_stream_info */
3022     opts = setup_find_stream_info_opts(ic, codec_opts);
3023     orig_nb_streams = ic->nb_streams;
3024
3025     /* If not enough info to get the stream parameters, we decode the
3026        first frames to get it. (used in mpeg case for example) */
3027     ret = avformat_find_stream_info(ic, opts);
3028     if (ret < 0) {
3029         av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3030         av_close_input_file(ic);
3031         exit_program(1);
3032     }
3033
3034     timestamp = o->start_time;
3035     /* add the stream start time */
3036     if (ic->start_time != AV_NOPTS_VALUE)
3037         timestamp += ic->start_time;
3038
3039     /* if seeking requested, we execute it */
3040     if (o->start_time != 0) {
3041         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3042         if (ret < 0) {
3043             av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3044                    filename, (double)timestamp / AV_TIME_BASE);
3045         }
3046     }
3047
3048     /* update the current parameters so that they match the one of the input stream */
3049     add_input_streams(o, ic);
3050
3051     /* dump the file content */
3052     av_dump_format(ic, nb_input_files, filename, 0);
3053
3054     input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3055     input_files[nb_input_files - 1].ctx        = ic;
3056     input_files[nb_input_files - 1].ist_index  = nb_input_streams - ic->nb_streams;
3057     input_files[nb_input_files - 1].ts_offset  = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3058     input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3059     input_files[nb_input_files - 1].rate_emu   = o->rate_emu;
3060
3061     for (i = 0; i < orig_nb_streams; i++)
3062         av_dict_free(&opts[i]);
3063     av_freep(&opts);
3064
3065     reset_options(o);
3066     return 0;
3067 }
3068
3069 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3070                                     AVCodecContext *avctx)
3071 {
3072     char *p;
3073     int n = 1, i;
3074     int64_t t;
3075
3076     for (p = kf; *p; p++)
3077         if (*p == ',')
3078             n++;
3079     ost->forced_kf_count = n;
3080     ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3081     if (!ost->forced_kf_pts) {
3082         av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3083         exit_program(1);
3084     }
3085     for (i = 0; i < n; i++) {
3086         p = i ? strchr(p, ',') + 1 : kf;
3087         t = parse_time_or_die("force_key_frames", p, 1);
3088         ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3089     }
3090 }
3091
3092 static uint8_t *get_line(AVIOContext *s)
3093 {
3094     AVIOContext *line;
3095     uint8_t *buf;
3096     char c;
3097
3098     if (avio_open_dyn_buf(&line) < 0) {
3099         av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3100         exit_program(1);
3101     }
3102
3103     while ((c = avio_r8(s)) && c != '\n')
3104         avio_w8(line, c);
3105     avio_w8(line, 0);
3106     avio_close_dyn_buf(line, &buf);
3107
3108     return buf;
3109 }
3110
3111 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3112 {
3113     int i, ret = 1;
3114     char filename[1000];
3115     const char *base[3] = { getenv("AVCONV_DATADIR"),
3116                             getenv("HOME"),
3117                             AVCONV_DATADIR,
3118                             };
3119
3120     for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3121         if (!base[i])
3122             continue;
3123         if (codec_name) {
3124             snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3125                      i != 1 ? "" : "/.avconv", codec_name, preset_name);
3126             ret = avio_open(s, filename, AVIO_FLAG_READ);
3127         }
3128         if (ret) {
3129             snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3130                      i != 1 ? "" : "/.avconv", preset_name);
3131             ret = avio_open(s, filename, AVIO_FLAG_READ);
3132         }
3133     }
3134     return ret;
3135 }
3136
3137 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3138 {
3139     OutputStream *ost;
3140     AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3141     int idx      = oc->nb_streams - 1, ret = 0;
3142     int64_t max_frames = INT64_MAX;
3143     char *bsf = NULL, *next, *codec_tag = NULL;
3144     AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3145     double qscale = -1;
3146     char *buf = NULL, *arg = NULL, *preset = NULL;
3147     AVIOContext *s = NULL;
3148
3149     if (!st) {
3150         av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3151         exit_program(1);
3152     }
3153
3154     output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3155                                 nb_output_streams + 1);
3156     ost = &output_streams[nb_output_streams - 1];
3157     ost->file_index = nb_output_files;
3158     ost->index = idx;
3159     ost->st    = st;
3160     st->codec->codec_type = type;
3161     ost->enc = choose_codec(o, oc, st, type);
3162     if (ost->enc) {
3163         ost->opts  = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3164     }
3165
3166     avcodec_get_context_defaults3(st->codec, ost->enc);
3167     st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3168
3169     MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3170     if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3171         do  {
3172             buf = get_line(s);
3173             if (!buf[0] || buf[0] == '#') {
3174                 av_free(buf);
3175                 continue;
3176             }
3177             if (!(arg = strchr(buf, '='))) {
3178                 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3179                 exit_program(1);
3180             }
3181             *arg++ = 0;
3182             av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3183             av_free(buf);
3184         } while (!s->eof_reached);
3185         avio_close(s);
3186     }
3187     if (ret) {
3188         av_log(NULL, AV_LOG_FATAL,
3189                "Preset %s specified for stream %d:%d, but could not be opened.\n",
3190                preset, ost->file_index, ost->index);
3191         exit_program(1);
3192     }
3193
3194     MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3195     ost->max_frames = max_frames;
3196
3197     MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3198     while (bsf) {
3199         if (next = strchr(bsf, ','))
3200             *next++ = 0;
3201         if (!(bsfc = av_bitstream_filter_init(bsf))) {
3202             av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3203             exit_program(1);
3204         }
3205         if (bsfc_prev)
3206             bsfc_prev->next = bsfc;
3207         else
3208             ost->bitstream_filters = bsfc;
3209
3210         bsfc_prev = bsfc;
3211         bsf       = next;
3212     }
3213
3214     MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3215     if (codec_tag) {
3216         uint32_t tag = strtol(codec_tag, &next, 0);
3217         if (*next)
3218             tag = AV_RL32(codec_tag);
3219         st->codec->codec_tag = tag;
3220     }
3221
3222     MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3223     if (qscale >= 0 || same_quant) {
3224         st->codec->flags |= CODEC_FLAG_QSCALE;
3225         st->codec->global_quality = FF_QP2LAMBDA * qscale;
3226     }
3227
3228     if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3229         st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3230
3231     av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3232     return ost;
3233 }
3234
3235 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3236 {
3237     int i;
3238     const char *p = str;
3239     for(i = 0;; i++) {
3240         dest[i] = atoi(p);
3241         if(i == 63)
3242             break;
3243         p = strchr(p, ',');
3244         if(!p) {
3245             av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3246             exit_program(1);
3247         }
3248         p++;
3249     }
3250 }
3251
3252 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3253 {
3254     AVStream *st;
3255     OutputStream *ost;
3256     AVCodecContext *video_enc;
3257
3258     ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3259     st  = ost->st;
3260     video_enc = st->codec;
3261
3262     if (!st->stream_copy) {
3263         const char *p = NULL;
3264         char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3265         char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3266         char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3267         int i, force_fps = 0, top_field_first = -1;
3268
3269         MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3270         if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3271             av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3272             exit_program(1);
3273         }
3274
3275         MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3276         if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3277             av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3278             exit_program(1);
3279         }
3280
3281         MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3282         if (frame_aspect_ratio)
3283             ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3284
3285         MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3286         if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3287             av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3288             exit_program(1);
3289         }
3290         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3291
3292         MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3293         if (intra_matrix) {
3294             if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3295                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3296                 exit_program(1);
3297             }
3298             parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3299         }
3300         MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3301         if (inter_matrix) {
3302             if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3303                 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3304                 exit_program(1);
3305             }
3306             parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3307         }
3308
3309         MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3310         for(i=0; p; i++){
3311             int start, end, q;
3312             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3313             if(e!=3){
3314                 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3315                 exit_program(1);
3316             }
3317             video_enc->rc_override=
3318                 av_realloc(video_enc->rc_override,
3319                            sizeof(RcOverride)*(i+1));
3320             video_enc->rc_override[i].start_frame= start;
3321             video_enc->rc_override[i].end_frame  = end;
3322             if(q>0){
3323                 video_enc->rc_override[i].qscale= q;
3324                 video_enc->rc_override[i].quality_factor= 1.0;
3325             }
3326             else{
3327                 video_enc->rc_override[i].qscale= 0;
3328                 video_enc->rc_override[i].quality_factor= -q/100.0;
3329             }
3330             p= strchr(p, '/');
3331             if(p) p++;
3332         }
3333         video_enc->rc_override_count=i;
3334         if (!video_enc->rc_initial_buffer_occupancy)
3335             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3336         video_enc->intra_dc_precision= intra_dc_precision - 8;
3337
3338         /* two pass mode */
3339         if (do_pass) {
3340             if (do_pass == 1) {
3341                 video_enc->flags |= CODEC_FLAG_PASS1;
3342             } else {
3343                 video_enc->flags |= CODEC_FLAG_PASS2;
3344             }
3345         }
3346
3347         MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3348         if (forced_key_frames)
3349             parse_forced_key_frames(forced_key_frames, ost, video_enc);
3350
3351         MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3352         ost->force_fps = force_fps;
3353
3354         MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3355         ost->top_field_first = top_field_first;
3356
3357 #if CONFIG_AVFILTER
3358         MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3359         if (filters)
3360             ost->avfilter = av_strdup(filters);
3361 #endif
3362     }
3363
3364     return ost;
3365 }
3366
3367 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3368 {
3369     AVStream *st;
3370     OutputStream *ost;
3371     AVCodecContext *audio_enc;
3372
3373     ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3374     st  = ost->st;
3375
3376     audio_enc = st->codec;
3377     audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3378
3379     if (!st->stream_copy) {
3380         char *sample_fmt = NULL;
3381
3382         MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3383
3384         MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3385         if (sample_fmt &&
3386             (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3387             av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3388             exit_program(1);
3389         }
3390
3391         MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3392     }
3393
3394     return ost;
3395 }
3396
3397 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3398 {
3399     AVStream *st;
3400     OutputStream *ost;
3401
3402     ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3403     st  = ost->st;
3404     if (!st->stream_copy) {
3405         av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3406         exit_program(1);
3407     }
3408
3409     return ost;
3410 }
3411
3412 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3413 {
3414     OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3415     ost->st->stream_copy = 1;
3416     return ost;
3417 }
3418
3419 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3420 {
3421     AVStream *st;
3422     OutputStream *ost;
3423     AVCodecContext *subtitle_enc;
3424
3425     ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3426     st  = ost->st;
3427     subtitle_enc = st->codec;
3428
3429     subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3430
3431     return ost;
3432 }
3433
3434 /* arg format is "output-stream-index:streamid-value". */
3435 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3436 {
3437     int idx;
3438     char *p;
3439     char idx_str[16];
3440
3441     av_strlcpy(idx_str, arg, sizeof(idx_str));
3442     p = strchr(idx_str, ':');
3443     if (!p) {
3444         av_log(NULL, AV_LOG_FATAL,
3445                "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3446                arg, opt);
3447         exit_program(1);
3448     }
3449     *p++ = '\0';
3450     idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3451     o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3452     o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3453     return 0;
3454 }
3455
3456 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3457 {
3458     AVFormatContext *is = ifile->ctx;
3459     AVFormatContext *os = ofile->ctx;
3460     int i;
3461
3462     for (i = 0; i < is->nb_chapters; i++) {
3463         AVChapter *in_ch = is->chapters[i], *out_ch;
3464         int64_t ts_off   = av_rescale_q(ofile->start_time - ifile->ts_offset,
3465                                       AV_TIME_BASE_Q, in_ch->time_base);
3466         int64_t rt       = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3467                            av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3468
3469
3470         if (in_ch->end < ts_off)
3471             continue;
3472         if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3473             break;
3474
3475         out_ch = av_mallocz(sizeof(AVChapter));
3476         if (!out_ch)
3477             return AVERROR(ENOMEM);
3478
3479         out_ch->id        = in_ch->id;
3480         out_ch->time_base = in_ch->time_base;
3481         out_ch->start     = FFMAX(0,  in_ch->start - ts_off);
3482         out_ch->end       = FFMIN(rt, in_ch->end   - ts_off);
3483
3484         if (copy_metadata)
3485             av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3486
3487         os->nb_chapters++;
3488         os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3489         if (!os->chapters)
3490             return AVERROR(ENOMEM);
3491         os->chapters[os->nb_chapters - 1] = out_ch;
3492     }
3493     return 0;
3494 }
3495
3496 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3497 {
3498     int i, err;
3499     AVFormatContext *ic = NULL;
3500
3501     err = avformat_open_input(&ic, filename, NULL, NULL);
3502     if (err < 0)
3503         return err;
3504     /* copy stream format */
3505     for(i=0;i<ic->nb_streams;i++) {
3506         AVStream *st;
3507         OutputStream *ost;
3508         AVCodec *codec;
3509
3510         codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3511         ost   = new_output_stream(o, s, codec->type);
3512         st    = ost->st;
3513
3514         // FIXME: a more elegant solution is needed
3515         memcpy(st, ic->streams[i], sizeof(AVStream));
3516         st->info = av_malloc(sizeof(*st->info));
3517         memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3518         avcodec_copy_context(st->codec, ic->streams[i]->codec);
3519
3520         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3521             choose_sample_fmt(st, codec);
3522         else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3523             choose_pixel_fmt(st, codec);
3524     }
3525
3526     av_close_input_file(ic);
3527     return 0;
3528 }
3529
3530 static void opt_output_file(void *optctx, const char *filename)
3531 {
3532     OptionsContext *o = optctx;
3533     AVFormatContext *oc;
3534     int i, err;
3535     AVOutputFormat *file_oformat;
3536     OutputStream *ost;
3537     InputStream  *ist;
3538
3539     if (!strcmp(filename, "-"))
3540         filename = "pipe:";
3541
3542     err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3543     if (!oc) {
3544         print_error(filename, err);
3545         exit_program(1);
3546     }
3547
3548     file_oformat= oc->oformat;
3549
3550     if (!strcmp(file_oformat->name, "ffm") &&
3551         av_strstart(filename, "http:", NULL)) {
3552         /* special case for files sent to ffserver: we get the stream
3553            parameters from ffserver */
3554         int err = read_ffserver_streams(o, oc, filename);
3555         if (err < 0) {
3556             print_error(filename, err);
3557             exit_program(1);
3558         }
3559     } else if (!o->nb_stream_maps) {
3560         /* pick the "best" stream of each type */
3561 #define NEW_STREAM(type, index)\
3562         if (index >= 0) {\
3563             ost = new_ ## type ## _stream(o, oc);\
3564             ost->source_index = index;\
3565             ost->sync_ist     = &input_streams[index];\
3566             input_streams[index].discard = 0;\
3567         }
3568
3569         /* video: highest resolution */
3570         if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3571             int area = 0, idx = -1;
3572             for (i = 0; i < nb_input_streams; i++) {
3573                 ist = &input_streams[i];
3574                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3575                     ist->st->codec->width * ist->st->codec->height > area) {
3576                     area = ist->st->codec->width * ist->st->codec->height;
3577                     idx = i;
3578                 }
3579             }
3580             NEW_STREAM(video, idx);
3581         }
3582
3583         /* audio: most channels */
3584         if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3585             int channels = 0, idx = -1;
3586             for (i = 0; i < nb_input_streams; i++) {
3587                 ist = &input_streams[i];
3588                 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3589                     ist->st->codec->channels > channels) {
3590                     channels = ist->st->codec->channels;
3591                     idx = i;
3592                 }
3593             }
3594             NEW_STREAM(audio, idx);
3595         }
3596
3597         /* subtitles: pick first */
3598         if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3599             for (i = 0; i < nb_input_streams; i++)
3600                 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3601                     NEW_STREAM(subtitle, i);
3602                     break;
3603                 }
3604         }
3605         /* do something with data? */
3606     } else {
3607         for (i = 0; i < o->nb_stream_maps; i++) {
3608             StreamMap *map = &o->stream_maps[i];
3609
3610             if (map->disabled)
3611                 continue;
3612
3613             ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3614             switch (ist->st->codec->codec_type) {
3615             case AVMEDIA_TYPE_VIDEO:    ost = new_video_stream(o, oc);    break;
3616             case AVMEDIA_TYPE_AUDIO:    ost = new_audio_stream(o, oc);    break;
3617             case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3618             case AVMEDIA_TYPE_DATA:     ost = new_data_stream(o, oc);     break;
3619             case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3620             default:
3621                 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3622                        map->file_index, map->stream_index);
3623                 exit_program(1);
3624             }
3625
3626             ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3627             ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3628                                            map->sync_stream_index];
3629             ist->discard = 0;
3630         }
3631     }
3632
3633     output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3634     output_files[nb_output_files - 1].ctx       = oc;
3635     output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3636     output_files[nb_output_files - 1].recording_time = o->recording_time;
3637     output_files[nb_output_files - 1].start_time     = o->start_time;
3638     output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3639     av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3640
3641     /* check filename in case of an image number is expected */
3642     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3643         if (!av_filename_number_test(oc->filename)) {
3644             print_error(oc->filename, AVERROR(EINVAL));
3645             exit_program(1);
3646         }
3647     }
3648
3649     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3650         /* test if it already exists to avoid loosing precious files */
3651         if (!file_overwrite &&
3652             (strchr(filename, ':') == NULL ||
3653              filename[1] == ':' ||
3654              av_strstart(filename, "file:", NULL))) {
3655             if (avio_check(filename, 0) == 0) {
3656                 if (!using_stdin) {
3657                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3658                     fflush(stderr);
3659                     if (!read_yesno()) {
3660                         fprintf(stderr, "Not overwriting - exiting\n");
3661                         exit_program(1);
3662                     }
3663                 }
3664                 else {
3665                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3666                     exit_program(1);
3667                 }
3668             }
3669         }
3670
3671         /* open the file */
3672         if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3673             print_error(filename, err);
3674             exit_program(1);
3675         }
3676     }
3677
3678     oc->preload   = (int)(o->mux_preload   * AV_TIME_BASE);
3679     oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3680
3681     /* copy chapters */
3682     if (o->chapters_input_file >= nb_input_files) {
3683         if (o->chapters_input_file == INT_MAX) {
3684             /* copy chapters from the first input file that has them*/
3685             o->chapters_input_file = -1;
3686             for (i = 0; i < nb_input_files; i++)
3687                 if (input_files[i].ctx->nb_chapters) {
3688                     o->chapters_input_file = i;
3689                     break;
3690                 }
3691         } else {
3692             av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3693                    o->chapters_input_file);
3694             exit_program(1);
3695         }
3696     }
3697     if (o->chapters_input_file >= 0)
3698         copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3699                       !o->metadata_chapters_manual);
3700
3701     /* copy metadata */
3702     for (i = 0; i < o->nb_meta_data_maps; i++) {
3703         AVFormatContext *files[2];
3704         AVDictionary    **meta[2];
3705         int j;
3706
3707 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3708         if ((index) < 0 || (index) >= (nb_elems)) {\
3709             av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3710                      (desc), (index));\
3711             exit_program(1);\
3712         }
3713
3714         int in_file_index = o->meta_data_maps[i][1].file;
3715         if (in_file_index < 0)
3716             continue;
3717         METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3718
3719         files[0] = oc;
3720         files[1] = input_files[in_file_index].ctx;
3721
3722         for (j = 0; j < 2; j++) {
3723             MetadataMap *map = &o->meta_data_maps[i][j];
3724
3725             switch (map->type) {
3726             case 'g':
3727                 meta[j] = &files[j]->metadata;
3728                 break;
3729             case 's':
3730                 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3731                 meta[j] = &files[j]->streams[map->index]->metadata;
3732                 break;
3733             case 'c':
3734                 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3735                 meta[j] = &files[j]->chapters[map->index]->metadata;
3736                 break;
3737             case 'p':
3738                 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3739                 meta[j] = &files[j]->programs[map->index]->metadata;
3740                 break;
3741             }
3742         }
3743
3744         av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3745     }
3746
3747     /* copy global metadata by default */
3748     if (!o->metadata_global_manual && nb_input_files)
3749         av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3750                      AV_DICT_DONT_OVERWRITE);
3751     if (!o->metadata_streams_manual)
3752         for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3753             InputStream *ist = &input_streams[output_streams[i].source_index];
3754             av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3755         }
3756
3757     /* process manually set metadata */
3758     for (i = 0; i < o->nb_metadata; i++) {
3759         AVDictionary **m;
3760         char type, *val;
3761         int index = 0;
3762
3763         val = strchr(o->metadata[i].u.str, '=');
3764         if (!val) {
3765             av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3766                    o->metadata[i].u.str);
3767             exit_program(1);
3768         }
3769         *val++ = 0;
3770
3771         parse_meta_type(o->metadata[i].specifier, &type, &index);
3772         switch (type) {
3773         case 'g':
3774             m = &oc->metadata;
3775             break;
3776         case 's':
3777             if (index < 0 || index >= oc->nb_streams) {
3778                 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3779                 exit_program(1);
3780             }
3781             m = &oc->streams[index]->metadata;
3782             break;
3783         case 'c':
3784             if (index < 0 || index >= oc->nb_chapters) {
3785                 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3786                 exit_program(1);
3787             }
3788             m = &oc->chapters[index]->metadata;
3789             break;
3790         default:
3791             av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3792             exit_program(1);
3793         }
3794
3795         av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3796     }
3797
3798     reset_options(o);
3799 }
3800
3801 /* same option as mencoder */
3802 static int opt_pass(const char *opt, const char *arg)
3803 {
3804     do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3805     return 0;
3806 }
3807
3808 static int64_t getutime(void)
3809 {
3810 #if HAVE_GETRUSAGE
3811     struct rusage rusage;
3812
3813     getrusage(RUSAGE_SELF, &rusage);
3814     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3815 #elif HAVE_GETPROCESSTIMES
3816     HANDLE proc;
3817     FILETIME c, e, k, u;
3818     proc = GetCurrentProcess();
3819     GetProcessTimes(proc, &c, &e, &k, &u);
3820     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3821 #else
3822     return av_gettime();
3823 #endif
3824 }
3825
3826 static int64_t getmaxrss(void)
3827 {
3828 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3829     struct rusage rusage;
3830     getrusage(RUSAGE_SELF, &rusage);
3831     return (int64_t)rusage.ru_maxrss * 1024;
3832 #elif HAVE_GETPROCESSMEMORYINFO
3833     HANDLE proc;
3834     PROCESS_MEMORY_COUNTERS memcounters;
3835     proc = GetCurrentProcess();
3836     memcounters.cb = sizeof(memcounters);
3837     GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3838     return memcounters.PeakPagefileUsage;
3839 #else
3840     return 0;
3841 #endif
3842 }
3843
3844 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3845 {
3846     return parse_option(o, "q:a", arg, options);
3847 }
3848
3849 static void show_usage(void)
3850 {
3851     printf("Hyper fast Audio and Video encoder\n");
3852     printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3853     printf("\n");
3854 }
3855
3856 static int opt_help(const char *opt, const char *arg)
3857 {
3858     int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3859     av_log_set_callback(log_callback_help);
3860     show_usage();
3861     show_help_options(options, "Main options:\n",
3862                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3863     show_help_options(options, "\nAdvanced options:\n",
3864                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3865                       OPT_EXPERT);
3866     show_help_options(options, "\nVideo options:\n",
3867                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3868                       OPT_VIDEO);
3869     show_help_options(options, "\nAdvanced Video options:\n",
3870                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3871                       OPT_VIDEO | OPT_EXPERT);
3872     show_help_options(options, "\nAudio options:\n",
3873                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3874                       OPT_AUDIO);
3875     show_help_options(options, "\nAdvanced Audio options:\n",
3876                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877                       OPT_AUDIO | OPT_EXPERT);
3878     show_help_options(options, "\nSubtitle options:\n",
3879                       OPT_SUBTITLE | OPT_GRAB,
3880                       OPT_SUBTITLE);
3881     show_help_options(options, "\nAudio/Video grab options:\n",
3882                       OPT_GRAB,
3883                       OPT_GRAB);
3884     printf("\n");
3885     show_help_children(avcodec_get_class(), flags);
3886     show_help_children(avformat_get_class(), flags);
3887     show_help_children(sws_get_class(), flags);
3888
3889     return 0;
3890 }
3891
3892 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3893 {
3894     enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3895     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3896
3897     if(!strncmp(arg, "pal-", 4)) {
3898         norm = PAL;
3899         arg += 4;
3900     } else if(!strncmp(arg, "ntsc-", 5)) {
3901         norm = NTSC;
3902         arg += 5;
3903     } else if(!strncmp(arg, "film-", 5)) {
3904         norm = FILM;
3905         arg += 5;
3906     } else {
3907         /* Try to determine PAL/NTSC by peeking in the input files */
3908         if(nb_input_files) {
3909             int i, j, fr;
3910             for (j = 0; j < nb_input_files; j++) {
3911                 for (i = 0; i < input_files[j].nb_streams; i++) {
3912                     AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3913                     if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3914                         continue;
3915                     fr = c->time_base.den * 1000 / c->time_base.num;
3916                     if(fr == 25000) {
3917                         norm = PAL;
3918                         break;
3919                     } else if((fr == 29970) || (fr == 23976)) {
3920                         norm = NTSC;
3921                         break;
3922                     }
3923                 }
3924                 if(norm != UNKNOWN)
3925                     break;
3926             }
3927         }
3928         if (norm != UNKNOWN)
3929             av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3930     }
3931
3932     if(norm == UNKNOWN) {
3933         av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3934         av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3935         av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3936         exit_program(1);
3937     }
3938
3939     if(!strcmp(arg, "vcd")) {
3940         opt_video_codec(o, "c:v", "mpeg1video");
3941         opt_audio_codec(o, "c:a", "mp2");
3942         parse_option(o, "f", "vcd", options);
3943
3944         parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3945         parse_option(o, "r", frame_rates[norm], options);
3946         opt_default("g", norm == PAL ? "15" : "18");
3947
3948         opt_default("b", "1150000");
3949         opt_default("maxrate", "1150000");
3950         opt_default("minrate", "1150000");
3951         opt_default("bufsize", "327680"); // 40*1024*8;
3952
3953         opt_default("b:a", "224000");
3954         parse_option(o, "ar", "44100", options);
3955         parse_option(o, "ac", "2", options);
3956
3957         opt_default("packetsize", "2324");
3958         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3959
3960         /* We have to offset the PTS, so that it is consistent with the SCR.
3961            SCR starts at 36000, but the first two packs contain only padding
3962            and the first pack from the other stream, respectively, may also have
3963            been written before.
3964            So the real data starts at SCR 36000+3*1200. */
3965         o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3966     } else if(!strcmp(arg, "svcd")) {
3967
3968         opt_video_codec(o, "c:v", "mpeg2video");
3969         opt_audio_codec(o, "c:a", "mp2");
3970         parse_option(o, "f", "svcd", options);
3971
3972         parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3973         parse_option(o, "r", frame_rates[norm], options);
3974         opt_default("g", norm == PAL ? "15" : "18");
3975
3976         opt_default("b", "2040000");
3977         opt_default("maxrate", "2516000");
3978         opt_default("minrate", "0"); //1145000;
3979         opt_default("bufsize", "1835008"); //224*1024*8;
3980         opt_default("flags", "+scan_offset");
3981
3982
3983         opt_default("b:a", "224000");
3984         parse_option(o, "ar", "44100", options);
3985
3986         opt_default("packetsize", "2324");
3987
3988     } else if(!strcmp(arg, "dvd")) {
3989
3990         opt_video_codec(o, "c:v", "mpeg2video");
3991         opt_audio_codec(o, "c:a", "ac3");
3992         parse_option(o, "f", "dvd", options);
3993
3994         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3995         parse_option(o, "r", frame_rates[norm], options);
3996         opt_default("g", norm == PAL ? "15" : "18");
3997
3998         opt_default("b", "6000000");
3999         opt_default("maxrate", "9000000");
4000         opt_default("minrate", "0"); //1500000;
4001         opt_default("bufsize", "1835008"); //224*1024*8;
4002
4003         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4004         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4005
4006         opt_default("b:a", "448000");
4007         parse_option(o, "ar", "48000", options);
4008
4009     } else if(!strncmp(arg, "dv", 2)) {
4010
4011         parse_option(o, "f", "dv", options);
4012
4013         parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4014         parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4015                           norm == PAL ? "yuv420p" : "yuv411p", options);
4016         parse_option(o, "r", frame_rates[norm], options);
4017
4018         parse_option(o, "ar", "48000", options);
4019         parse_option(o, "ac", "2", options);
4020
4021     } else {
4022         av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4023         return AVERROR(EINVAL);
4024     }
4025     return 0;
4026 }
4027
4028 static int opt_vstats_file(const char *opt, const char *arg)
4029 {
4030     av_free (vstats_filename);
4031     vstats_filename=av_strdup (arg);
4032     return 0;
4033 }
4034
4035 static int opt_vstats(const char *opt, const char *arg)
4036 {
4037     char filename[40];
4038     time_t today2 = time(NULL);
4039     struct tm *today = localtime(&today2);
4040
4041     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4042              today->tm_sec);
4043     return opt_vstats_file(opt, filename);
4044 }
4045
4046 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4047 {
4048     return parse_option(o, "frames:v", arg, options);
4049 }
4050
4051 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4052 {
4053     return parse_option(o, "frames:a", arg, options);
4054 }
4055
4056 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4057 {
4058     return parse_option(o, "frames:d", arg, options);
4059 }
4060
4061 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4062 {
4063 }
4064
4065 static int opt_passlogfile(const char *opt, const char *arg)
4066 {
4067     pass_logfilename_prefix = arg;
4068 #if CONFIG_LIBX264_ENCODER
4069     return opt_default("passlogfile", arg);
4070 #else
4071     return 0;
4072 #endif
4073 }
4074
4075 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4076 {
4077     return parse_option(o, "tag:v", arg, options);
4078 }
4079
4080 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4081 {
4082     return parse_option(o, "tag:a", arg, options);
4083 }
4084
4085 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4086 {
4087     return parse_option(o, "tag:s", arg, options);
4088 }
4089
4090 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4091 {
4092     return parse_option(o, "filter:v", arg, options);
4093 }
4094
4095 #define OFFSET(x) offsetof(OptionsContext, x)
4096 static const OptionDef options[] = {
4097     /* main options */
4098 #include "cmdutils_common_opts.h"
4099     { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4100     { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4101     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4102     { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4103     { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4104     { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4105     { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4106     { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4107       "outfile[,metadata]:infile[,metadata]" },
4108     { "map_chapters",  OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)},  "set chapters mapping", "input_file_index" },
4109     { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4110     { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4111     { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4112     { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4113     { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4114     { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4115     { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4116     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4117       "add timings for benchmarking" },
4118     { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4119     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4120       "dump each input packet" },
4121     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4122       "when dumping packets, also dump the payload" },
4123     { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4124     { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4125     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4126     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4127     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4128     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4129     { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4130     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4131     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4132     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4133     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4134     { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4135     { "tag",   OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4136     { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4137     { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4138 #if CONFIG_AVFILTER
4139     { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4140 #endif
4141     { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4142
4143     /* video options */
4144     { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4145     { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4146     { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4147     { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4148     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4149     { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4150     { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4151     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4152     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4153     { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4154     { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4155       "use same quantizer as source (implies VBR)" },
4156     { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4157     { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4158     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4159       "deinterlace pictures" },
4160     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4161     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4162 #if CONFIG_AVFILTER
4163     { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4164 #endif
4165     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4166     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4167     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4168     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4169     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4170     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4171     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4172     { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4173     { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4174
4175     /* audio options */
4176     { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4177     { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4178     { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4179     { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4180     { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4181     { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4182     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4183     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4184     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4185
4186     /* subtitle options */
4187     { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4188     { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4189     { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4190
4191     /* grab options */
4192     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4193
4194     /* muxer options */
4195     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT   | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4196     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)},   "set the initial demux-decode delay", "seconds" },
4197
4198     { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4199
4200     /* data codec support */
4201     { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4202
4203     { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4204     { NULL, },
4205 };
4206
4207 int main(int argc, char **argv)
4208 {
4209     OptionsContext o = { 0 };
4210     int64_t ti;
4211
4212     reset_options(&o);
4213
4214     av_log_set_flags(AV_LOG_SKIP_REPEATED);
4215     parse_loglevel(argc, argv, options);
4216
4217     if(argc>1 && !strcmp(argv[1], "-d")){
4218         run_as_daemon=1;
4219         av_log_set_callback(log_callback_null);
4220         argc--;
4221         argv++;
4222     }
4223
4224     avcodec_register_all();
4225 #if CONFIG_AVDEVICE
4226     avdevice_register_all();
4227 #endif
4228 #if CONFIG_AVFILTER
4229     avfilter_register_all();
4230 #endif
4231     av_register_all();
4232
4233 #if HAVE_ISATTY
4234     if(isatty(STDIN_FILENO))
4235         avio_set_interrupt_cb(decode_interrupt_cb);
4236 #endif
4237
4238     show_banner();
4239
4240     /* parse options */
4241     parse_options(&o, argc, argv, options, opt_output_file);
4242
4243     if(nb_output_files <= 0 && nb_input_files == 0) {
4244         show_usage();
4245         av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4246         exit_program(1);
4247     }
4248
4249     /* file converter / grab */
4250     if (nb_output_files <= 0) {
4251         fprintf(stderr, "At least one output file must be specified\n");
4252         exit_program(1);
4253     }
4254
4255     if (nb_input_files == 0) {
4256         av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4257         exit_program(1);
4258     }
4259
4260     ti = getutime();
4261     if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4262         exit_program(1);
4263     ti = getutime() - ti;
4264     if (do_benchmark) {
4265         int maxrss = getmaxrss() / 1024;
4266         printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4267     }
4268
4269     exit_program(0);
4270     return 0;
4271 }