git.sesse.net Git - ffmpeg/blob - ffmpeg.c

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