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