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