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

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