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