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