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