ffmpeg.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 /* needed for usleep() */
  23 #define _XOPEN_SOURCE 600
  24
  25 #include "config.h"
  26 #include <ctype.h>
  27 #include <string.h>
  28 #include <math.h>
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <signal.h>
  32 #include <limits.h>
  33 #include <unistd.h>
  34 #include "libavformat/avformat.h"
  35 #include "libavdevice/avdevice.h"
  36 #include "libswscale/swscale.h"
  37 #include "libavcodec/opt.h"
  38 #include "libavcodec/audioconvert.h"
  39 #include "libavutil/fifo.h"
  40 #include "libavutil/avstring.h"
  41 #include "libavformat/os_support.h"
  42
  43 #if HAVE_SYS_RESOURCE_H
  44 #include <sys/types.h>
  45 #include <sys/resource.h>
  46 #elif HAVE_GETPROCESSTIMES
  47 #include <windows.h>
  48 #endif
  49
  50 #if HAVE_SYS_SELECT_H
  51 #include <sys/select.h>
  52 #endif
  53
  54 #if HAVE_TERMIOS_H
  55 #include <fcntl.h>
  56 #include <sys/ioctl.h>
  57 #include <sys/time.h>
  58 #include <termios.h>
  59 #elif HAVE_CONIO_H
  60 #include <conio.h>
  61 #endif
  62 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
  63 #include <time.h>
  64
  65 #include "cmdutils.h"
  66
  67 #undef NDEBUG
  68 #include <assert.h>
  69
  70 #undef exit
  71
  72 const char program_name[] = "FFmpeg";
  73 const int program_birth_year = 2000;
  74
  75 /* select an input stream for an output stream */
  76 typedef struct AVStreamMap {
  77     int file_index;
  78     int stream_index;
  79     int sync_file_index;
  80     int sync_stream_index;
  81 } AVStreamMap;
  82
  83 /** select an input file for an output file */
  84 typedef struct AVMetaDataMap {
  85     int out_file;
  86     int in_file;
  87 } AVMetaDataMap;
  88
  89 static const OptionDef options[];
  90
  91 #define MAX_FILES 20
  92
  93 static AVFormatContext *input_files[MAX_FILES];
  94 static int64_t input_files_ts_offset[MAX_FILES];
  95 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
  96 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
  97 static int nb_input_files = 0;
  98 static int nb_icodecs;
  99
 100 static AVFormatContext *output_files[MAX_FILES];
 101 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
 102 static int nb_output_files = 0;
 103 static int nb_ocodecs;
 104
 105 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
 106 static int nb_stream_maps;
 107
 108 static AVMetaDataMap meta_data_maps[MAX_FILES];
 109 static int nb_meta_data_maps;
 110
 111 static AVInputFormat *file_iformat;
 112 static AVOutputFormat *file_oformat;
 113 static int frame_width  = 0;
 114 static int frame_height = 0;
 115 static float frame_aspect_ratio = 0;
 116 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
 117 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
 118 static int frame_padtop  = 0;
 119 static int frame_padbottom = 0;
 120 static int frame_padleft  = 0;
 121 static int frame_padright = 0;
 122 static int padcolor[3] = {16,128,128}; /* default to black */
 123 static int frame_topBand  = 0;
 124 static int frame_bottomBand = 0;
 125 static int frame_leftBand  = 0;
 126 static int frame_rightBand = 0;
 127 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
 128 static AVRational frame_rate;
 129 static float video_qscale = 0;
 130 static uint16_t *intra_matrix = NULL;
 131 static uint16_t *inter_matrix = NULL;
 132 #if 0 //experimental, (can be removed)
 133 static float video_rc_qsquish=1.0;
 134 static float video_rc_qmod_amp=0;
 135 static int video_rc_qmod_freq=0;
 136 #endif
 137 static const char *video_rc_override_string=NULL;
 138 static int video_disable = 0;
 139 static int video_discard = 0;
 140 static char *video_codec_name = NULL;
 141 static int video_codec_tag = 0;
 142 static int same_quality = 0;
 143 static int do_deinterlace = 0;
 144 static int top_field_first = -1;
 145 static int me_threshold = 0;
 146 static int intra_dc_precision = 8;
 147 static int loop_input = 0;
 148 static int loop_output = AVFMT_NOOUTPUTLOOP;
 149 static int qp_hist = 0;
 150
 151 static int intra_only = 0;
 152 static int audio_sample_rate = 44100;
 153 static int64_t channel_layout = 0;
 154 #define QSCALE_NONE -99999
 155 static float audio_qscale = QSCALE_NONE;
 156 static int audio_disable = 0;
 157 static int audio_channels = 1;
 158 static char  *audio_codec_name = NULL;
 159 static int audio_codec_tag = 0;
 160 static char *audio_language = NULL;
 161
 162 static int subtitle_disable = 0;
 163 static char *subtitle_codec_name = NULL;
 164 static char *subtitle_language = NULL;
 165
 166 static float mux_preload= 0.5;
 167 static float mux_max_delay= 0.7;
 168
 169 static int64_t recording_time = INT64_MAX;
 170 static int64_t start_time = 0;
 171 static int64_t rec_timestamp = 0;
 172 static int64_t input_ts_offset = 0;
 173 static int file_overwrite = 0;
 174 static int metadata_count;
 175 static AVMetadataTag *metadata;
 176 static int do_benchmark = 0;
 177 static int do_hex_dump = 0;
 178 static int do_pkt_dump = 0;
 179 static int do_psnr = 0;
 180 static int do_pass = 0;
 181 static char *pass_logfilename_prefix = NULL;
 182 static int audio_stream_copy = 0;
 183 static int video_stream_copy = 0;
 184 static int subtitle_stream_copy = 0;
 185 static int video_sync_method= -1;
 186 static int audio_sync_method= 0;
 187 static float audio_drift_threshold= 0.1;
 188 static int copy_ts= 0;
 189 static int opt_shortest = 0;
 190 static int video_global_header = 0;
 191 static char *vstats_filename;
 192 static FILE *vstats_file;
 193 static int opt_programid = 0;
 194 static int copy_initial_nonkeyframes = 0;
 195
 196 static int rate_emu = 0;
 197
 198 static int  video_channel = 0;
 199 static char *video_standard;
 200
 201 static int audio_volume = 256;
 202
 203 static int exit_on_error = 0;
 204 static int using_stdin = 0;
 205 static int verbose = 1;
 206 static int thread_count= 1;
 207 static int q_pressed = 0;
 208 static int64_t video_size = 0;
 209 static int64_t audio_size = 0;
 210 static int64_t extra_size = 0;
 211 static int nb_frames_dup = 0;
 212 static int nb_frames_drop = 0;
 213 static int input_sync;
 214 static uint64_t limit_filesize = 0;
 215 static int force_fps = 0;
 216
 217 static int pgmyuv_compatibility_hack=0;
 218 static float dts_delta_threshold = 10;
 219
 220 static unsigned int sws_flags = SWS_BICUBIC;
 221
 222 static int64_t timer_start;
 223
 224 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
 225 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
 226 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
 227 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
 228
 229 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
 230
 231 struct AVInputStream;
 232
 233 typedef struct AVOutputStream {
 234     int file_index;          /* file index */
 235     int index;               /* stream index in the output file */
 236     int source_index;        /* AVInputStream index */
 237     AVStream *st;            /* stream in the output file */
 238     int encoding_needed;     /* true if encoding needed for this stream */
 239     int frame_number;
 240     /* input pts and corresponding output pts
 241        for A/V sync */
 242     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
 243     struct AVInputStream *sync_ist; /* input stream to sync against */
 244     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
 245     /* video only */
 246     int video_resample;
 247     AVFrame pict_tmp;      /* temporary image for resampling */
 248     struct SwsContext *img_resample_ctx; /* for image resampling */
 249     int resample_height;
 250
 251     int video_crop;
 252     int topBand;             /* cropping area sizes */
 253     int leftBand;
 254
 255     int video_pad;
 256     int padtop;              /* padding area sizes */
 257     int padbottom;
 258     int padleft;
 259     int padright;
 260
 261     /* audio only */
 262     int audio_resample;
 263     ReSampleContext *resample; /* for audio resampling */
 264     int reformat_pair;
 265     AVAudioConvert *reformat_ctx;
 266     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
 267     FILE *logfile;
 268 } AVOutputStream;
 269
 270 typedef struct AVInputStream {
 271     int file_index;
 272     int index;
 273     AVStream *st;
 274     int discard;             /* true if stream data should be discarded */
 275     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
 276     int64_t sample_index;      /* current sample */
 277
 278     int64_t       start;     /* time when read started */
 279     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
 280                                 is not defined */
 281     int64_t       pts;       /* current pts */
 282     int is_start;            /* is 1 at the start and after a discontinuity */
 283 } AVInputStream;
 284
 285 typedef struct AVInputFile {
 286     int eof_reached;      /* true if eof reached */
 287     int ist_index;        /* index of first stream in ist_table */
 288     int buffer_size;      /* current total buffer size */
 289     int nb_streams;       /* nb streams we are aware of */
 290 } AVInputFile;
 291
 292 #if HAVE_TERMIOS_H
 293
 294 /* init terminal so that we can grab keys */
 295 static struct termios oldtty;
 296 #endif
 297
 298 static void term_exit(void)
 299 {
 300 #if HAVE_TERMIOS_H
 301     tcsetattr (0, TCSANOW, &oldtty);
 302 #endif
 303 }
 304
 305 static volatile sig_atomic_t received_sigterm = 0;
 306
 307 static void
 308 sigterm_handler(int sig)
 309 {
 310     received_sigterm = sig;
 311     term_exit();
 312 }
 313
 314 static void term_init(void)
 315 {
 316 #if HAVE_TERMIOS_H
 317     struct termios tty;
 318
 319     tcgetattr (0, &tty);
 320     oldtty = tty;
 321
 322     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
 323                           |INLCR|IGNCR|ICRNL|IXON);
 324     tty.c_oflag |= OPOST;
 325     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
 326     tty.c_cflag &= ~(CSIZE|PARENB);
 327     tty.c_cflag |= CS8;
 328     tty.c_cc[VMIN] = 1;
 329     tty.c_cc[VTIME] = 0;
 330
 331     tcsetattr (0, TCSANOW, &tty);
 332     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
 333 #endif
 334
 335     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
 336     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
 337     /*
 338     register a function to be called at normal program termination
 339     */
 340     atexit(term_exit);
 341 #if CONFIG_BEOS_NETSERVER
 342     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
 343 #endif
 344 }
 345
 346 /* read a key without blocking */
 347 static int read_key(void)
 348 {
 349 #if HAVE_TERMIOS_H
 350     int n = 1;
 351     unsigned char ch;
 352 #if !CONFIG_BEOS_NETSERVER
 353     struct timeval tv;
 354     fd_set rfds;
 355
 356     FD_ZERO(&rfds);
 357     FD_SET(0, &rfds);
 358     tv.tv_sec = 0;
 359     tv.tv_usec = 0;
 360     n = select(1, &rfds, NULL, NULL, &tv);
 361 #endif
 362     if (n > 0) {
 363         n = read(0, &ch, 1);
 364         if (n == 1)
 365             return ch;
 366
 367         return n;
 368     }
 369 #elif HAVE_CONIO_H
 370     if(kbhit())
 371         return(getch());
 372 #endif
 373     return -1;
 374 }
 375
 376 static int decode_interrupt_cb(void)
 377 {
 378     return q_pressed || (q_pressed = read_key() == 'q');
 379 }
 380
 381 static int av_exit(int ret)
 382 {
 383     int i;
 384
 385     /* close files */
 386     for(i=0;i<nb_output_files;i++) {
 387         /* maybe av_close_output_file ??? */
 388         AVFormatContext *s = output_files[i];
 389         int j;
 390         if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
 391             url_fclose(s->pb);
 392         for(j=0;j<s->nb_streams;j++) {
 393             av_metadata_free(&s->streams[j]->metadata);
 394             av_free(s->streams[j]->codec);
 395             av_free(s->streams[j]);
 396         }
 397         for(j=0;j<s->nb_programs;j++) {
 398             av_metadata_free(&s->programs[j]->metadata);
 399         }
 400         for(j=0;j<s->nb_chapters;j++) {
 401             av_metadata_free(&s->chapters[j]->metadata);
 402         }
 403         av_metadata_free(&s->metadata);
 404         av_free(s);
 405     }
 406     for(i=0;i<nb_input_files;i++)
 407         av_close_input_file(input_files[i]);
 408
 409     av_free(intra_matrix);
 410     av_free(inter_matrix);
 411
 412     if (vstats_file)
 413         fclose(vstats_file);
 414     av_free(vstats_filename);
 415
 416     av_free(opt_names);
 417
 418     av_free(video_codec_name);
 419     av_free(audio_codec_name);
 420     av_free(subtitle_codec_name);
 421
 422     av_free(video_standard);
 423
 424 #if CONFIG_POWERPC_PERF
 425     void powerpc_display_perf_report(void);
 426     powerpc_display_perf_report();
 427 #endif /* CONFIG_POWERPC_PERF */
 428
 429     if (received_sigterm) {
 430         fprintf(stderr,
 431             "Received signal %d: terminating.\n",
 432             (int) received_sigterm);
 433         exit (255);
 434     }
 435
 436     exit(ret); /* not all OS-es handle main() return value */
 437     return ret;
 438 }
 439
 440 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
 441 {
 442     int i, err;
 443     AVFormatContext *ic;
 444     int nopts = 0;
 445
 446     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
 447     if (err < 0)
 448         return err;
 449     /* copy stream format */
 450     s->nb_streams = ic->nb_streams;
 451     for(i=0;i<ic->nb_streams;i++) {
 452         AVStream *st;
 453
 454         // FIXME: a more elegant solution is needed
 455         st = av_mallocz(sizeof(AVStream));
 456         memcpy(st, ic->streams[i], sizeof(AVStream));
 457         st->codec = avcodec_alloc_context();
 458         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
 459         s->streams[i] = st;
 460
 461         if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
 462             st->stream_copy = 1;
 463         else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
 464             st->stream_copy = 1;
 465
 466         if(!st->codec->thread_count)
 467             st->codec->thread_count = 1;
 468         if(st->codec->thread_count>1)
 469             avcodec_thread_init(st->codec, st->codec->thread_count);
 470
 471         if(st->codec->flags & CODEC_FLAG_BITEXACT)
 472             nopts = 1;
 473     }
 474
 475     if (!nopts)
 476         s->timestamp = av_gettime();
 477
 478     av_close_input_file(ic);
 479     return 0;
 480 }
 481
 482 static double
 483 get_sync_ipts(const AVOutputStream *ost)
 484 {
 485     const AVInputStream *ist = ost->sync_ist;
 486     return (double)(ist->pts - start_time)/AV_TIME_BASE;
 487 }
 488
 489 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
 490     int ret;
 491
 492     while(bsfc){
 493         AVPacket new_pkt= *pkt;
 494         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
 495                                           &new_pkt.data, &new_pkt.size,
 496                                           pkt->data, pkt->size,
 497                                           pkt->flags & PKT_FLAG_KEY);
 498         if(a>0){
 499             av_free_packet(pkt);
 500             new_pkt.destruct= av_destruct_packet;
 501         } else if(a<0){
 502             fprintf(stderr, "%s failed for stream %d, codec %s",
 503                     bsfc->filter->name, pkt->stream_index,
 504                     avctx->codec ? avctx->codec->name : "copy");
 505             print_error("", a);
 506             if (exit_on_error)
 507                 av_exit(1);
 508         }
 509         *pkt= new_pkt;
 510
 511         bsfc= bsfc->next;
 512     }
 513
 514     ret= av_interleaved_write_frame(s, pkt);
 515     if(ret < 0){
 516         print_error("av_interleaved_write_frame()", ret);
 517         av_exit(1);
 518     }
 519 }
 520
 521 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
 522
 523 static void do_audio_out(AVFormatContext *s,
 524                          AVOutputStream *ost,
 525                          AVInputStream *ist,
 526                          unsigned char *buf, int size)
 527 {
 528     uint8_t *buftmp;
 529     static uint8_t *audio_buf = NULL;
 530     static uint8_t *audio_out = NULL;
 531     static uint8_t *audio_out2 = NULL;
 532     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
 533
 534     int size_out, frame_bytes, ret;
 535     AVCodecContext *enc= ost->st->codec;
 536     AVCodecContext *dec= ist->st->codec;
 537     int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
 538     int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
 539
 540     /* SC: dynamic allocation of buffers */
 541     if (!audio_buf)
 542         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
 543     if (!audio_out)
 544         audio_out = av_malloc(audio_out_size);
 545     if (!audio_buf || !audio_out)
 546         return;               /* Should signal an error ! */
 547
 548     if (enc->channels != dec->channels)
 549         ost->audio_resample = 1;
 550
 551     if (ost->audio_resample && !ost->resample) {
 552         if (dec->sample_fmt != SAMPLE_FMT_S16)
 553             fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
 554         ost->resample = av_audio_resample_init(enc->channels,    dec->channels,
 555                                                enc->sample_rate, dec->sample_rate,
 556                                                enc->sample_fmt,  dec->sample_fmt,
 557                                                16, 10, 0, 0.8);
 558         if (!ost->resample) {
 559             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
 560                     dec->channels, dec->sample_rate,
 561                     enc->channels, enc->sample_rate);
 562             av_exit(1);
 563         }
 564     }
 565
 566 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
 567     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
 568         MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
 569         if (!audio_out2)
 570             audio_out2 = av_malloc(audio_out_size);
 571         if (!audio_out2)
 572             av_exit(1);
 573         if (ost->reformat_ctx)
 574             av_audio_convert_free(ost->reformat_ctx);
 575         ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
 576                                                    dec->sample_fmt, 1, NULL, 0);
 577         if (!ost->reformat_ctx) {
 578             fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
 579                 avcodec_get_sample_fmt_name(dec->sample_fmt),
 580                 avcodec_get_sample_fmt_name(enc->sample_fmt));
 581             av_exit(1);
 582         }
 583         ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
 584     }
 585
 586     if(audio_sync_method){
 587         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
 588                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
 589         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
 590         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
 591
 592         //FIXME resample delay
 593         if(fabs(delta) > 50){
 594             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
 595                 if(byte_delta < 0){
 596                     byte_delta= FFMAX(byte_delta, -size);
 597                     size += byte_delta;
 598                     buf  -= byte_delta;
 599                     if(verbose > 2)
 600                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
 601                     if(!size)
 602                         return;
 603                     ist->is_start=0;
 604                 }else{
 605                     static uint8_t *input_tmp= NULL;
 606                     input_tmp= av_realloc(input_tmp, byte_delta + size);
 607
 608                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
 609                         ist->is_start=0;
 610                     else
 611                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
 612
 613                     memset(input_tmp, 0, byte_delta);
 614                     memcpy(input_tmp + byte_delta, buf, size);
 615                     buf= input_tmp;
 616                     size += byte_delta;
 617                     if(verbose > 2)
 618                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
 619                 }
 620             }else if(audio_sync_method>1){
 621                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
 622                 assert(ost->audio_resample);
 623                 if(verbose > 2)
 624                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
 625 //                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));
 626                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
 627             }
 628         }
 629     }else
 630         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
 631                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
 632
 633     if (ost->audio_resample) {
 634         buftmp = audio_buf;
 635         size_out = audio_resample(ost->resample,
 636                                   (short *)buftmp, (short *)buf,
 637                                   size / (ist->st->codec->channels * isize));
 638         size_out = size_out * enc->channels * osize;
 639     } else {
 640         buftmp = buf;
 641         size_out = size;
 642     }
 643
 644     if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
 645         const void *ibuf[6]= {buftmp};
 646         void *obuf[6]= {audio_out2};
 647         int istride[6]= {isize};
 648         int ostride[6]= {osize};
 649         int len= size_out/istride[0];
 650         if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
 651             printf("av_audio_convert() failed\n");
 652             if (exit_on_error)
 653                 av_exit(1);
 654             return;
 655         }
 656         buftmp = audio_out2;
 657         size_out = len*osize;
 658     }
 659
 660     /* now encode as many frames as possible */
 661     if (enc->frame_size > 1) {
 662         /* output resampled raw samples */
 663         if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
 664             fprintf(stderr, "av_fifo_realloc2() failed\n");
 665             av_exit(1);
 666         }
 667         av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
 668
 669         frame_bytes = enc->frame_size * osize * enc->channels;
 670
 671         while (av_fifo_size(&ost->fifo) >= frame_bytes) {
 672             AVPacket pkt;
 673             av_init_packet(&pkt);
 674
 675             av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
 676
 677             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 678
 679             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
 680                                        (short *)audio_buf);
 681             if (ret < 0) {
 682                 fprintf(stderr, "Audio encoding failed\n");
 683                 av_exit(1);
 684             }
 685             audio_size += ret;
 686             pkt.stream_index= ost->index;
 687             pkt.data= audio_out;
 688             pkt.size= ret;
 689             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 690                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 691             pkt.flags |= PKT_FLAG_KEY;
 692             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 693
 694             ost->sync_opts += enc->frame_size;
 695         }
 696     } else {
 697         AVPacket pkt;
 698         int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
 699         av_init_packet(&pkt);
 700
 701         ost->sync_opts += size_out / (osize * enc->channels);
 702
 703         /* output a pcm frame */
 704         /* determine the size of the coded buffer */
 705         size_out /= osize;
 706         if (coded_bps)
 707             size_out *= coded_bps;
 708
 709         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
 710         ret = avcodec_encode_audio(enc, audio_out, size_out,
 711                                    (short *)buftmp);
 712         if (ret < 0) {
 713             fprintf(stderr, "Audio encoding failed\n");
 714             av_exit(1);
 715         }
 716         audio_size += ret;
 717         pkt.stream_index= ost->index;
 718         pkt.data= audio_out;
 719         pkt.size= ret;
 720         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
 721             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 722         pkt.flags |= PKT_FLAG_KEY;
 723         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 724     }
 725 }
 726
 727 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
 728 {
 729     AVCodecContext *dec;
 730     AVPicture *picture2;
 731     AVPicture picture_tmp;
 732     uint8_t *buf = 0;
 733
 734     dec = ist->st->codec;
 735
 736     /* deinterlace : must be done before any resize */
 737     if (do_deinterlace) {
 738         int size;
 739
 740         /* create temporary picture */
 741         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
 742         buf = av_malloc(size);
 743         if (!buf)
 744             return;
 745
 746         picture2 = &picture_tmp;
 747         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
 748
 749         if (do_deinterlace){
 750             if(avpicture_deinterlace(picture2, picture,
 751                                      dec->pix_fmt, dec->width, dec->height) < 0) {
 752                 /* if error, do not deinterlace */
 753                 fprintf(stderr, "Deinterlacing failed\n");
 754                 av_free(buf);
 755                 buf = NULL;
 756                 picture2 = picture;
 757             }
 758         } else {
 759             av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
 760         }
 761     } else {
 762         picture2 = picture;
 763     }
 764
 765     if (picture != picture2)
 766         *picture = *picture2;
 767     *bufp = buf;
 768 }
 769
 770 /* we begin to correct av delay at this threshold */
 771 #define AV_DELAY_MAX 0.100
 772
 773 static void do_subtitle_out(AVFormatContext *s,
 774                             AVOutputStream *ost,
 775                             AVInputStream *ist,
 776                             AVSubtitle *sub,
 777                             int64_t pts)
 778 {
 779     static uint8_t *subtitle_out = NULL;
 780     int subtitle_out_max_size = 65536;
 781     int subtitle_out_size, nb, i;
 782     AVCodecContext *enc;
 783     AVPacket pkt;
 784
 785     if (pts == AV_NOPTS_VALUE) {
 786         fprintf(stderr, "Subtitle packets must have a pts\n");
 787         if (exit_on_error)
 788             av_exit(1);
 789         return;
 790     }
 791
 792     enc = ost->st->codec;
 793
 794     if (!subtitle_out) {
 795         subtitle_out = av_malloc(subtitle_out_max_size);
 796     }
 797
 798     /* Note: DVB subtitle need one packet to draw them and one other
 799        packet to clear them */
 800     /* XXX: signal it in the codec context ? */
 801     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
 802         nb = 2;
 803     else
 804         nb = 1;
 805
 806     for(i = 0; i < nb; i++) {
 807         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
 808                                                     subtitle_out_max_size, sub);
 809
 810         av_init_packet(&pkt);
 811         pkt.stream_index = ost->index;
 812         pkt.data = subtitle_out;
 813         pkt.size = subtitle_out_size;
 814         pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
 815         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
 816             /* XXX: the pts correction is handled here. Maybe handling
 817                it in the codec would be better */
 818             if (i == 0)
 819                 pkt.pts += 90 * sub->start_display_time;
 820             else
 821                 pkt.pts += 90 * sub->end_display_time;
 822         }
 823         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 824     }
 825 }
 826
 827 static int bit_buffer_size= 1024*256;
 828 static uint8_t *bit_buffer= NULL;
 829
 830 static void do_video_out(AVFormatContext *s,
 831                          AVOutputStream *ost,
 832                          AVInputStream *ist,
 833                          AVFrame *in_picture,
 834                          int *frame_size)
 835 {
 836     int nb_frames, i, ret;
 837     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
 838     AVFrame picture_crop_temp, picture_pad_temp;
 839     AVCodecContext *enc, *dec;
 840
 841     avcodec_get_frame_defaults(&picture_crop_temp);
 842     avcodec_get_frame_defaults(&picture_pad_temp);
 843
 844     enc = ost->st->codec;
 845     dec = ist->st->codec;
 846
 847     /* by default, we output a single frame */
 848     nb_frames = 1;
 849
 850     *frame_size = 0;
 851
 852     if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
 853         double vdelta;
 854         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
 855         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
 856         if (vdelta < -1.1)
 857             nb_frames = 0;
 858         else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
 859             if(vdelta<=-0.6){
 860                 nb_frames=0;
 861             }else if(vdelta>0.6)
 862             ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 863         }else if (vdelta > 1.1)
 864             nb_frames = lrintf(vdelta);
 865 //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);
 866         if (nb_frames == 0){
 867             ++nb_frames_drop;
 868             if (verbose>2)
 869                 fprintf(stderr, "*** drop!\n");
 870         }else if (nb_frames > 1) {
 871             nb_frames_dup += nb_frames;
 872             if (verbose>2)
 873                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
 874         }
 875     }else
 876         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
 877
 878     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
 879     if (nb_frames <= 0)
 880         return;
 881
 882     if (ost->video_crop) {
 883         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
 884             fprintf(stderr, "error cropping picture\n");
 885             if (exit_on_error)
 886                 av_exit(1);
 887             return;
 888         }
 889         formatted_picture = &picture_crop_temp;
 890     } else {
 891         formatted_picture = in_picture;
 892     }
 893
 894     final_picture = formatted_picture;
 895     padding_src = formatted_picture;
 896     resampling_dst = &ost->pict_tmp;
 897     if (ost->video_pad) {
 898         final_picture = &ost->pict_tmp;
 899         if (ost->video_resample) {
 900             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
 901                 fprintf(stderr, "error padding picture\n");
 902                 if (exit_on_error)
 903                     av_exit(1);
 904                 return;
 905             }
 906             resampling_dst = &picture_pad_temp;
 907         }
 908     }
 909
 910     if (ost->video_resample) {
 911         padding_src = NULL;
 912         final_picture = &ost->pict_tmp;
 913         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
 914               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
 915     }
 916
 917     if (ost->video_pad) {
 918         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
 919                 enc->height, enc->width, enc->pix_fmt,
 920                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
 921     }
 922
 923     /* duplicates frame if needed */
 924     for(i=0;i<nb_frames;i++) {
 925         AVPacket pkt;
 926         av_init_packet(&pkt);
 927         pkt.stream_index= ost->index;
 928
 929         if (s->oformat->flags & AVFMT_RAWPICTURE) {
 930             /* raw pictures are written as AVPicture structure to
 931                avoid any copies. We support temorarily the older
 932                method. */
 933             AVFrame* old_frame = enc->coded_frame;
 934             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
 935             pkt.data= (uint8_t *)final_picture;
 936             pkt.size=  sizeof(AVPicture);
 937             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
 938             pkt.flags |= PKT_FLAG_KEY;
 939
 940             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 941             enc->coded_frame = old_frame;
 942         } else {
 943             AVFrame big_picture;
 944
 945             big_picture= *final_picture;
 946             /* better than nothing: use input picture interlaced
 947                settings */
 948             big_picture.interlaced_frame = in_picture->interlaced_frame;
 949             if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
 950                 if(top_field_first == -1)
 951                     big_picture.top_field_first = in_picture->top_field_first;
 952                 else
 953                     big_picture.top_field_first = top_field_first;
 954             }
 955
 956             /* handles sameq here. This is not correct because it may
 957                not be a global option */
 958             if (same_quality) {
 959                 big_picture.quality = ist->st->quality;
 960             }else
 961                 big_picture.quality = ost->st->quality;
 962             if(!me_threshold)
 963                 big_picture.pict_type = 0;
 964 //            big_picture.pts = AV_NOPTS_VALUE;
 965             big_picture.pts= ost->sync_opts;
 966 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
 967 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
 968             ret = avcodec_encode_video(enc,
 969                                        bit_buffer, bit_buffer_size,
 970                                        &big_picture);
 971             if (ret < 0) {
 972                 fprintf(stderr, "Video encoding failed\n");
 973                 av_exit(1);
 974             }
 975             //enc->frame_number = enc->real_pict_num;
 976             if(ret>0){
 977                 pkt.data= bit_buffer;
 978                 pkt.size= ret;
 979                 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
 980                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
 981 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
 982    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
 983    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
 984
 985                 if(enc->coded_frame->key_frame)
 986                     pkt.flags |= PKT_FLAG_KEY;
 987                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
 988                 *frame_size = ret;
 989                 video_size += ret;
 990                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
 991                 //        enc->frame_number-1, enc->real_pict_num, ret,
 992                 //        enc->pict_type);
 993                 /* if two pass, output log */
 994                 if (ost->logfile && enc->stats_out) {
 995                     fprintf(ost->logfile, "%s", enc->stats_out);
 996                 }
 997             }
 998         }
 999         ost->sync_opts++;
