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