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