1000         ost->frame_number++;
1001     }
1002 }
1003
1004 static double psnr(double d){
1005     return -10.0*log(d)/log(10.0);
1006 }
1007
1008 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1009                            int frame_size)
1010 {
1011     AVCodecContext *enc;
1012     int frame_number;
1013     double ti1, bitrate, avg_bitrate;
1014
1015     /* this is executed just the first time do_video_stats is called */
1016     if (!vstats_file) {
1017         vstats_file = fopen(vstats_filename, "w");
1018         if (!vstats_file) {
1019             perror("fopen");
1020             av_exit(1);
1021         }
1022     }
1023
1024     enc = ost->st->codec;
1025     if (enc->codec_type == CODEC_TYPE_VIDEO) {
1026         frame_number = ost->frame_number;
1027         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1028         if (enc->flags&CODEC_FLAG_PSNR)
1029             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1030
1031         fprintf(vstats_file,"f_size= %6d ", frame_size);
1032         /* compute pts value */
1033         ti1 = ost->sync_opts * av_q2d(enc->time_base);
1034         if (ti1 < 0.01)
1035             ti1 = 0.01;
1036
1037         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1038         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1039         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1040             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1041         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1042     }
1043 }
1044
1045 static void print_report(AVFormatContext **output_files,
1046                          AVOutputStream **ost_table, int nb_ostreams,
1047                          int is_last_report)
1048 {
1049     char buf[1024];
1050     AVOutputStream *ost;
1051     AVFormatContext *oc, *os;
1052     int64_t total_size;
1053     AVCodecContext *enc;
1054     int frame_number, vid, i;
1055     double bitrate, ti1, pts;
1056     static int64_t last_time = -1;
1057     static int qp_histogram[52];
1058
1059     if (!is_last_report) {
1060         int64_t cur_time;
1061         /* display the report every 0.5 seconds */
1062         cur_time = av_gettime();
1063         if (last_time == -1) {
1064             last_time = cur_time;
1065             return;
1066         }
1067         if ((cur_time - last_time) < 500000)
1068             return;
1069         last_time = cur_time;
1070     }
1071
1072
1073     oc = output_files[0];
1074
1075     total_size = url_fsize(oc->pb);
1076     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1077         total_size= url_ftell(oc->pb);
1078
1079     buf[0] = '\0';
1080     ti1 = 1e10;
1081     vid = 0;
1082     for(i=0;i<nb_ostreams;i++) {
1083         ost = ost_table[i];
1084         os = output_files[ost->file_index];
1085         enc = ost->st->codec;
1086         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1087             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1088                      !ost->st->stream_copy ?
1089                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1090         }
1091         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1092             float t = (av_gettime()-timer_start) / 1000000.0;
1093
1094             frame_number = ost->frame_number;
1095             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1096                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1097                      !ost->st->stream_copy ?
1098                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1099             if(is_last_report)
1100                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1101             if(qp_hist){
1102                 int j;
1103                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1104                 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1105                     qp_histogram[qp]++;
1106                 for(j=0; j<32; j++)
1107                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1108             }
1109             if (enc->flags&CODEC_FLAG_PSNR){
1110                 int j;
1111                 double error, error_sum=0;
1112                 double scale, scale_sum=0;
1113                 char type[3]= {'Y','U','V'};
1114                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1115                 for(j=0; j<3; j++){
1116                     if(is_last_report){
1117                         error= enc->error[j];
1118                         scale= enc->width*enc->height*255.0*255.0*frame_number;
1119                     }else{
1120                         error= enc->coded_frame->error[j];
1121                         scale= enc->width*enc->height*255.0*255.0;
1122                     }
1123                     if(j) scale/=4;
1124                     error_sum += error;
1125                     scale_sum += scale;
1126                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1127                 }
1128                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1129             }
1130             vid = 1;
1131         }
1132         /* compute min output value */
1133         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1134         if ((pts < ti1) && (pts > 0))
1135             ti1 = pts;
1136     }
1137     if (ti1 < 0.01)
1138         ti1 = 0.01;
1139
1140     if (verbose || is_last_report) {
1141         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1142
1143         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1144             "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1145             (double)total_size / 1024, ti1, bitrate);
1146
1147         if (verbose > 1)
1148           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1149                   nb_frames_dup, nb_frames_drop);
1150
1151         if (verbose >= 0)
1152             fprintf(stderr, "%s    \r", buf);
1153
1154         fflush(stderr);
1155     }
1156
1157     if (is_last_report && verbose >= 0){
1158         int64_t raw= audio_size + video_size + extra_size;
1159         fprintf(stderr, "\n");
1160         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1161                 video_size/1024.0,
1162                 audio_size/1024.0,
1163                 extra_size/1024.0,
1164                 100.0*(total_size - raw)/raw
1165         );
1166     }
1167 }
1168
1169 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1170 static int output_packet(AVInputStream *ist, int ist_index,
1171                          AVOutputStream **ost_table, int nb_ostreams,
1172                          const AVPacket *pkt)
1173 {
1174     AVFormatContext *os;
1175     AVOutputStream *ost;
1176     uint8_t *ptr;
1177     int len, ret, i;
1178     uint8_t *data_buf;
1179     int data_size, got_picture;
1180     AVFrame picture;
1181     void *buffer_to_free;
1182     static unsigned int samples_size= 0;
1183     static short *samples= NULL;
1184     AVSubtitle subtitle, *subtitle_to_free;
1185     int got_subtitle;
1186
1187     if(ist->next_pts == AV_NOPTS_VALUE)
1188         ist->next_pts= ist->pts;
1189
1190     if (pkt == NULL) {
1191         /* EOF handling */
1192         ptr = NULL;
1193         len = 0;
1194         goto handle_eof;
1195     }
1196
1197     if(pkt->dts != AV_NOPTS_VALUE)
1198         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1199
1200     len = pkt->size;
1201     ptr = pkt->data;
1202
1203     //while we have more to decode or while the decoder did output something on EOF
1204     while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1205     handle_eof:
1206         ist->pts= ist->next_pts;
1207
1208         if(len && len != pkt->size && verbose>0)
1209             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1210
1211         /* decode the packet if needed */
1212         data_buf = NULL; /* fail safe */
1213         data_size = 0;
1214         subtitle_to_free = NULL;
1215         if (ist->decoding_needed) {
1216             switch(ist->st->codec->codec_type) {
1217             case CODEC_TYPE_AUDIO:{
1218                 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1219                     samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1220                     av_free(samples);
1221                     samples= av_malloc(samples_size);
1222                 }
1223                 data_size= samples_size;
1224                     /* XXX: could avoid copy if PCM 16 bits with same
1225                        endianness as CPU */
1226                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1227                                            ptr, len);
1228                 if (ret < 0)
1229                     goto fail_decode;
1230                 ptr += ret;
1231                 len -= ret;
1232                 /* Some bug in mpeg audio decoder gives */
1233                 /* data_size < 0, it seems they are overflows */
1234                 if (data_size <= 0) {
1235                     /* no audio frame */
1236                     continue;
1237                 }
1238                 data_buf = (uint8_t *)samples;
1239                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1240                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1241                 break;}
1242             case CODEC_TYPE_VIDEO:
1243                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1244                     /* XXX: allocate picture correctly */
1245                     avcodec_get_frame_defaults(&picture);
1246
1247                     ret = avcodec_decode_video(ist->st->codec,
1248                                                &picture, &got_picture, ptr, len);
1249                     ist->st->quality= picture.quality;
1250                     if (ret < 0)
1251                         goto fail_decode;
1252                     if (!got_picture) {
1253                         /* no picture yet */
1254                         goto discard_packet;
1255                     }
1256                     if (ist->st->codec->time_base.num != 0) {
1257                         int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1258                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1259                                           ist->st->codec->time_base.num * ticks) /
1260                             ist->st->codec->time_base.den;
1261                     }
1262                     len = 0;
1263                     break;
1264             case CODEC_TYPE_SUBTITLE:
1265                 ret = avcodec_decode_subtitle(ist->st->codec,
1266                                               &subtitle, &got_subtitle, ptr, len);
1267                 if (ret < 0)
1268                     goto fail_decode;
1269                 if (!got_subtitle) {
1270                     goto discard_packet;
1271                 }
1272                 subtitle_to_free = &subtitle;
1273                 len = 0;
1274                 break;
1275             default:
1276                 goto fail_decode;
1277             }
1278         } else {
1279             switch(ist->st->codec->codec_type) {
1280             case CODEC_TYPE_AUDIO:
1281                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1282                     ist->st->codec->sample_rate;
1283                 break;
1284             case CODEC_TYPE_VIDEO:
1285                 if (ist->st->codec->time_base.num != 0) {
1286                     int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1287                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1288                                       ist->st->codec->time_base.num * ticks) /
1289                         ist->st->codec->time_base.den;
1290                 }
1291                 break;
1292             }
1293             data_buf = ptr;
1294             data_size = len;
1295             ret = len;
1296             len = 0;
1297         }
1298
1299         buffer_to_free = NULL;
1300         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1301             pre_process_video_frame(ist, (AVPicture *)&picture,
1302                                     &buffer_to_free);
1303         }
1304
1305         // preprocess audio (volume)
1306         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1307             if (audio_volume != 256) {
1308                 short *volp;
1309                 volp = samples;
1310                 for(i=0;i<(data_size / sizeof(short));i++) {
1311                     int v = ((*volp) * audio_volume + 128) >> 8;
1312                     if (v < -32768) v = -32768;
1313                     if (v >  32767) v = 32767;
1314                     *volp++ = v;
1315                 }
1316             }
1317         }
1318
1319         /* frame rate emulation */
1320         if (rate_emu) {
1321             int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1322             int64_t now = av_gettime() - ist->start;
1323             if (pts > now)
1324                 usleep(pts - now);
1325         }
1326
1327         /* if output time reached then transcode raw format,
1328            encode packets and output them */
1329         if (start_time == 0 || ist->pts >= start_time)
1330             for(i=0;i<nb_ostreams;i++) {
1331                 int frame_size;
1332
1333                 ost = ost_table[i];
1334                 if (ost->source_index == ist_index) {
1335                     os = output_files[ost->file_index];
1336
1337 #if 0
1338                     printf("%d: got pts=%0.3f %0.3f\n", i,
1339                            (double)pkt->pts / AV_TIME_BASE,
1340                            ((double)ist->pts / AV_TIME_BASE) -
1341                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1342 #endif
1343                     /* set the input output pts pairs */
1344                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1345
1346                     if (ost->encoding_needed) {
1347                         switch(ost->st->codec->codec_type) {
1348                         case CODEC_TYPE_AUDIO:
1349                             do_audio_out(os, ost, ist, data_buf, data_size);
1350                             break;
1351                         case CODEC_TYPE_VIDEO:
1352                             do_video_out(os, ost, ist, &picture, &frame_size);
1353                             if (vstats_filename && frame_size)
1354                                 do_video_stats(os, ost, frame_size);
1355                             break;
1356                         case CODEC_TYPE_SUBTITLE:
1357                             do_subtitle_out(os, ost, ist, &subtitle,
1358                                             pkt->pts);
1359                             break;
1360                         default:
1361                             abort();
1362                         }
1363                     } else {
1364                         AVFrame avframe; //FIXME/XXX remove this
1365                         AVPacket opkt;
1366                         av_init_packet(&opkt);
1367
1368                         if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1369                             continue;
1370
1371                         /* no reencoding needed : output the packet directly */
1372                         /* force the input stream PTS */
1373
1374                         avcodec_get_frame_defaults(&avframe);
1375                         ost->st->codec->coded_frame= &avframe;
1376                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1377
1378                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1379                             audio_size += data_size;
1380                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1381                             video_size += data_size;
1382                             ost->sync_opts++;
1383                         }
1384
1385                         opkt.stream_index= ost->index;
1386                         if(pkt->pts != AV_NOPTS_VALUE)
1387                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1388                         else
1389                             opkt.pts= AV_NOPTS_VALUE;
1390
1391                         if (pkt->dts == AV_NOPTS_VALUE)
1392                             opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1393                         else
1394                             opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1395
1396                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1397                         opkt.flags= pkt->flags;
1398
1399                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1400                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1401                             opkt.destruct= av_destruct_packet;
1402
1403                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1404                         ost->st->codec->frame_number++;
1405                         ost->frame_number++;
1406                         av_free_packet(&opkt);
1407                     }
1408                 }
1409             }
1410         av_free(buffer_to_free);
1411         /* XXX: allocate the subtitles in the codec ? */
1412         if (subtitle_to_free) {
1413             if (subtitle_to_free->rects != NULL) {
1414                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1415                     av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1416                     av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1417                     av_freep(&subtitle_to_free->rects[i]);
1418                 }
1419                 av_freep(&subtitle_to_free->rects);
1420             }
1421             subtitle_to_free->num_rects = 0;
1422             subtitle_to_free = NULL;
1423         }
1424     }
1425  discard_packet:
1426     if (pkt == NULL) {
1427         /* EOF handling */
1428
1429         for(i=0;i<nb_ostreams;i++) {
1430             ost = ost_table[i];
1431             if (ost->source_index == ist_index) {
1432                 AVCodecContext *enc= ost->st->codec;
1433                 os = output_files[ost->file_index];
1434
1435                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1436                     continue;
1437                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1438                     continue;
1439
1440                 if (ost->encoding_needed) {
1441                     for(;;) {
1442                         AVPacket pkt;
1443                         int fifo_bytes;
1444                         av_init_packet(&pkt);
1445                         pkt.stream_index= ost->index;
1446
1447                         switch(ost->st->codec->codec_type) {
1448                         case CODEC_TYPE_AUDIO:
1449                             fifo_bytes = av_fifo_size(&ost->fifo);
1450                             ret = 0;
1451                             /* encode any samples remaining in fifo */
1452                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1453                                 int fs_tmp = enc->frame_size;
1454                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1455                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1456                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1457                                 enc->frame_size = fs_tmp;
1458                             }
1459                             if(ret <= 0) {
1460                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1461                             }
1462                             if (ret < 0) {
1463                                 fprintf(stderr, "Audio encoding failed\n");
1464                                 av_exit(1);
1465                             }
1466                             audio_size += ret;
1467                             pkt.flags |= PKT_FLAG_KEY;
1468                             break;
1469                         case CODEC_TYPE_VIDEO:
1470                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1471                             if (ret < 0) {
1472                                 fprintf(stderr, "Video encoding failed\n");
1473                                 av_exit(1);
1474                             }
1475                             video_size += ret;
1476                             if(enc->coded_frame && enc->coded_frame->key_frame)
1477                                 pkt.flags |= PKT_FLAG_KEY;
1478                             if (ost->logfile && enc->stats_out) {
1479                                 fprintf(ost->logfile, "%s", enc->stats_out);
1480                             }
1481                             break;
1482                         default:
1483                             ret=-1;
1484                         }
1485
1486                         if(ret<=0)
1487                             break;
1488                         pkt.data= bit_buffer;
1489                         pkt.size= ret;
1490                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1491                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1492                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1493                     }
1494                 }
1495             }
1496         }
1497     }
1498
1499     return 0;
1500  fail_decode:
1501     return -1;
1502 }
1503
1504 static void print_sdp(AVFormatContext **avc, int n)
1505 {
1506     char sdp[2048];
1507
1508     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1509     printf("SDP:\n%s\n", sdp);
1510     fflush(stdout);
1511 }
1512
1513 static int stream_index_from_inputs(AVFormatContext **input_files,
1514                                     int nb_input_files,
1515                                     AVInputFile *file_table,
1516                                     AVInputStream **ist_table,
1517                                     enum CodecType type,
1518                                     int programid)
1519 {
1520     int p, q, z;
1521     for(z=0; z<nb_input_files; z++) {
1522         AVFormatContext *ic = input_files[z];
1523         for(p=0; p<ic->nb_programs; p++) {
1524             AVProgram *program = ic->programs[p];
1525             if(program->id != programid)
1526                 continue;
1527             for(q=0; q<program->nb_stream_indexes; q++) {
1528                 int sidx = program->stream_index[q];
1529                 int ris = file_table[z].ist_index + sidx;
1530                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1531                     return ris;
1532             }
1533         }
1534     }
1535
1536     return -1;
1537 }
1538
1539 /*
1540  * The following code is the main loop of the file converter
1541  */
1542 static int av_encode(AVFormatContext **output_files,
1543                      int nb_output_files,
1544                      AVFormatContext **input_files,
1545                      int nb_input_files,
1546                      AVStreamMap *stream_maps, int nb_stream_maps)
1547 {
1548     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1549     AVFormatContext *is, *os;
1550     AVCodecContext *codec, *icodec;
1551     AVOutputStream *ost, **ost_table = NULL;
1552     AVInputStream *ist, **ist_table = NULL;
1553     AVInputFile *file_table;
1554     int key;
1555     int want_sdp = 1;
1556     uint8_t no_packet[MAX_FILES]={0};
1557     int no_packet_count=0;
1558
1559     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1560     if (!file_table)
1561         goto fail;
1562
1563     /* input stream init */
1564     j = 0;
1565     for(i=0;i<nb_input_files;i++) {
1566         is = input_files[i];
1567         file_table[i].ist_index = j;
1568         file_table[i].nb_streams = is->nb_streams;
1569         j += is->nb_streams;
1570     }
1571     nb_istreams = j;
1572
1573     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1574     if (!ist_table)
1575         goto fail;
1576
1577     for(i=0;i<nb_istreams;i++) {
1578         ist = av_mallocz(sizeof(AVInputStream));
1579         if (!ist)
1580             goto fail;
1581         ist_table[i] = ist;
1582     }
1583     j = 0;
1584     for(i=0;i<nb_input_files;i++) {
1585         is = input_files[i];
1586         for(k=0;k<is->nb_streams;k++) {
1587             ist = ist_table[j++];
1588             ist->st = is->streams[k];
1589             ist->file_index = i;
1590             ist->index = k;
1591             ist->discard = 1; /* the stream is discarded by default
1592                                  (changed later) */
1593
1594             if (rate_emu) {
1595                 ist->start = av_gettime();
1596             }
1597         }
1598     }
1599
1600     /* output stream init */
1601     nb_ostreams = 0;
1602     for(i=0;i<nb_output_files;i++) {
1603         os = output_files[i];
1604         if (!os->nb_streams) {
1605             dump_format(output_files[i], i, output_files[i]->filename, 1);
1606             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1607             av_exit(1);
1608         }
1609         nb_ostreams += os->nb_streams;
1610     }
1611     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1612         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1613         av_exit(1);
1614     }
1615
1616     /* Sanity check the mapping args -- do the input files & streams exist? */
1617     for(i=0;i<nb_stream_maps;i++) {
1618         int fi = stream_maps[i].file_index;
1619         int si = stream_maps[i].stream_index;
1620
1621         if (fi < 0 || fi > nb_input_files - 1 ||
1622             si < 0 || si > file_table[fi].nb_streams - 1) {
1623             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1624             av_exit(1);
1625         }
1626         fi = stream_maps[i].sync_file_index;
1627         si = stream_maps[i].sync_stream_index;
1628         if (fi < 0 || fi > nb_input_files - 1 ||
1629             si < 0 || si > file_table[fi].nb_streams - 1) {
1630             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1631             av_exit(1);
1632         }
1633     }
1634
1635     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1636     if (!ost_table)
1637         goto fail;
1638     for(i=0;i<nb_ostreams;i++) {
1639         ost = av_mallocz(sizeof(AVOutputStream));
1640         if (!ost)
1641             goto fail;
1642         ost_table[i] = ost;
1643     }
1644
1645     n = 0;
1646     for(k=0;k<nb_output_files;k++) {
1647         os = output_files[k];
1648         for(i=0;i<os->nb_streams;i++,n++) {
1649             int found;
1650             ost = ost_table[n];
1651             ost->file_index = k;
1652             ost->index = i;
1653             ost->st = os->streams[i];
1654             if (nb_stream_maps > 0) {
1655                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1656                     stream_maps[n].stream_index;
1657
1658                 /* Sanity check that the stream types match */
1659                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1660                     int i= ost->file_index;
1661                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1662                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1663                         stream_maps[n].file_index, stream_maps[n].stream_index,
1664                         ost->file_index, ost->index);
1665                     av_exit(1);
1666                 }
1667
1668             } else {
1669                 if(opt_programid) {
1670                     found = 0;
1671                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1672                     if(j != -1) {
1673                         ost->source_index = j;
1674                         found = 1;
1675                     }
1676                 } else {
1677                     /* get corresponding input stream index : we select the first one with the right type */
1678                     found = 0;
1679                     for(j=0;j<nb_istreams;j++) {
1680                         ist = ist_table[j];
1681                         if (ist->discard &&
1682                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1683                             ost->source_index = j;
1684                             found = 1;
1685                             break;
1686                         }
1687                     }
1688                 }
1689
1690                 if (!found) {
1691                     if(! opt_programid) {
1692                         /* try again and reuse existing stream */
1693                         for(j=0;j<nb_istreams;j++) {
1694                             ist = ist_table[j];
1695                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1696                                 ost->source_index = j;
1697                                 found = 1;
1698                             }
1699                         }
1700                     }
1701                     if (!found) {
1702                         int i= ost->file_index;
1703                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1704                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1705                                 ost->file_index, ost->index);
1706                         av_exit(1);
1707                     }
1708                 }
1709             }
1710             ist = ist_table[ost->source_index];
1711             ist->discard = 0;
1712             ost->sync_ist = (nb_stream_maps > 0) ?
1713                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1714                          stream_maps[n].sync_stream_index] : ist;
1715         }
1716     }
1717
1718     /* for each output stream, we compute the right encoding parameters */
1719     for(i=0;i<nb_ostreams;i++) {
1720         AVMetadataTag *lang;
1721         ost = ost_table[i];
1722         os = output_files[ost->file_index];
1723         ist = ist_table[ost->source_index];
1724
1725         codec = ost->st->codec;
1726         icodec = ist->st->codec;
1727
1728         if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1729             &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1730             av_metadata_set(&ost->st->metadata, "language", lang->value);
1731
1732         ost->st->disposition = ist->st->disposition;
1733
1734         if (ost->st->stream_copy) {
1735             /* if stream_copy is selected, no need to decode or encode */
1736             codec->codec_id = icodec->codec_id;
1737             codec->codec_type = icodec->codec_type;
1738
1739             if(!codec->codec_tag){
1740                 if(   !os->oformat->codec_tag
1741                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1742                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1743                     codec->codec_tag = icodec->codec_tag;
1744             }
1745
1746             codec->bit_rate = icodec->bit_rate;
1747             codec->extradata= icodec->extradata;
1748             codec->extradata_size= icodec->extradata_size;
1749             if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1750                 codec->time_base = icodec->time_base;
1751                 codec->time_base.num *= icodec->ticks_per_frame;
1752             }else
1753                 codec->time_base = ist->st->time_base;
1754             switch(codec->codec_type) {
1755             case CODEC_TYPE_AUDIO:
1756                 if(audio_volume != 256) {
1757                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1758                     av_exit(1);
1759                 }
1760                 codec->channel_layout = icodec->channel_layout;
1761                 codec->sample_rate = icodec->sample_rate;
1762                 codec->channels = icodec->channels;
1763                 codec->frame_size = icodec->frame_size;
1764                 codec->block_align= icodec->block_align;
1765                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1766                     codec->block_align= 0;
1767                 if(codec->codec_id == CODEC_ID_AC3)
1768                     codec->block_align= 0;
1769                 break;
1770             case CODEC_TYPE_VIDEO:
1771                 codec->pix_fmt = icodec->pix_fmt;
1772                 codec->width = icodec->width;
1773                 codec->height = icodec->height;
1774                 codec->has_b_frames = icodec->has_b_frames;
1775                 break;
1776             case CODEC_TYPE_SUBTITLE:
1777                 codec->width = icodec->width;
1778                 codec->height = icodec->height;
1779                 break;
1780             default:
1781                 abort();
1782             }
1783         } else {
1784             switch(codec->codec_type) {
1785             case CODEC_TYPE_AUDIO:
1786                 if (av_fifo_init(&ost->fifo, 1024))
1787                     goto fail;
1788                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1789                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1790                 icodec->request_channels = codec->channels;
1791                 ist->decoding_needed = 1;
1792                 ost->encoding_needed = 1;
1793                 break;
1794             case CODEC_TYPE_VIDEO:
1795                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1796                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1797                 ost->video_resample = ((codec->width != icodec->width -
1798                                 (frame_leftBand + frame_rightBand) +
1799                                 (frame_padleft + frame_padright)) ||
1800                         (codec->height != icodec->height -
1801                                 (frame_topBand  + frame_bottomBand) +
1802                                 (frame_padtop + frame_padbottom)) ||
1803                         (codec->pix_fmt != icodec->pix_fmt));
1804                 if (ost->video_crop) {
1805                     ost->topBand = frame_topBand;
1806                     ost->leftBand = frame_leftBand;
1807                 }
1808                 if (ost->video_pad) {
1809                     ost->padtop = frame_padtop;
1810                     ost->padleft = frame_padleft;
1811                     ost->padbottom = frame_padbottom;
1812                     ost->padright = frame_padright;
1813                     if (!ost->video_resample) {
1814                         avcodec_get_frame_defaults(&ost->pict_tmp);
1815                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1816                                          codec->width, codec->height))
1817                             goto fail;
1818                     }
1819                 }
1820                 if (ost->video_resample) {
1821                     avcodec_get_frame_defaults(&ost->pict_tmp);
1822                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1823                                          codec->width, codec->height)) {
1824                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1825                         av_exit(1);
1826                     }
1827                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1828                     ost->img_resample_ctx = sws_getContext(
1829                             icodec->width - (frame_leftBand + frame_rightBand),
1830                             icodec->height - (frame_topBand + frame_bottomBand),
1831                             icodec->pix_fmt,
1832                             codec->width - (frame_padleft + frame_padright),
1833                             codec->height - (frame_padtop + frame_padbottom),
1834                             codec->pix_fmt,
1835                             sws_flags, NULL, NULL, NULL);
1836                     if (ost->img_resample_ctx == NULL) {
1837                         fprintf(stderr, "Cannot get resampling context\n");
1838                         av_exit(1);
1839                     }
1840                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1841                 }
1842                 ost->encoding_needed = 1;
1843                 ist->decoding_needed = 1;
1844                 break;
1845             case CODEC_TYPE_SUBTITLE:
1846                 ost->encoding_needed = 1;
1847                 ist->decoding_needed = 1;
1848                 break;
1849             default:
1850                 abort();
1851                 break;
1852             }
1853             /* two pass mode */
1854             if (ost->encoding_needed &&
1855                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1856                 char logfilename[1024];
1857                 FILE *f;
1858                 int size;
1859                 char *logbuffer;
1860
1861                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1862                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1863                          i);
1864                 if (codec->flags & CODEC_FLAG_PASS1) {
1865                     f = fopen(logfilename, "w");
1866                     if (!f) {
1867                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1868                         av_exit(1);
1869                     }
1870                     ost->logfile = f;
1871                 } else {
1872                     /* read the log file */
1873                     f = fopen(logfilename, "r");
1874                     if (!f) {
1875                         fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1876                         av_exit(1);
1877                     }
1878                     fseek(f, 0, SEEK_END);
1879                     size = ftell(f);
1880                     fseek(f, 0, SEEK_SET);
1881                     logbuffer = av_malloc(size + 1);
1882                     if (!logbuffer) {
1883                         fprintf(stderr, "Could not allocate log buffer\n");
1884                         av_exit(1);
1885                     }
1886                     size = fread(logbuffer, 1, size, f);
1887                     fclose(f);
1888                     logbuffer[size] = '\0';
1889                     codec->stats_in = logbuffer;
1890                 }
1891             }
1892         }
1893         if(codec->codec_type == CODEC_TYPE_VIDEO){
1894             int size= codec->width * codec->height;
1895             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1896         }
1897     }
1898
1899     if (!bit_buffer)
1900         bit_buffer = av_malloc(bit_buffer_size);
1901     if (!bit_buffer)
1902         goto fail;
1903
1904     /* dump the file output parameters - cannot be done before in case
1905        of stream copy */
1906     for(i=0;i<nb_output_files;i++) {
1907         dump_format(output_files[i], i, output_files[i]->filename, 1);
1908     }
1909
1910     /* dump the stream mapping */
1911     if (verbose >= 0) {
1912         fprintf(stderr, "Stream mapping:\n");
1913         for(i=0;i<nb_ostreams;i++) {
1914             ost = ost_table[i];
1915             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1916                     ist_table[ost->source_index]->file_index,
1917                     ist_table[ost->source_index]->index,
1918                     ost->file_index,
1919                     ost->index);
1920             if (ost->sync_ist != ist_table[ost->source_index])
1921                 fprintf(stderr, " [sync #%d.%d]",
1922                         ost->sync_ist->file_index,
1923                         ost->sync_ist->index);
1924             fprintf(stderr, "\n");
1925         }
1926     }
1927
1928     /* open each encoder */
1929     for(i=0;i<nb_ostreams;i++) {
1930         ost = ost_table[i];
1931         if (ost->encoding_needed) {
1932             AVCodec *codec = output_codecs[i];
1933             if (!codec)
1934                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1935             if (!codec) {
1936                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1937                         ost->file_index, ost->index);
1938                 av_exit(1);
1939             }
1940             if (avcodec_open(ost->st->codec, codec) < 0) {
1941                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1942                         ost->file_index, ost->index);
1943                 av_exit(1);
1944             }
1945             extra_size += ost->st->codec->extradata_size;
1946         }
1947     }
1948
1949     /* open each decoder */
1950     for(i=0;i<nb_istreams;i++) {
1951         ist = ist_table[i];
1952         if (ist->decoding_needed) {
1953             AVCodec *codec = input_codecs[i];
1954             if (!codec)
1955                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1956             if (!codec) {
1957                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1958                         ist->st->codec->codec_id, ist->file_index, ist->index);
1959                 av_exit(1);
1960             }
1961             if (avcodec_open(ist->st->codec, codec) < 0) {
1962                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1963                         ist->file_index, ist->index);
1964                 av_exit(1);
1965             }
1966             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1967             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1968         }
1969     }
1970
1971     /* init pts */
1972     for(i=0;i<nb_istreams;i++) {
1973         ist = ist_table[i];
1974         is = input_files[ist->file_index];
1975         ist->pts = 0;
1976         ist->next_pts = AV_NOPTS_VALUE;
1977         ist->is_start = 1;
1978     }
1979
1980     /* set meta data information from input file if required */
1981     for (i=0;i<nb_meta_data_maps;i++) {
1982         AVFormatContext *out_file;
1983         AVFormatContext *in_file;
1984         AVMetadataTag *mtag;
1985
1986         int out_file_index = meta_data_maps[i].out_file;
1987         int in_file_index = meta_data_maps[i].in_file;
1988         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1989             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1990             ret = AVERROR(EINVAL);
1991             goto fail;
1992         }
1993         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1994             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1995             ret = AVERROR(EINVAL);
1996             goto fail;
1997         }
1998
1999         out_file = output_files[out_file_index];
2000         in_file = input_files[in_file_index];
2001
2002
2003         mtag=NULL;
2004         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2005             av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2006         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2007                                     in_file->iformat->metadata_conv);
2008     }
2009
2010     /* open files and write file headers */
2011     for(i=0;i<nb_output_files;i++) {
2012         os = output_files[i];
2013         if (av_write_header(os) < 0) {
2014             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2015             ret = AVERROR(EINVAL);
2016             goto fail;
2017         }
2018         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2019             want_sdp = 0;
2020         }
2021     }
2022     if (want_sdp) {
2023         print_sdp(output_files, nb_output_files);
2024     }
2025
2026     if (!using_stdin && verbose >= 0) {
2027         fprintf(stderr, "Press [q] to stop encoding\n");
2028         url_set_interrupt_cb(decode_interrupt_cb);
2029     }
2030     term_init();
2031
2032     key = -1;
2033     timer_start = av_gettime();
2034
2035     for(; received_sigterm == 0;) {
2036         int file_index, ist_index;
2037         AVPacket pkt;
2038         double ipts_min;
2039         double opts_min;
2040
2041     redo:
2042         ipts_min= 1e100;
2043         opts_min= 1e100;
2044         /* if 'q' pressed, exits */
2045         if (!using_stdin) {
2046             if (q_pressed)
2047                 break;
2048             /* read_key() returns 0 on EOF */
2049             key = read_key();
2050             if (key == 'q')
2051                 break;
2052         }
2053
2054         /* select the stream that we must read now by looking at the
2055            smallest output pts */
2056         file_index = -1;
2057         for(i=0;i<nb_ostreams;i++) {
2058             double ipts, opts;
2059             ost = ost_table[i];
2060             os = output_files[ost->file_index];
2061             ist = ist_table[ost->source_index];
2062             if(no_packet[ist->file_index])
2063                 continue;
2064             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2065                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2066             else
2067                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2068             ipts = (double)ist->pts;
2069             if (!file_table[ist->file_index].eof_reached){
2070                 if(ipts < ipts_min) {
2071                     ipts_min = ipts;
2072                     if(input_sync ) file_index = ist->file_index;
2073                 }
2074                 if(opts < opts_min) {
2075                     opts_min = opts;
2076                     if(!input_sync) file_index = ist->file_index;
2077                 }
2078             }
2079             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2080                 file_index= -1;
2081                 break;
2082             }
2083         }
2084         /* if none, if is finished */
2085         if (file_index < 0) {
2086             if(no_packet_count){
2087                 no_packet_count=0;
2088                 memset(no_packet, 0, sizeof(no_packet));
2089                 usleep(10000);
2090                 continue;
2091             }
2092             break;
2093         }
2094
2095         /* finish if recording time exhausted */
2096         if (opts_min >= (recording_time / 1000000.0))
2097             break;
2098
2099         /* finish if limit size exhausted */
2100         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2101             break;
2102
2103         /* read a frame from it and output it in the fifo */
2104         is = input_files[file_index];
2105         ret= av_read_frame(is, &pkt);
2106         if(ret == AVERROR(EAGAIN) && strcmp(is->iformat->name, "ffm")){
2107             no_packet[file_index]=1;
2108             no_packet_count++;
2109             continue;
2110         }
2111         if (ret < 0) {
2112             file_table[file_index].eof_reached = 1;
2113             if (opt_shortest)
2114                 break;
2115             else
2116                 continue;
2117         }
2118
2119         no_packet_count=0;
2120         memset(no_packet, 0, sizeof(no_packet));
2121
2122         if (do_pkt_dump) {
2123             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2124         }
2125         /* the following test is needed in case new streams appear
2126            dynamically in stream : we ignore them */
2127         if (pkt.stream_index >= file_table[file_index].nb_streams)
2128             goto discard_packet;
2129         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2130         ist = ist_table[ist_index];
2131         if (ist->discard)
2132             goto discard_packet;
2133
2134         if (pkt.dts != AV_NOPTS_VALUE)
2135             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2136         if (pkt.pts != AV_NOPTS_VALUE)
2137             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2138
2139         if(input_files_ts_scale[file_index][pkt.stream_index]){
2140             if(pkt.pts != AV_NOPTS_VALUE)
2141                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2142             if(pkt.dts != AV_NOPTS_VALUE)
2143                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2144         }
2145
2146 //        fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2147         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2148             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2149             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2150             int64_t delta= pkt_dts - ist->next_pts;
2151             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2152                 input_files_ts_offset[ist->file_index]-= delta;
2153                 if (verbose > 2)
2154                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2155                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2156                 if(pkt.pts != AV_NOPTS_VALUE)
2157                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2158             }
2159         }
2160
2161         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2162         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2163
2164             if (verbose >= 0)
2165                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2166                         ist->file_index, ist->index);
2167             if (exit_on_error)
2168                 av_exit(1);
2169             av_free_packet(&pkt);
2170             goto redo;
2171         }
2172
2173     discard_packet:
2174         av_free_packet(&pkt);
2175
2176         /* dump report by using the output first video and audio streams */
2177         print_report(output_files, ost_table, nb_ostreams, 0);
2178     }
2179
2180     /* at the end of stream, we must flush the decoder buffers */
2181     for(i=0;i<nb_istreams;i++) {
2182         ist = ist_table[i];
2183         if (ist->decoding_needed) {
2184             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2185         }
2186     }
2187
2188     term_exit();
2189
2190     /* write the trailer if needed and close file */
2191     for(i=0;i<nb_output_files;i++) {
2192         os = output_files[i];
2193         av_write_trailer(os);
2194     }
2195
2196     /* dump report by using the first video and audio streams */
2197     print_report(output_files, ost_table, nb_ostreams, 1);
2198
2199     /* close each encoder */
2200     for(i=0;i<nb_ostreams;i++) {
2201         ost = ost_table[i];
2202         if (ost->encoding_needed) {
2203             av_freep(&ost->st->codec->stats_in);
2204             avcodec_close(ost->st->codec);
2205         }
2206     }
2207
2208     /* close each decoder */
2209     for(i=0;i<nb_istreams;i++) {
2210         ist = ist_table[i];
2211         if (ist->decoding_needed) {
2212             avcodec_close(ist->st->codec);
2213         }
2214     }
2215
2216     /* finished ! */
2217
2218     ret = 0;
2219  fail1:
2220     av_freep(&bit_buffer);
2221     av_free(file_table);
2222
2223     if (ist_table) {
2224         for(i=0;i<nb_istreams;i++) {
2225             ist = ist_table[i];
2226             av_free(ist);
2227         }
2228         av_free(ist_table);
2229     }
2230     if (ost_table) {
2231         for(i=0;i<nb_ostreams;i++) {
2232             ost = ost_table[i];
2233             if (ost) {
2234                 if (ost->logfile) {
2235                     fclose(ost->logfile);
2236                     ost->logfile = NULL;
2237                 }
2238                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2239                                              initialized but set to zero */
2240                 av_free(ost->pict_tmp.data[0]);
2241                 if (ost->video_resample)
2242                     sws_freeContext(ost->img_resample_ctx);
2243                 if (ost->resample)
2244                     audio_resample_close(ost->resample);
2245                 if (ost->reformat_ctx)
2246                     av_audio_convert_free(ost->reformat_ctx);
2247                 av_free(ost);
2248             }
2249         }
2250         av_free(ost_table);
2251     }
2252     return ret;
2253  fail:
2254     ret = AVERROR(ENOMEM);
2255     goto fail1;
2256 }
2257
2258 #if 0
2259 int file_read(const char *filename)
2260 {
2261     URLContext *h;
2262     unsigned char buffer[1024];
2263     int len, i;
2264
2265     if (url_open(&h, filename, O_RDONLY) < 0) {
2266         printf("could not open '%s'\n", filename);
2267         return -1;
2268     }
2269     for(;;) {
2270         len = url_read(h, buffer, sizeof(buffer));
2271         if (len <= 0)
2272             break;
2273         for(i=0;i<len;i++) putchar(buffer[i]);
2274     }
2275     url_close(h);
2276     return 0;
2277 }
2278 #endif
2279
2280 static void opt_format(const char *arg)
2281 {
2282     /* compatibility stuff for pgmyuv */
2283     if (!strcmp(arg, "pgmyuv")) {
2284         pgmyuv_compatibility_hack=1;
2285 //        opt_image_format(arg);
2286         arg = "image2";
2287         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2288     }
2289
2290     file_iformat = av_find_input_format(arg);
2291     file_oformat = guess_format(arg, NULL, NULL);
2292     if (!file_iformat && !file_oformat) {
2293         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2294         av_exit(1);
2295     }
2296 }
2297
2298 static void opt_video_rc_override_string(const char *arg)
2299 {
2300     video_rc_override_string = arg;
2301 }
2302
2303 static int opt_me_threshold(const char *opt, const char *arg)
2304 {
2305     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2306     return 0;
2307 }
2308
2309 static int opt_verbose(const char *opt, const char *arg)
2310 {
2311     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2312     av_log_set_level(verbose);
2313     return 0;
2314 }
2315
2316 static int opt_frame_rate(const char *opt, const char *arg)
2317 {
2318     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2319         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2320         av_exit(1);
2321     }
2322     return 0;
2323 }
2324
2325 static int opt_bitrate(const char *opt, const char *arg)
2326 {
2327     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2328
2329     opt_default(opt, arg);
2330
2331     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2332         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2333
2334     return 0;
2335 }
2336
2337 static void opt_frame_crop_top(const char *arg)
2338 {
2339     frame_topBand = atoi(arg);
2340     if (frame_topBand < 0) {
2341         fprintf(stderr, "Incorrect top crop size\n");
2342         av_exit(1);
2343     }
2344     if ((frame_topBand % 2) != 0) {
2345         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2346         av_exit(1);
2347     }
2348     if ((frame_topBand) >= frame_height){
2349         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2350         av_exit(1);
2351     }
2352     frame_height -= frame_topBand;
2353 }
2354
2355 static void opt_frame_crop_bottom(const char *arg)
2356 {
2357     frame_bottomBand = atoi(arg);
2358     if (frame_bottomBand < 0) {
2359         fprintf(stderr, "Incorrect bottom crop size\n");
2360         av_exit(1);
2361     }
2362     if ((frame_bottomBand % 2) != 0) {
2363         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2364         av_exit(1);
2365     }
2366     if ((frame_bottomBand) >= frame_height){
2367         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2368         av_exit(1);
2369     }
2370     frame_height -= frame_bottomBand;
2371 }
2372
2373 static void opt_frame_crop_left(const char *arg)
2374 {
2375     frame_leftBand = atoi(arg);
2376     if (frame_leftBand < 0) {
2377         fprintf(stderr, "Incorrect left crop size\n");
2378         av_exit(1);
2379     }
2380     if ((frame_leftBand % 2) != 0) {
2381         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2382         av_exit(1);
2383     }
2384     if ((frame_leftBand) >= frame_width){
2385         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2386         av_exit(1);
2387     }
2388     frame_width -= frame_leftBand;
2389 }
2390
2391 static void opt_frame_crop_right(const char *arg)
2392 {
2393     frame_rightBand = atoi(arg);
2394     if (frame_rightBand < 0) {
2395         fprintf(stderr, "Incorrect right crop size\n");
2396         av_exit(1);
2397     }
2398     if ((frame_rightBand % 2) != 0) {
2399         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2400         av_exit(1);
2401     }
2402     if ((frame_rightBand) >= frame_width){
2403         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2404         av_exit(1);
2405     }
2406     frame_width -= frame_rightBand;
2407 }
2408
2409 static void opt_frame_size(const char *arg)
2410 {
2411     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2412         fprintf(stderr, "Incorrect frame size\n");
2413         av_exit(1);
2414     }
2415     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2416         fprintf(stderr, "Frame size must be a multiple of 2\n");
2417         av_exit(1);
2418     }
2419 }
2420
2421
2422 #define SCALEBITS 10
2423 #define ONE_HALF  (1 << (SCALEBITS - 1))
2424 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2425
2426 #define RGB_TO_Y(r, g, b) \
2427 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2428   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2429
2430 #define RGB_TO_U(r1, g1, b1, shift)\
2431 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2432      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2433
2434 #define RGB_TO_V(r1, g1, b1, shift)\
2435 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2436    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2437
2438 static void opt_pad_color(const char *arg) {
2439     /* Input is expected to be six hex digits similar to
2440        how colors are expressed in html tags (but without the #) */
2441     int rgb = strtol(arg, NULL, 16);
2442     int r,g,b;
2443
2444     r = (rgb >> 16);
2445     g = ((rgb >> 8) & 255);
2446     b = (rgb & 255);
2447
2448     padcolor[0] = RGB_TO_Y(r,g,b);
2449     padcolor[1] = RGB_TO_U(r,g,b,0);
2450     padcolor[2] = RGB_TO_V(r,g,b,0);
2451 }
2452
2453 static void opt_frame_pad_top(const char *arg)
2454 {
2455     frame_padtop = atoi(arg);
2456     if (frame_padtop < 0) {
2457         fprintf(stderr, "Incorrect top pad size\n");
2458         av_exit(1);
2459     }
2460     if ((frame_padtop % 2) != 0) {
2461         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2462         av_exit(1);
2463     }
2464 }
2465
2466 static void opt_frame_pad_bottom(const char *arg)
2467 {
2468     frame_padbottom = atoi(arg);
2469     if (frame_padbottom < 0) {
2470         fprintf(stderr, "Incorrect bottom pad size\n");
2471         av_exit(1);
2472     }
2473     if ((frame_padbottom % 2) != 0) {
2474         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2475         av_exit(1);
2476     }
2477 }
2478
2479
2480 static void opt_frame_pad_left(const char *arg)
2481 {
2482     frame_padleft = atoi(arg);
2483     if (frame_padleft < 0) {
2484         fprintf(stderr, "Incorrect left pad size\n");
2485         av_exit(1);
2486     }
2487     if ((frame_padleft % 2) != 0) {
2488         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2489         av_exit(1);
2490     }
2491 }
2492
2493
2494 static void opt_frame_pad_right(const char *arg)
2495 {
2496     frame_padright = atoi(arg);
2497     if (frame_padright < 0) {
2498         fprintf(stderr, "Incorrect right pad size\n");
2499         av_exit(1);
2500     }
2501     if ((frame_padright % 2) != 0) {
2502         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2503         av_exit(1);
2504     }
2505 }
2506
2507 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2508 {
2509     int i;
2510     char fmt_str[128];
2511     for (i=-1; i < nb_fmts; i++) {
2512         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2513         fprintf(stdout, "%s\n", fmt_str);
2514     }
2515 }
2516
2517 static void opt_frame_pix_fmt(const char *arg)
2518 {
2519     if (strcmp(arg, "list"))
2520         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2521     else {
2522         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2523         av_exit(0);
2524     }
2525 }
2526
2527 static void opt_frame_aspect_ratio(const char *arg)
2528 {
2529     int x = 0, y = 0;
2530     double ar = 0;
2531     const char *p;
2532     char *end;
2533
2534     p = strchr(arg, ':');
2535     if (p) {
2536         x = strtol(arg, &end, 10);
2537         if (end == p)
2538             y = strtol(end+1, &end, 10);
2539         if (x > 0 && y > 0)
2540             ar = (double)x / (double)y;
2541     } else
2542         ar = strtod(arg, NULL);
2543
2544     if (!ar) {
2545         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2546         av_exit(1);
2547     }
2548     frame_aspect_ratio = ar;
2549 }
2550
2551 static int opt_metadata(const char *opt, const char *arg)
2552 {
2553     char *mid= strchr(arg, '=');
2554
2555     if(!mid){
2556         fprintf(stderr, "Missing =\n");
2557         av_exit(1);
2558     }
2559     *mid++= 0;
2560
2561     metadata_count++;
2562     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2563     metadata[metadata_count-1].key  = av_strdup(arg);
2564     metadata[metadata_count-1].value= av_strdup(mid);
2565
2566     return 0;
2567 }
2568
2569 static void opt_qscale(const char *arg)
2570 {
2571     video_qscale = atof(arg);
2572     if (video_qscale <= 0 ||
2573         video_qscale > 255) {
2574         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2575         av_exit(1);
2576     }
2577 }
2578
2579 static void opt_top_field_first(const char *arg)
2580 {
2581     top_field_first= atoi(arg);
2582 }
2583
2584 static int opt_thread_count(const char *opt, const char *arg)
2585 {
2586     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2587 #if !HAVE_THREADS
2588     if (verbose >= 0)
2589         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2590 #endif
2591     return 0;
2592 }
2593
2594 static void opt_audio_sample_fmt(const char *arg)
2595 {
2596     if (strcmp(arg, "list"))
2597         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2598     else {
2599         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2600         av_exit(0);
2601     }
2602 }
2603
2604 static int opt_audio_rate(const char *opt, const char *arg)
2605 {
2606     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2607     return 0;
2608 }
2609
2610 static int opt_audio_channels(const char *opt, const char *arg)
2611 {
2612     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2613     return 0;
2614 }
2615
2616 static void opt_video_channel(const char *arg)
2617 {
2618     video_channel = strtol(arg, NULL, 0);
2619 }
2620
2621 static void opt_video_standard(const char *arg)
2622 {
2623     video_standard = av_strdup(arg);
2624 }
2625
2626 static void opt_codec(int *pstream_copy, char **pcodec_name,
2627                       int codec_type, const char *arg)
2628 {
2629     av_freep(pcodec_name);
2630     if (!strcmp(arg, "copy")) {
2631         *pstream_copy = 1;
2632     } else {
2633         *pcodec_name = av_strdup(arg);
2634     }
2635 }
2636
2637 static void opt_audio_codec(const char *arg)
2638 {
2639     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2640 }
2641
2642 static void opt_audio_tag(const char *arg)
2643 {
2644     char *tail;
2645     audio_codec_tag= strtol(arg, &tail, 0);
2646
2647     if(!tail || *tail)
2648         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2649 }
2650
2651 static void opt_video_tag(const char *arg)
2652 {
2653     char *tail;
2654     video_codec_tag= strtol(arg, &tail, 0);
2655
2656     if(!tail || *tail)
2657         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2658 }
2659
2660 static void opt_video_codec(const char *arg)
2661 {
2662     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2663 }
2664
2665 static void opt_subtitle_codec(const char *arg)
2666 {
2667     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2668 }
2669
2670 static void opt_map(const char *arg)
2671 {
2672     AVStreamMap *m;
2673     char *p;
2674
2675     m = &stream_maps[nb_stream_maps++];
2676
2677     m->file_index = strtol(arg, &p, 0);
2678     if (*p)
2679         p++;
2680
2681     m->stream_index = strtol(p, &p, 0);
2682     if (*p) {
2683         p++;
2684         m->sync_file_index = strtol(p, &p, 0);
2685         if (*p)
2686             p++;
2687         m->sync_stream_index = strtol(p, &p, 0);
2688     } else {
2689         m->sync_file_index = m->file_index;
2690         m->sync_stream_index = m->stream_index;
2691     }
2692 }
2693
2694 static void opt_map_meta_data(const char *arg)
2695 {
2696     AVMetaDataMap *m;
2697     char *p;
2698
2699     m = &meta_data_maps[nb_meta_data_maps++];
2700
2701     m->out_file = strtol(arg, &p, 0);
2702     if (*p)
2703         p++;
2704
2705     m->in_file = strtol(p, &p, 0);
2706 }
2707
2708 static void opt_input_ts_scale(const char *arg)
2709 {
2710     unsigned int stream;
2711     double scale;
2712     char *p;
2713
2714     stream = strtol(arg, &p, 0);
2715     if (*p)
2716         p++;
2717     scale= strtod(p, &p);
2718
2719     if(stream >= MAX_STREAMS)
2720         av_exit(1);
2721
2722     input_files_ts_scale[nb_input_files][stream]= scale;
2723 }
2724
2725 static int opt_recording_time(const char *opt, const char *arg)
2726 {
2727     recording_time = parse_time_or_die(opt, arg, 1);
2728     return 0;
2729 }
2730
2731 static int opt_start_time(const char *opt, const char *arg)
2732 {
2733     start_time = parse_time_or_die(opt, arg, 1);
2734     return 0;
2735 }
2736
2737 static int opt_rec_timestamp(const char *opt, const char *arg)
2738 {
2739     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2740     return 0;
2741 }
2742
2743 static int opt_input_ts_offset(const char *opt, const char *arg)
2744 {
2745     input_ts_offset = parse_time_or_die(opt, arg, 1);
2746     return 0;
2747 }
2748
2749 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2750 {
2751     const char *codec_string = encoder ? "encoder" : "decoder";
2752     AVCodec *codec;
2753
2754     if(!name)
2755         return CODEC_ID_NONE;
2756     codec = encoder ?
2757         avcodec_find_encoder_by_name(name) :
2758         avcodec_find_decoder_by_name(name);
2759     if(!codec) {
2760         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2761         av_exit(1);
2762     }
2763     if(codec->type != type) {
2764         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2765         av_exit(1);
2766     }
2767     return codec->id;
2768 }
2769
2770 static void opt_input_file(const char *filename)
2771 {
2772     AVFormatContext *ic;
2773     AVFormatParameters params, *ap = &params;
2774     int err, i, ret, rfps, rfps_base;
2775     int64_t timestamp;
2776
2777     if (!strcmp(filename, "-"))
2778         filename = "pipe:";
2779
2780     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2781                     !strcmp(filename, "/dev/stdin");
2782
2783     /* get default parameters from command line */
2784     ic = avformat_alloc_context();
2785
2786     memset(ap, 0, sizeof(*ap));
2787     ap->prealloced_context = 1;
2788     ap->sample_rate = audio_sample_rate;
2789     ap->channels = audio_channels;
2790     ap->time_base.den = frame_rate.num;
2791     ap->time_base.num = frame_rate.den;
2792     ap->width = frame_width + frame_padleft + frame_padright;
2793     ap->height = frame_height + frame_padtop + frame_padbottom;
2794     ap->pix_fmt = frame_pix_fmt;
2795    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2796     ap->channel = video_channel;
2797     ap->standard = video_standard;
2798     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2799     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2800     if(pgmyuv_compatibility_hack)
2801         ap->video_codec_id= CODEC_ID_PGMYUV;
2802
2803     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2804
2805     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2806     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2807     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2808     ic->flags |= AVFMT_FLAG_NONBLOCK;
2809
2810     /* open the input file with generic libav function */
2811     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2812     if (err < 0) {
2813         print_error(filename, err);
2814         av_exit(1);
2815     }
2816     if(opt_programid) {
2817         int i;
2818         for(i=0; i<ic->nb_programs; i++)
2819             if(ic->programs[i]->id != opt_programid)
2820                 ic->programs[i]->discard = AVDISCARD_ALL;
2821     }
2822
2823     ic->loop_input = loop_input;
2824
2825     /* If not enough info to get the stream parameters, we decode the
2826        first frames to get it. (used in mpeg case for example) */
2827     ret = av_find_stream_info(ic);
2828     if (ret < 0 && verbose >= 0) {
2829         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2830         av_exit(1);
2831     }
2832
2833     timestamp = start_time;
2834     /* add the stream start time */
2835     if (ic->start_time != AV_NOPTS_VALUE)
2836         timestamp += ic->start_time;
2837
2838     /* if seeking requested, we execute it */
2839     if (start_time != 0) {
2840         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2841         if (ret < 0) {
2842             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2843                     filename, (double)timestamp / AV_TIME_BASE);
2844         }
2845         /* reset seek info */
2846         start_time = 0;
2847     }
2848
2849     /* update the current parameters so that they match the one of the input stream */
2850     for(i=0;i<ic->nb_streams;i++) {
2851         AVCodecContext *enc = ic->streams[i]->codec;
2852         if(thread_count>1)
2853             avcodec_thread_init(enc, thread_count);
2854         enc->thread_count= thread_count;
2855         switch(enc->codec_type) {
2856         case CODEC_TYPE_AUDIO:
2857             set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2858             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2859             channel_layout = enc->channel_layout;
2860             audio_channels = enc->channels;
2861             audio_sample_rate = enc->sample_rate;
2862             audio_sample_fmt = enc->sample_fmt;
2863             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2864             if(audio_disable)
2865                 ic->streams[i]->discard= AVDISCARD_ALL;
2866             break;
2867         case CODEC_TYPE_VIDEO:
2868             set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2869             frame_height = enc->height;
2870             frame_width = enc->width;
2871             if(ic->streams[i]->sample_aspect_ratio.num)
2872                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2873             else
2874                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2875             frame_aspect_ratio *= (float) enc->width / enc->height;
2876             frame_pix_fmt = enc->pix_fmt;
2877             rfps      = ic->streams[i]->r_frame_rate.num;
2878             rfps_base = ic->streams[i]->r_frame_rate.den;
2879             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2880             if(me_threshold)
2881                 enc->debug |= FF_DEBUG_MV;
2882
2883             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2884
2885                 if (verbose >= 0)
2886                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2887                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2888
2889                     (float)rfps / rfps_base, rfps, rfps_base);
2890             }
2891             /* update the current frame rate to match the stream frame rate */
2892             frame_rate.num = rfps;
2893             frame_rate.den = rfps_base;
2894
2895             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2896             if(video_disable)
2897                 ic->streams[i]->discard= AVDISCARD_ALL;
2898             else if(video_discard)
2899                 ic->streams[i]->discard= video_discard;
2900             break;
2901         case CODEC_TYPE_DATA:
2902             break;
2903         case CODEC_TYPE_SUBTITLE:
2904             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2905             if(subtitle_disable)
2906                 ic->streams[i]->discard = AVDISCARD_ALL;
2907             break;
2908         case CODEC_TYPE_ATTACHMENT:
2909         case CODEC_TYPE_UNKNOWN:
2910             nb_icodecs++;
2911             break;
2912         default:
2913             abort();
2914         }
2915     }
2916
2917     input_files[nb_input_files] = ic;
2918     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2919     /* dump the file content */
2920     if (verbose >= 0)
2921         dump_format(ic, nb_input_files, filename, 0);
2922
2923     nb_input_files++;
2924     file_iformat = NULL;
2925     file_oformat = NULL;
2926
2927     video_channel = 0;
2928
2929     av_freep(&video_codec_name);
2930     av_freep(&audio_codec_name);
2931     av_freep(&subtitle_codec_name);
2932 }
2933
2934 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2935                                          int *has_subtitle_ptr)
2936 {
2937     int has_video, has_audio, has_subtitle, i, j;
2938     AVFormatContext *ic;
2939
2940     has_video = 0;
2941     has_audio = 0;
2942     has_subtitle = 0;
2943     for(j=0;j<nb_input_files;j++) {
2944         ic = input_files[j];
2945         for(i=0;i<ic->nb_streams;i++) {
2946             AVCodecContext *enc = ic->streams[i]->codec;
2947             switch(enc->codec_type) {
2948             case CODEC_TYPE_AUDIO:
2949                 has_audio = 1;
2950                 break;
2951             case CODEC_TYPE_VIDEO:
2952                 has_video = 1;
2953                 break;
2954             case CODEC_TYPE_SUBTITLE:
2955                 has_subtitle = 1;
2956                 break;
2957             case CODEC_TYPE_DATA:
2958             case CODEC_TYPE_ATTACHMENT:
2959             case CODEC_TYPE_UNKNOWN:
2960                 break;
2961             default:
2962                 abort();
2963             }
2964         }
2965     }
2966     *has_video_ptr = has_video;
2967     *has_audio_ptr = has_audio;
2968     *has_subtitle_ptr = has_subtitle;
2969 }
2970
2971 static void new_video_stream(AVFormatContext *oc)
2972 {
2973     AVStream *st;
2974     AVCodecContext *video_enc;
2975     int codec_id;
2976
2977     st = av_new_stream(oc, oc->nb_streams);
2978     if (!st) {
2979         fprintf(stderr, "Could not alloc stream\n");
2980         av_exit(1);
2981     }
2982     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2983     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2984     video_bitstream_filters= NULL;
2985
2986     if(thread_count>1)
2987         avcodec_thread_init(st->codec, thread_count);
2988
2989     video_enc = st->codec;
2990
2991     if(video_codec_tag)
2992         video_enc->codec_tag= video_codec_tag;
2993
2994     if(   (video_global_header&1)
2995        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2996         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2997         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2998     }
2999     if(video_global_header&2){
3000         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3001         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3002     }
3003
3004     if (video_stream_copy) {
3005         st->stream_copy = 1;
3006         video_enc->codec_type = CODEC_TYPE_VIDEO;
3007         video_enc->sample_aspect_ratio =
3008         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3009     } else {
3010         const char *p;
3011         int i;
3012         AVCodec *codec;
3013         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3014
3015         if (video_codec_name) {
3016             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3017             codec = avcodec_find_encoder_by_name(video_codec_name);
3018             output_codecs[nb_ocodecs] = codec;
3019         } else {
3020             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3021             codec = avcodec_find_encoder(codec_id);
3022         }
3023
3024         video_enc->codec_id = codec_id;
3025
3026         set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3027
3028         if (codec && codec->supported_framerates && !force_fps)
3029             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3030         video_enc->time_base.den = fps.num;
3031         video_enc->time_base.num = fps.den;
3032
3033         video_enc->width = frame_width + frame_padright + frame_padleft;
3034         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3035         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3036         video_enc->pix_fmt = frame_pix_fmt;
3037         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3038
3039         if(codec && codec->pix_fmts){
3040             const enum PixelFormat *p= codec->pix_fmts;
3041             for(; *p!=-1; p++){
3042                 if(*p == video_enc->pix_fmt)
3043                     break;
3044             }
3045             if(*p == -1)
3046                 video_enc->pix_fmt = codec->pix_fmts[0];
3047         }
3048
3049         if (intra_only)
3050             video_enc->gop_size = 0;
3051         if (video_qscale || same_quality) {
3052             video_enc->flags |= CODEC_FLAG_QSCALE;
3053             video_enc->global_quality=
3054                 st->quality = FF_QP2LAMBDA * video_qscale;
3055         }
3056
3057         if(intra_matrix)
3058             video_enc->intra_matrix = intra_matrix;
3059         if(inter_matrix)
3060             video_enc->inter_matrix = inter_matrix;
3061
3062         video_enc->thread_count = thread_count;
3063         p= video_rc_override_string;
3064         for(i=0; p; i++){
3065             int start, end, q;
3066             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3067             if(e!=3){
3068                 fprintf(stderr, "error parsing rc_override\n");
3069                 av_exit(1);
3070             }
3071             video_enc->rc_override=
3072                 av_realloc(video_enc->rc_override,
3073                            sizeof(RcOverride)*(i+1));
3074             video_enc->rc_override[i].start_frame= start;
3075             video_enc->rc_override[i].end_frame  = end;
3076             if(q>0){
3077                 video_enc->rc_override[i].qscale= q;
3078                 video_enc->rc_override[i].quality_factor= 1.0;
3079             }
3080             else{
3081                 video_enc->rc_override[i].qscale= 0;
3082                 video_enc->rc_override[i].quality_factor= -q/100.0;
3083             }
3084             p= strchr(p, '/');
3085             if(p) p++;
3086         }
3087         video_enc->rc_override_count=i;
3088         if (!video_enc->rc_initial_buffer_occupancy)
3089             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3090         video_enc->me_threshold= me_threshold;
3091         video_enc->intra_dc_precision= intra_dc_precision - 8;
3092
3093         if (do_psnr)
3094             video_enc->flags|= CODEC_FLAG_PSNR;
3095
3096         /* two pass mode */
3097         if (do_pass) {
3098             if (do_pass == 1) {
3099                 video_enc->flags |= CODEC_FLAG_PASS1;
3100             } else {
3101                 video_enc->flags |= CODEC_FLAG_PASS2;
3102             }
3103         }
3104     }
3105     nb_ocodecs++;
3106
3107     /* reset some key parameters */
3108     video_disable = 0;
3109     av_freep(&video_codec_name);
3110     video_stream_copy = 0;
3111 }
3112
3113 static void new_audio_stream(AVFormatContext *oc)
3114 {
3115     AVStream *st;
3116     AVCodecContext *audio_enc;
3117     int codec_id;
3118
3119     st = av_new_stream(oc, oc->nb_streams);
3120     if (!st) {
3121         fprintf(stderr, "Could not alloc stream\n");
3122         av_exit(1);
3123     }
3124     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3125
3126     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3127     audio_bitstream_filters= NULL;
3128
3129     if(thread_count>1)
3130         avcodec_thread_init(st->codec, thread_count);
3131
3132     audio_enc = st->codec;
3133     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3134
3135     if(audio_codec_tag)
3136         audio_enc->codec_tag= audio_codec_tag;
3137
3138     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3139         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3140         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3141     }
3142     if (audio_stream_copy) {
3143         st->stream_copy = 1;
3144         audio_enc->channels = audio_channels;
3145     } else {
3146         AVCodec *codec;
3147
3148         set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3149
3150         if (audio_codec_name) {
3151             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3152             codec = avcodec_find_encoder_by_name(audio_codec_name);
3153             output_codecs[nb_ocodecs] = codec;
3154         } else {
3155             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3156             codec = avcodec_find_encoder(codec_id);
3157         }
3158         audio_enc->codec_id = codec_id;
3159
3160         if (audio_qscale > QSCALE_NONE) {
3161             audio_enc->flags |= CODEC_FLAG_QSCALE;
3162             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3163         }
3164         audio_enc->thread_count = thread_count;
3165         audio_enc->channels = audio_channels;
3166         audio_enc->sample_fmt = audio_sample_fmt;
3167         audio_enc->channel_layout = channel_layout;
3168
3169         if(codec && codec->sample_fmts){
3170             const enum SampleFormat *p= codec->sample_fmts;
3171             for(; *p!=-1; p++){
3172                 if(*p == audio_enc->sample_fmt)
3173                     break;
3174             }
3175             if(*p == -1)
3176                 audio_enc->sample_fmt = codec->sample_fmts[0];
3177         }
3178     }
3179     nb_ocodecs++;
3180     audio_enc->sample_rate = audio_sample_rate;
3181     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3182     if (audio_language) {
3183         av_metadata_set(&st->metadata, "language", audio_language);
3184         av_free(audio_language);
3185         audio_language = NULL;
3186     }
3187
3188     /* reset some key parameters */
3189     audio_disable = 0;
3190     av_freep(&audio_codec_name);
3191     audio_stream_copy = 0;
3192 }
3193
3194 static void new_subtitle_stream(AVFormatContext *oc)
3195 {
3196     AVStream *st;
3197     AVCodecContext *subtitle_enc;
3198
3199     st = av_new_stream(oc, oc->nb_streams);
3200     if (!st) {
3201         fprintf(stderr, "Could not alloc stream\n");
3202         av_exit(1);
3203     }
3204     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3205
3206     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3207     subtitle_bitstream_filters= NULL;
3208
3209     subtitle_enc = st->codec;
3210     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3211     if (subtitle_stream_copy) {
3212         st->stream_copy = 1;
3213     } else {
3214         set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3215         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3216         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3217     }
3218     nb_ocodecs++;
3219
3220     if (subtitle_language) {
3221         av_metadata_set(&st->metadata, "language", subtitle_language);
3222         av_free(subtitle_language);
3223         subtitle_language = NULL;
3224     }
3225
3226     subtitle_disable = 0;
3227     av_freep(&subtitle_codec_name);
3228     subtitle_stream_copy = 0;
3229 }
3230
3231 static void opt_new_audio_stream(void)
3232 {
3233     AVFormatContext *oc;
3234     if (nb_output_files <= 0) {
3235         fprintf(stderr, "At least one output file must be specified\n");
3236         av_exit(1);
3237     }
3238     oc = output_files[nb_output_files - 1];
3239     new_audio_stream(oc);
3240 }
3241
3242 static void opt_new_video_stream(void)
3243 {
3244     AVFormatContext *oc;
3245     if (nb_output_files <= 0) {
3246         fprintf(stderr, "At least one output file must be specified\n");
3247         av_exit(1);
3248     }
3249     oc = output_files[nb_output_files - 1];
3250     new_video_stream(oc);
3251 }
3252
3253 static void opt_new_subtitle_stream(void)
3254 {
3255     AVFormatContext *oc;
3256     if (nb_output_files <= 0) {
3257         fprintf(stderr, "At least one output file must be specified\n");
3258         av_exit(1);
3259     }
3260     oc = output_files[nb_output_files - 1];
3261     new_subtitle_stream(oc);
3262 }
3263
3264 static void opt_output_file(const char *filename)
3265 {
3266     AVFormatContext *oc;
3267     int use_video, use_audio, use_subtitle;
3268     int input_has_video, input_has_audio, input_has_subtitle;
3269     AVFormatParameters params, *ap = &params;
3270
3271     if (!strcmp(filename, "-"))
3272         filename = "pipe:";
3273
3274     oc = avformat_alloc_context();
3275
3276     if (!file_oformat) {
3277         file_oformat = guess_format(NULL, filename, NULL);
3278         if (!file_oformat) {
3279             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3280                     filename);
3281             av_exit(1);
3282         }
3283     }
3284
3285     oc->oformat = file_oformat;
3286     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3287
3288     if (!strcmp(file_oformat->name, "ffm") &&
3289         av_strstart(filename, "http:", NULL)) {
3290         /* special case for files sent to ffserver: we get the stream
3291            parameters from ffserver */
3292         int err = read_ffserver_streams(oc, filename);
3293         if (err < 0) {
3294             print_error(filename, err);
3295             av_exit(1);
3296         }
3297     } else {
3298         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3299         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3300         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3301
3302         /* disable if no corresponding type found and at least one
3303            input file */
3304         if (nb_input_files > 0) {
3305             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3306                                          &input_has_subtitle);
3307             if (!input_has_video)
3308                 use_video = 0;
3309             if (!input_has_audio)
3310                 use_audio = 0;
3311             if (!input_has_subtitle)
3312                 use_subtitle = 0;
3313         }
3314
3315         /* manual disable */
3316         if (audio_disable) {
3317             use_audio = 0;
3318         }
3319         if (video_disable) {
3320             use_video = 0;
3321         }
3322         if (subtitle_disable) {
3323             use_subtitle = 0;
3324         }
3325
3326         if (use_video) {
3327             new_video_stream(oc);
3328         }
3329
3330         if (use_audio) {
3331             new_audio_stream(oc);
3332         }
3333
3334         if (use_subtitle) {
3335             new_subtitle_stream(oc);
3336         }
3337
3338         oc->timestamp = rec_timestamp;
3339
3340         for(; metadata_count>0; metadata_count--){
3341             av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3342                                            metadata[metadata_count-1].value);
3343         }
3344         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3345     }
3346
3347     output_files[nb_output_files++] = oc;
3348
3349     /* check filename in case of an image number is expected */
3350     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3351         if (!av_filename_number_test(oc->filename)) {
3352             print_error(oc->filename, AVERROR_NUMEXPECTED);
3353             av_exit(1);
3354         }
3355     }
3356
3357     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3358         /* test if it already exists to avoid loosing precious files */
3359         if (!file_overwrite &&
3360             (strchr(filename, ':') == NULL ||
3361              filename[1] == ':' ||
3362              av_strstart(filename, "file:", NULL))) {
3363             if (url_exist(filename)) {
3364                 int c;
3365
3366                 if (!using_stdin) {
3367                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3368                     fflush(stderr);
3369                     c = getchar();
3370                     if (toupper(c) != 'Y') {
3371                         fprintf(stderr, "Not overwriting - exiting\n");
3372                         av_exit(1);
3373                     }
3374                 }
3375                 else {
3376                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3377                     av_exit(1);
3378                 }
3379             }
3380         }
3381
3382         /* open the file */
3383         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3384             fprintf(stderr, "Could not open '%s'\n", filename);
3385             av_exit(1);
3386         }
3387     }
3388
3389     memset(ap, 0, sizeof(*ap));
3390     if (av_set_parameters(oc, ap) < 0) {
3391         fprintf(stderr, "%s: Invalid encoding parameters\n",
3392                 oc->filename);
3393         av_exit(1);
3394     }
3395
3396     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3397     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3398     oc->loop_output = loop_output;
3399     oc->flags |= AVFMT_FLAG_NONBLOCK;
3400
3401     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3402
3403     /* reset some options */
3404     file_oformat = NULL;
3405     file_iformat = NULL;
3406 }
3407
3408 /* same option as mencoder */
3409 static void opt_pass(const char *pass_str)
3410 {
3411     int pass;
3412     pass = atoi(pass_str);
3413     if (pass != 1 && pass != 2) {
3414         fprintf(stderr, "pass number can be only 1 or 2\n");
3415         av_exit(1);
3416     }
3417     do_pass = pass;
3418 }
3419
3420 static int64_t getutime(void)
3421 {
3422 #if HAVE_GETRUSAGE
3423     struct rusage rusage;
3424
3425     getrusage(RUSAGE_SELF, &rusage);
3426     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3427 #elif HAVE_GETPROCESSTIMES
3428     HANDLE proc;
3429     FILETIME c, e, k, u;
3430     proc = GetCurrentProcess();
3431     GetProcessTimes(proc, &c, &e, &k, &u);
3432     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3433 #else
3434     return av_gettime();
3435 #endif
3436 }
3437
3438 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3439 {
3440     int i;
3441     const char *p = str;
3442     for(i = 0;; i++) {
3443         dest[i] = atoi(p);
3444         if(i == 63)
3445             break;
3446         p = strchr(p, ',');
3447         if(!p) {
3448             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3449             av_exit(1);
3450         }
3451         p++;
3452     }
3453 }
3454
3455 static void opt_inter_matrix(const char *arg)
3456 {
3457     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3458     parse_matrix_coeffs(inter_matrix, arg);
3459 }
3460
3461 static void opt_intra_matrix(const char *arg)
3462 {
3463     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3464     parse_matrix_coeffs(intra_matrix, arg);
3465 }
3466
3467 /**
3468  * Trivial log callback.
3469  * Only suitable for show_help and similar since it lacks prefix handling.
3470  */
3471 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3472 {
3473     vfprintf(stdout, fmt, vl);
3474 }
3475
3476 static void show_help(void)
3477 {
3478     av_log_set_callback(log_callback_help);
3479     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3480            "Hyper fast Audio and Video encoder\n");
3481     printf("\n");
3482     show_help_options(options, "Main options:\n",
3483                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3484     show_help_options(options, "\nAdvanced options:\n",
3485                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3486                       OPT_EXPERT);
3487     show_help_options(options, "\nVideo options:\n",
3488                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3489                       OPT_VIDEO);
3490     show_help_options(options, "\nAdvanced Video options:\n",
3491                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3492                       OPT_VIDEO | OPT_EXPERT);
3493     show_help_options(options, "\nAudio options:\n",
3494                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3495                       OPT_AUDIO);
3496     show_help_options(options, "\nAdvanced Audio options:\n",
3497                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3498                       OPT_AUDIO | OPT_EXPERT);
3499     show_help_options(options, "\nSubtitle options:\n",
3500                       OPT_SUBTITLE | OPT_GRAB,
3501                       OPT_SUBTITLE);
3502     show_help_options(options, "\nAudio/Video grab options:\n",
3503                       OPT_GRAB,
3504                       OPT_GRAB);
3505     printf("\n");
3506     av_opt_show(avctx_opts[0], NULL);
3507     printf("\n");
3508     av_opt_show(avformat_opts, NULL);
3509     printf("\n");
3510     av_opt_show(sws_opts, NULL);
3511 }
3512
3513 static void opt_target(const char *arg)
3514 {
3515     int norm = -1;
3516     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3517
3518     if(!strncmp(arg, "pal-", 4)) {
3519         norm = 0;
3520         arg += 4;
3521     } else if(!strncmp(arg, "ntsc-", 5)) {
3522         norm = 1;
3523         arg += 5;
3524     } else if(!strncmp(arg, "film-", 5)) {
3525         norm = 2;
3526         arg += 5;
3527     } else {
3528         int fr;
3529         /* Calculate FR via float to avoid int overflow */
3530         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3531         if(fr == 25000) {
3532             norm = 0;
3533         } else if((fr == 29970) || (fr == 23976)) {
3534             norm = 1;
3535         } else {
3536             /* Try to determine PAL/NTSC by peeking in the input files */
3537             if(nb_input_files) {
3538                 int i, j;
3539                 for(j = 0; j < nb_input_files; j++) {
3540                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3541                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3542                         if(c->codec_type != CODEC_TYPE_VIDEO)
3543                             continue;
3544                         fr = c->time_base.den * 1000 / c->time_base.num;
3545                         if(fr == 25000) {
3546                             norm = 0;
3547                             break;
3548                         } else if((fr == 29970) || (fr == 23976)) {
3549                             norm = 1;
3550                             break;
3551                         }
3552                     }
3553                     if(norm >= 0)
3554                         break;
3555                 }
3556             }
3557         }
3558         if(verbose && norm >= 0)
3559             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3560     }
3561
3562     if(norm < 0) {
3563         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3564         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3565         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3566         av_exit(1);
3567     }
3568
3569     if(!strcmp(arg, "vcd")) {
3570
3571         opt_video_codec("mpeg1video");
3572         opt_audio_codec("mp2");
3573         opt_format("vcd");
3574
3575         opt_frame_size(norm ? "352x240" : "352x288");
3576         opt_frame_rate(NULL, frame_rates[norm]);
3577         opt_default("gop", norm ? "18" : "15");
3578
3579         opt_default("b", "1150000");
3580         opt_default("maxrate", "1150000");
3581         opt_default("minrate", "1150000");
3582         opt_default("bufsize", "327680"); // 40*1024*8;
3583
3584         opt_default("ab", "224000");
3585         audio_sample_rate = 44100;
3586         audio_channels = 2;
3587
3588         opt_default("packetsize", "2324");
3589         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3590
3591         /* We have to offset the PTS, so that it is consistent with the SCR.
3592            SCR starts at 36000, but the first two packs contain only padding
3593            and the first pack from the other stream, respectively, may also have
3594            been written before.
3595            So the real data starts at SCR 36000+3*1200. */
3596         mux_preload= (36000+3*1200) / 90000.0; //0.44
3597     } else if(!strcmp(arg, "svcd")) {
3598
3599         opt_video_codec("mpeg2video");
3600         opt_audio_codec("mp2");
3601         opt_format("svcd");
3602
3603         opt_frame_size(norm ? "480x480" : "480x576");
3604         opt_frame_rate(NULL, frame_rates[norm]);
3605         opt_default("gop", norm ? "18" : "15");
3606
3607         opt_default("b", "2040000");
3608         opt_default("maxrate", "2516000");
3609         opt_default("minrate", "0"); //1145000;
3610         opt_default("bufsize", "1835008"); //224*1024*8;
3611         opt_default("flags", "+scan_offset");
3612
3613
3614         opt_default("ab", "224000");
3615         audio_sample_rate = 44100;
3616
3617         opt_default("packetsize", "2324");
3618
3619     } else if(!strcmp(arg, "dvd")) {
3620
3621         opt_video_codec("mpeg2video");
3622         opt_audio_codec("ac3");
3623         opt_format("dvd");
3624
3625         opt_frame_size(norm ? "720x480" : "720x576");
3626         opt_frame_rate(NULL, frame_rates[norm]);
3627         opt_default("gop", norm ? "18" : "15");
3628
3629         opt_default("b", "6000000");
3630         opt_default("maxrate", "9000000");
3631         opt_default("minrate", "0"); //1500000;
3632         opt_default("bufsize", "1835008"); //224*1024*8;
3633
3634         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3635         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3636
3637         opt_default("ab", "448000");
3638         audio_sample_rate = 48000;
3639
3640     } else if(!strncmp(arg, "dv", 2)) {
3641
3642         opt_format("dv");
3643
3644         opt_frame_size(norm ? "720x480" : "720x576");
3645         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3646                                              (norm ? "yuv411p" : "yuv420p"));
3647         opt_frame_rate(NULL, frame_rates[norm]);
3648
3649         audio_sample_rate = 48000;
3650         audio_channels = 2;
3651
3652     } else {
3653         fprintf(stderr, "Unknown target: %s\n", arg);
3654         av_exit(1);
3655     }
3656 }
3657
3658 static void opt_vstats_file (const char *arg)
3659 {
3660     av_free (vstats_filename);
3661     vstats_filename=av_strdup (arg);
3662 }
3663
3664 static void opt_vstats (void)
3665 {
3666     char filename[40];
3667     time_t today2 = time(NULL);
3668     struct tm *today = localtime(&today2);
3669
3670     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3671              today->tm_sec);
3672     opt_vstats_file(filename);
3673 }
3674
3675 static int opt_bsf(const char *opt, const char *arg)
3676 {
3677     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3678     AVBitStreamFilterContext **bsfp;
3679
3680     if(!bsfc){
3681         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3682         av_exit(1);
3683     }
3684
3685     bsfp= *opt == 'v' ? &video_bitstream_filters :
3686           *opt == 'a' ? &audio_bitstream_filters :
3687                         &subtitle_bitstream_filters;
3688     while(*bsfp)
3689         bsfp= &(*bsfp)->next;
3690
3691     *bsfp= bsfc;
3692
3693     return 0;
3694 }
3695
3696 static int opt_preset(const char *opt, const char *arg)
3697 {
3698     FILE *f=NULL;
3699     char filename[1000], tmp[1000], tmp2[1000], line[1000];
3700     int i;
3701     const char *base[2]= { getenv("HOME"),
3702                            FFMPEG_DATADIR,
3703                          };
3704
3705     for(i=!base[0]; i<2 && !f; i++){
3706         snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3707         f= fopen(filename, "r");
3708         if(!f){
3709             char *codec_name= *opt == 'v' ? video_codec_name :
3710                               *opt == 'a' ? audio_codec_name :
3711                                             subtitle_codec_name;
3712             snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i],  i ? "" : "/.ffmpeg", codec_name, arg);
3713             f= fopen(filename, "r");
3714         }
3715     }
3716     if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3717               is_dos_path(arg))){
3718         av_strlcpy(filename, arg, sizeof(filename));
3719         f= fopen(filename, "r");
3720     }
3721
3722     if(!f){
3723         fprintf(stderr, "File for preset '%s' not found\n", arg);
3724         av_exit(1);
3725     }
3726
3727     while(!feof(f)){
3728         int e= fscanf(f, "%999[^\n]\n", line) - 1;
3729         if(line[0] == '#' && !e)
3730             continue;
3731         e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3732         if(e){
3733             fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3734             av_exit(1);
3735         }
3736         if(!strcmp(tmp, "acodec")){
3737             opt_audio_codec(tmp2);
3738         }else if(!strcmp(tmp, "vcodec")){
3739             opt_video_codec(tmp2);
3740         }else if(!strcmp(tmp, "scodec")){
3741             opt_subtitle_codec(tmp2);
3742         }else if(opt_default(tmp, tmp2) < 0){
3743             fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3744             av_exit(1);
3745         }
3746     }
3747
3748     fclose(f);
3749
3750     return 0;
3751 }
3752
3753 static const OptionDef options[] = {
3754     /* main options */
3755     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3756     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3757     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3758     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3759     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3760     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3761     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3762     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3763     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3764     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3765     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3766     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3767     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3768     { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3769     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3770     { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3771     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3772     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3773       "add timings for benchmarking" },
3774     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3775       "dump each input packet" },
3776     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3777       "when dumping packets, also dump the payload" },
3778     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3779     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3780     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3781     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3782     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3783     { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3784     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3785     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3786     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3787     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3788     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3789     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3790     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3791     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3792     { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3793     { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
3794
3795     /* video options */
3796     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3797     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3798     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3799     { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3800     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3801     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3802     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3803     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3804     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3805     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3806     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3807     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3808     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3809     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3810     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3811     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3812     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3813     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3814     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3815     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3816     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3817     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3818     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3819     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3820       "use same video quality as source (implies VBR)" },
3821     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3822     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3823     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3824       "deinterlace pictures" },
3825     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3826     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3827     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3828     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3829     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3830     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3831     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3832     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3833     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3834     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3835     { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3836
3837     /* audio options */
3838     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3839     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3840     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3841     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3842     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3843     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3844     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3845     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3846     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3847     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3848     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3849     { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3850
3851     /* subtitle options */
3852     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3853     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3854     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3855     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3856
3857     /* grab options */
3858     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3859     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3860     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3861
3862     /* muxer options */
3863     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3864     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3865
3866     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3867     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3868     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3869
3870     { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3871     { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3872     { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3873
3874     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3875     { NULL, },
3876 };
3877
3878 int main(int argc, char **argv)
3879 {
3880     int i;
3881     int64_t ti;
3882
3883     avcodec_register_all();
3884     avdevice_register_all();
3885     av_register_all();
3886
3887     if(isatty(STDIN_FILENO))
3888         url_set_interrupt_cb(decode_interrupt_cb);
3889
3890     for(i=0; i<CODEC_TYPE_NB; i++){
3891         avctx_opts[i]= avcodec_alloc_context2(i);
3892     }
3893     avformat_opts = avformat_alloc_context();
3894     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3895
3896     show_banner();
3897
3898     /* parse options */
3899     parse_options(argc, argv, options, opt_output_file);
3900
3901     /* file converter / grab */
3902     if (nb_output_files <= 0) {
3903         fprintf(stderr, "At least one output file must be specified\n");
3904         av_exit(1);
3905     }
3906
3907     if (nb_input_files == 0) {
3908         fprintf(stderr, "At least one input file must be specified\n");
3909         av_exit(1);
3910     }
3911
3912     ti = getutime();
3913     if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3914                   stream_maps, nb_stream_maps) < 0)
3915         av_exit(1);
3916     ti = getutime() - ti;
3917     if (do_benchmark) {
3918         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3919     }
3920
3921     return av_exit(0);
3922 }