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