* fixing a bug preventing default values to be set correctly
[ffmpeg.git] / 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 #include "config.h"
23 #include <ctype.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include "avformat.h"
31 #include "avdevice.h"
32 #include "swscale.h"
33 #include "framehook.h"
34 #include "opt.h"
35 #include "fifo.h"
36 #include "avstring.h"
37 #include "os_support.h"
38
39 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
40 #include <windows.h>
41 #endif
42
43 #if defined(HAVE_TERMIOS_H)
44 #include <unistd.h>
45 #include <fcntl.h>
46 #include <sys/ioctl.h>
47 #include <sys/time.h>
48 #include <termios.h>
49 #include <sys/resource.h>
50 #elif defined(HAVE_CONIO_H)
51 #include <conio.h>
52 #endif
53 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
54 #include <time.h>
55
56 #include "version.h"
57 #include "cmdutils.h"
58
59 #undef NDEBUG
60 #include <assert.h>
61
62 #if !defined(INFINITY) && defined(HUGE_VAL)
63 #define INFINITY HUGE_VAL
64 #endif
65
66 #undef exit
67
68 static const char program_name[] = "FFmpeg";
69 static const int program_birth_year = 2000;
70
71 /* select an input stream for an output stream */
72 typedef struct AVStreamMap {
73     int file_index;
74     int stream_index;
75     int sync_file_index;
76     int sync_stream_index;
77 } AVStreamMap;
78
79 /** select an input file for an output file */
80 typedef struct AVMetaDataMap {
81     int out_file;
82     int in_file;
83 } AVMetaDataMap;
84
85 extern const OptionDef options[];
86
87 #define MAX_FILES 20
88
89 static AVFormatContext *input_files[MAX_FILES];
90 static int64_t input_files_ts_offset[MAX_FILES];
91 static int nb_input_files = 0;
92
93 static AVFormatContext *output_files[MAX_FILES];
94 static int nb_output_files = 0;
95
96 static AVStreamMap stream_maps[MAX_FILES];
97 static int nb_stream_maps;
98
99 static AVMetaDataMap meta_data_maps[MAX_FILES];
100 static int nb_meta_data_maps;
101
102 static AVInputFormat *file_iformat;
103 static AVOutputFormat *file_oformat;
104 static int frame_width  = 0;
105 static int frame_height = 0;
106 static float frame_aspect_ratio = 0;
107 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
108 static int frame_padtop  = 0;
109 static int frame_padbottom = 0;
110 static int frame_padleft  = 0;
111 static int frame_padright = 0;
112 static int padcolor[3] = {16,128,128}; /* default to black */
113 static int frame_topBand  = 0;
114 static int frame_bottomBand = 0;
115 static int frame_leftBand  = 0;
116 static int frame_rightBand = 0;
117 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
118 static AVRational frame_rate = (AVRational) {0,0};
119 static float video_qscale = 0;
120 static int video_qdiff = 3;
121 static uint16_t *intra_matrix = NULL;
122 static uint16_t *inter_matrix = NULL;
123 #if 0 //experimental, (can be removed)
124 static float video_rc_qsquish=1.0;
125 static float video_rc_qmod_amp=0;
126 static int video_rc_qmod_freq=0;
127 #endif
128 static const char *video_rc_override_string=NULL;
129 static int video_disable = 0;
130 static int video_discard = 0;
131 static char *video_codec_name = NULL;
132 static int video_codec_tag = 0;
133 static int same_quality = 0;
134 static int do_deinterlace = 0;
135 static int strict = 0;
136 static int top_field_first = -1;
137 static int me_threshold = 0;
138 static int intra_dc_precision = 8;
139 static int loop_input = 0;
140 static int loop_output = AVFMT_NOOUTPUTLOOP;
141 static int qp_hist = 0;
142
143 static int intra_only = 0;
144 static int audio_sample_rate = 44100;
145 #define QSCALE_NONE -99999
146 static float audio_qscale = QSCALE_NONE;
147 static int audio_disable = 0;
148 static int audio_channels = 1;
149 static char  *audio_codec_name = NULL;
150 static int audio_codec_tag = 0;
151 static char *audio_language = NULL;
152
153 static int subtitle_disable = 0;
154 static char *subtitle_codec_name = NULL;
155 static char *subtitle_language = NULL;
156
157 static float mux_preload= 0.5;
158 static float mux_max_delay= 0.7;
159
160 static int64_t recording_time = 0;
161 static int64_t start_time = 0;
162 static int64_t rec_timestamp = 0;
163 static int64_t input_ts_offset = 0;
164 static int file_overwrite = 0;
165 static char *str_title = NULL;
166 static char *str_author = NULL;
167 static char *str_copyright = NULL;
168 static char *str_comment = NULL;
169 static char *str_album = NULL;
170 static int do_benchmark = 0;
171 static int do_hex_dump = 0;
172 static int do_pkt_dump = 0;
173 static int do_psnr = 0;
174 static int do_pass = 0;
175 static char *pass_logfilename = NULL;
176 static int audio_stream_copy = 0;
177 static int video_stream_copy = 0;
178 static int subtitle_stream_copy = 0;
179 static int video_sync_method= 1;
180 static int audio_sync_method= 0;
181 static float audio_drift_threshold= 0.1;
182 static int copy_ts= 0;
183 static int opt_shortest = 0; //
184 static int video_global_header = 0;
185 static char *vstats_filename;
186 static FILE *vstats_file;
187 static int opt_programid = 0;
188
189 static int rate_emu = 0;
190
191 static int  video_channel = 0;
192 static char *video_standard;
193
194 static int audio_volume = 256;
195
196 static int using_stdin = 0;
197 static int using_vhook = 0;
198 static int verbose = 1;
199 static int thread_count= 1;
200 static int q_pressed = 0;
201 static int64_t video_size = 0;
202 static int64_t audio_size = 0;
203 static int64_t extra_size = 0;
204 static int nb_frames_dup = 0;
205 static int nb_frames_drop = 0;
206 static int input_sync;
207 static uint64_t limit_filesize = 0; //
208
209 static int pgmyuv_compatibility_hack=0;
210 static float dts_delta_threshold = 10;
211
212 static int sws_flags = SWS_BICUBIC;
213
214 static const char **opt_names;
215 static int opt_name_count;
216 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
217 static AVFormatContext *avformat_opts;
218 static struct SwsContext *sws_opts;
219 static int64_t timer_start;
220
221 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
222 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
223 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
224
225 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226
227 struct AVInputStream;
228
229 typedef struct AVOutputStream {
230     int file_index;          /* file index */
231     int index;               /* stream index in the output file */
232     int source_index;        /* AVInputStream index */
233     AVStream *st;            /* stream in the output file */
234     int encoding_needed;     /* true if encoding needed for this stream */
235     int frame_number;
236     /* input pts and corresponding output pts
237        for A/V sync */
238     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
239     struct AVInputStream *sync_ist; /* input stream to sync against */
240     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
241     /* video only */
242     int video_resample;
243     AVFrame pict_tmp;      /* temporary image for resampling */
244     struct SwsContext *img_resample_ctx; /* for image resampling */
245     int resample_height;
246
247     int video_crop;
248     int topBand;             /* cropping area sizes */
249     int leftBand;
250
251     int video_pad;
252     int padtop;              /* padding area sizes */
253     int padbottom;
254     int padleft;
255     int padright;
256
257     /* audio only */
258     int audio_resample;
259     ReSampleContext *resample; /* for audio resampling */
260     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
261     FILE *logfile;
262 } AVOutputStream;
263
264 typedef struct AVInputStream {
265     int file_index;
266     int index;
267     AVStream *st;
268     int discard;             /* true if stream data should be discarded */
269     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
270     int64_t sample_index;      /* current sample */
271
272     int64_t       start;     /* time when read started */
273     unsigned long frame;     /* current frame */
274     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
275                                 is not defined */
276     int64_t       pts;       /* current pts */
277     int is_start;            /* is 1 at the start and after a discontinuity */
278 } AVInputStream;
279
280 typedef struct AVInputFile {
281     int eof_reached;      /* true if eof reached */
282     int ist_index;        /* index of first stream in ist_table */
283     int buffer_size;      /* current total buffer size */
284     int nb_streams;       /* nb streams we are aware of */
285 } AVInputFile;
286
287 #ifdef HAVE_TERMIOS_H
288
289 /* init terminal so that we can grab keys */
290 static struct termios oldtty;
291 #endif
292
293 static void term_exit(void)
294 {
295 #ifdef HAVE_TERMIOS_H
296     tcsetattr (0, TCSANOW, &oldtty);
297 #endif
298 }
299
300 static volatile sig_atomic_t received_sigterm = 0;
301
302 static void
303 sigterm_handler(int sig)
304 {
305     received_sigterm = sig;
306     term_exit();
307 }
308
309 static void term_init(void)
310 {
311 #ifdef HAVE_TERMIOS_H
312     struct termios tty;
313
314     tcgetattr (0, &tty);
315     oldtty = tty;
316
317     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
318                           |INLCR|IGNCR|ICRNL|IXON);
319     tty.c_oflag |= OPOST;
320     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
321     tty.c_cflag &= ~(CSIZE|PARENB);
322     tty.c_cflag |= CS8;
323     tty.c_cc[VMIN] = 1;
324     tty.c_cc[VTIME] = 0;
325
326     tcsetattr (0, TCSANOW, &tty);
327     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
328 #endif
329
330     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
331     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
332     /*
333     register a function to be called at normal program termination
334     */
335     atexit(term_exit);
336 #ifdef CONFIG_BEOS_NETSERVER
337     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
338 #endif
339 }
340
341 /* read a key without blocking */
342 static int read_key(void)
343 {
344 #if defined(HAVE_TERMIOS_H)
345     int n = 1;
346     unsigned char ch;
347 #ifndef CONFIG_BEOS_NETSERVER
348     struct timeval tv;
349     fd_set rfds;
350
351     FD_ZERO(&rfds);
352     FD_SET(0, &rfds);
353     tv.tv_sec = 0;
354     tv.tv_usec = 0;
355     n = select(1, &rfds, NULL, NULL, &tv);
356 #endif
357     if (n > 0) {
358         n = read(0, &ch, 1);
359         if (n == 1)
360             return ch;
361
362         return n;
363     }
364 #elif defined(HAVE_CONIO_H)
365     if(kbhit())
366         return(getch());
367 #endif
368     return -1;
369 }
370
371 static int decode_interrupt_cb(void)
372 {
373     return q_pressed || (q_pressed = read_key() == 'q');
374 }
375
376 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
377 {
378     int i, err;
379     AVFormatContext *ic;
380
381     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
382     if (err < 0)
383         return err;
384     /* copy stream format */
385     s->nb_streams = ic->nb_streams;
386     for(i=0;i<ic->nb_streams;i++) {
387         AVStream *st;
388
389         // FIXME: a more elegant solution is needed
390         st = av_mallocz(sizeof(AVStream));
391         memcpy(st, ic->streams[i], sizeof(AVStream));
392         st->codec = avcodec_alloc_context();
393         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
394         s->streams[i] = st;
395     }
396
397     av_close_input_file(ic);
398     return 0;
399 }
400
401 static double
402 get_sync_ipts(const AVOutputStream *ost)
403 {
404     const AVInputStream *ist = ost->sync_ist;
405     return (double)(ist->pts - start_time)/AV_TIME_BASE;
406 }
407
408 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
409     int ret;
410
411     while(bsfc){
412         AVPacket new_pkt= *pkt;
413         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
414                                           &new_pkt.data, &new_pkt.size,
415                                           pkt->data, pkt->size,
416                                           pkt->flags & PKT_FLAG_KEY);
417         if(a){
418             av_free_packet(pkt);
419             new_pkt.destruct= av_destruct_packet;
420         }
421         *pkt= new_pkt;
422
423         bsfc= bsfc->next;
424     }
425
426     ret= av_interleaved_write_frame(s, pkt);
427     if(ret < 0){
428         print_error("av_interleaved_write_frame()", ret);
429         exit(1);
430     }
431 }
432
433 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
434
435 static void do_audio_out(AVFormatContext *s,
436                          AVOutputStream *ost,
437                          AVInputStream *ist,
438                          unsigned char *buf, int size)
439 {
440     uint8_t *buftmp;
441     static uint8_t *audio_buf = NULL;
442     static uint8_t *audio_out = NULL;
443     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
444
445     int size_out, frame_bytes, ret;
446     AVCodecContext *enc= ost->st->codec;
447     AVCodecContext *dec= ist->st->codec;
448
449     /* SC: dynamic allocation of buffers */
450     if (!audio_buf)
451         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
452     if (!audio_out)
453         audio_out = av_malloc(audio_out_size);
454     if (!audio_buf || !audio_out)
455         return;               /* Should signal an error ! */
456
457     if (enc->channels != dec->channels)
458         ost->audio_resample = 1;
459
460     if (ost->audio_resample && !ost->resample) {
461         ost->resample = audio_resample_init(enc->channels,    dec->channels,
462                                             enc->sample_rate, dec->sample_rate);
463         if (!ost->resample) {
464             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
465                     dec->channels, dec->sample_rate,
466                     enc->channels, enc->sample_rate);
467             exit(1);
468         }
469     }
470
471     if(audio_sync_method){
472         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
473                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
474         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
475         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
476
477         //FIXME resample delay
478         if(fabs(delta) > 50){
479             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
480                 if(byte_delta < 0){
481                     byte_delta= FFMAX(byte_delta, -size);
482                     size += byte_delta;
483                     buf  -= byte_delta;
484                     if(verbose > 2)
485                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
486                     if(!size)
487                         return;
488                     ist->is_start=0;
489                 }else{
490                     static uint8_t *input_tmp= NULL;
491                     input_tmp= av_realloc(input_tmp, byte_delta + size);
492
493                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
494                         ist->is_start=0;
495                     else
496                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
497
498                     memset(input_tmp, 0, byte_delta);
499                     memcpy(input_tmp + byte_delta, buf, size);
500                     buf= input_tmp;
501                     size += byte_delta;
502                     if(verbose > 2)
503                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
504                 }
505             }else if(audio_sync_method>1){
506                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
507                 assert(ost->audio_resample);
508                 if(verbose > 2)
509                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
510 //                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));
511                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
512             }
513         }
514     }else
515         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
516                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
517
518     if (ost->audio_resample) {
519         buftmp = audio_buf;
520         size_out = audio_resample(ost->resample,
521                                   (short *)buftmp, (short *)buf,
522                                   size / (ist->st->codec->channels * 2));
523         size_out = size_out * enc->channels * 2;
524     } else {
525         buftmp = buf;
526         size_out = size;
527     }
528
529     /* now encode as many frames as possible */
530     if (enc->frame_size > 1) {
531         /* output resampled raw samples */
532         av_fifo_write(&ost->fifo, buftmp, size_out);
533
534         frame_bytes = enc->frame_size * 2 * enc->channels;
535
536         while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
537             AVPacket pkt;
538             av_init_packet(&pkt);
539
540             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
541                                        (short *)audio_buf);
542             audio_size += ret;
543             pkt.stream_index= ost->index;
544             pkt.data= audio_out;
545             pkt.size= ret;
546             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
547                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
548             pkt.flags |= PKT_FLAG_KEY;
549             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
550
551             ost->sync_opts += enc->frame_size;
552         }
553     } else {
554         AVPacket pkt;
555         av_init_packet(&pkt);
556
557         ost->sync_opts += size_out / (2 * enc->channels);
558
559         /* output a pcm frame */
560         /* XXX: change encoding codec API to avoid this ? */
561         switch(enc->codec->id) {
562         case CODEC_ID_PCM_S32LE:
563         case CODEC_ID_PCM_S32BE:
564         case CODEC_ID_PCM_U32LE:
565         case CODEC_ID_PCM_U32BE:
566             size_out = size_out << 1;
567             break;
568         case CODEC_ID_PCM_S24LE:
569         case CODEC_ID_PCM_S24BE:
570         case CODEC_ID_PCM_U24LE:
571         case CODEC_ID_PCM_U24BE:
572         case CODEC_ID_PCM_S24DAUD:
573             size_out = size_out / 2 * 3;
574             break;
575         case CODEC_ID_PCM_S16LE:
576         case CODEC_ID_PCM_S16BE:
577         case CODEC_ID_PCM_U16LE:
578         case CODEC_ID_PCM_U16BE:
579             break;
580         default:
581             size_out = size_out >> 1;
582             break;
583         }
584         ret = avcodec_encode_audio(enc, audio_out, size_out,
585                                    (short *)buftmp);
586         audio_size += ret;
587         pkt.stream_index= ost->index;
588         pkt.data= audio_out;
589         pkt.size= ret;
590         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
591             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
592         pkt.flags |= PKT_FLAG_KEY;
593         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
594     }
595 }
596
597 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
598 {
599     AVCodecContext *dec;
600     AVPicture *picture2;
601     AVPicture picture_tmp;
602     uint8_t *buf = 0;
603
604     dec = ist->st->codec;
605
606     /* deinterlace : must be done before any resize */
607     if (do_deinterlace || using_vhook) {
608         int size;
609
610         /* create temporary picture */
611         size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
612         buf = av_malloc(size);
613         if (!buf)
614             return;
615
616         picture2 = &picture_tmp;
617         avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
618
619         if (do_deinterlace){
620             if(avpicture_deinterlace(picture2, picture,
621                                      dec->pix_fmt, dec->width, dec->height) < 0) {
622                 /* if error, do not deinterlace */
623                 av_free(buf);
624                 buf = NULL;
625                 picture2 = picture;
626             }
627         } else {
628             av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
629         }
630     } else {
631         picture2 = picture;
632     }
633
634     if (ENABLE_VHOOK)
635         frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
636                            1000000 * ist->pts / AV_TIME_BASE);
637
638     if (picture != picture2)
639         *picture = *picture2;
640     *bufp = buf;
641 }
642
643 /* we begin to correct av delay at this threshold */
644 #define AV_DELAY_MAX 0.100
645
646 static void do_subtitle_out(AVFormatContext *s,
647                             AVOutputStream *ost,
648                             AVInputStream *ist,
649                             AVSubtitle *sub,
650                             int64_t pts)
651 {
652     static uint8_t *subtitle_out = NULL;
653     int subtitle_out_max_size = 65536;
654     int subtitle_out_size, nb, i;
655     AVCodecContext *enc;
656     AVPacket pkt;
657
658     if (pts == AV_NOPTS_VALUE) {
659         fprintf(stderr, "Subtitle packets must have a pts\n");
660         return;
661     }
662
663     enc = ost->st->codec;
664
665     if (!subtitle_out) {
666         subtitle_out = av_malloc(subtitle_out_max_size);
667     }
668
669     /* Note: DVB subtitle need one packet to draw them and one other
670        packet to clear them */
671     /* XXX: signal it in the codec context ? */
672     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
673         nb = 2;
674     else
675         nb = 1;
676
677     for(i = 0; i < nb; i++) {
678         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
679                                                     subtitle_out_max_size, sub);
680
681         av_init_packet(&pkt);
682         pkt.stream_index = ost->index;
683         pkt.data = subtitle_out;
684         pkt.size = subtitle_out_size;
685         pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
686         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
687             /* XXX: the pts correction is handled here. Maybe handling
688                it in the codec would be better */
689             if (i == 0)
690                 pkt.pts += 90 * sub->start_display_time;
691             else
692                 pkt.pts += 90 * sub->end_display_time;
693         }
694         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
695     }
696 }
697
698 static int bit_buffer_size= 1024*256;
699 static uint8_t *bit_buffer= NULL;
700
701 static void do_video_out(AVFormatContext *s,
702                          AVOutputStream *ost,
703                          AVInputStream *ist,
704                          AVFrame *in_picture,
705                          int *frame_size)
706 {
707     int nb_frames, i, ret;
708     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
709     AVFrame picture_crop_temp, picture_pad_temp;
710     AVCodecContext *enc, *dec;
711
712     avcodec_get_frame_defaults(&picture_crop_temp);
713     avcodec_get_frame_defaults(&picture_pad_temp);
714
715     enc = ost->st->codec;
716     dec = ist->st->codec;
717
718     /* by default, we output a single frame */
719     nb_frames = 1;
720
721     *frame_size = 0;
722
723     if(video_sync_method){
724         double vdelta;
725         vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
726         //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
727         if (vdelta < -1.1)
728             nb_frames = 0;
729         else if (vdelta > 1.1)
730             nb_frames = lrintf(vdelta);
731 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
732         if (nb_frames == 0){
733             ++nb_frames_drop;
734             if (verbose>2)
735                 fprintf(stderr, "*** drop!\n");
736         }else if (nb_frames > 1) {
737             nb_frames_dup += nb_frames;
738             if (verbose>2)
739                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
740         }
741     }else
742         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
743
744     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
745     if (nb_frames <= 0)
746         return;
747
748     if (ost->video_crop) {
749         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
750             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
751             return;
752         }
753         formatted_picture = &picture_crop_temp;
754     } else {
755         formatted_picture = in_picture;
756     }
757
758     final_picture = formatted_picture;
759     padding_src = formatted_picture;
760     resampling_dst = &ost->pict_tmp;
761     if (ost->video_pad) {
762         final_picture = &ost->pict_tmp;
763         if (ost->video_resample) {
764             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
765                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
766                 return;
767             }
768             resampling_dst = &picture_pad_temp;
769         }
770     }
771
772     if (ost->video_resample) {
773         padding_src = NULL;
774         final_picture = &ost->pict_tmp;
775         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
776               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
777     }
778
779     if (ost->video_pad) {
780         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
781                 enc->height, enc->width, enc->pix_fmt,
782                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
783     }
784
785     /* duplicates frame if needed */
786     for(i=0;i<nb_frames;i++) {
787         AVPacket pkt;
788         av_init_packet(&pkt);
789         pkt.stream_index= ost->index;
790
791         if (s->oformat->flags & AVFMT_RAWPICTURE) {
792             /* raw pictures are written as AVPicture structure to
793                avoid any copies. We support temorarily the older
794                method. */
795             AVFrame* old_frame = enc->coded_frame;
796             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
797             pkt.data= (uint8_t *)final_picture;
798             pkt.size=  sizeof(AVPicture);
799             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
800             pkt.flags |= PKT_FLAG_KEY;
801
802             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
803             enc->coded_frame = old_frame;
804         } else {
805             AVFrame big_picture;
806
807             big_picture= *final_picture;
808             /* better than nothing: use input picture interlaced
809                settings */
810             big_picture.interlaced_frame = in_picture->interlaced_frame;
811             if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
812                 if(top_field_first == -1)
813                     big_picture.top_field_first = in_picture->top_field_first;
814                 else
815                     big_picture.top_field_first = top_field_first;
816             }
817
818             /* handles sameq here. This is not correct because it may
819                not be a global option */
820             if (same_quality) {
821                 big_picture.quality = ist->st->quality;
822             }else
823                 big_picture.quality = ost->st->quality;
824             if(!me_threshold)
825                 big_picture.pict_type = 0;
826 //            big_picture.pts = AV_NOPTS_VALUE;
827             big_picture.pts= ost->sync_opts;
828 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
829 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
830             ret = avcodec_encode_video(enc,
831                                        bit_buffer, bit_buffer_size,
832                                        &big_picture);
833             if (ret == -1) {
834                 fprintf(stderr, "Video encoding failed\n");
835                 exit(1);
836             }
837             //enc->frame_number = enc->real_pict_num;
838             if(ret>0){
839                 pkt.data= bit_buffer;
840                 pkt.size= ret;
841                 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
842                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
843 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
844    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
845    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
846
847                 if(enc->coded_frame && enc->coded_frame->key_frame)
848                     pkt.flags |= PKT_FLAG_KEY;
849                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
850                 *frame_size = ret;
851                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
852                 //        enc->frame_number-1, enc->real_pict_num, ret,
853                 //        enc->pict_type);
854                 /* if two pass, output log */
855                 if (ost->logfile && enc->stats_out) {
856                     fprintf(ost->logfile, "%s", enc->stats_out);
857                 }
858             }
859         }
860         ost->sync_opts++;
861         ost->frame_number++;
862     }
863 }
864
865 static double psnr(double d){
866     if(d==0) return INFINITY;
867     return -10.0*log(d)/log(10.0);
868 }
869
870 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
871                            int frame_size)
872 {
873     AVCodecContext *enc;
874     int frame_number;
875     double ti1, bitrate, avg_bitrate;
876
877     /* this is executed just the first time do_video_stats is called */
878     if (!vstats_file) {
879         vstats_file = fopen(vstats_filename, "w");
880         if (!vstats_file) {
881             perror("fopen");
882             exit(1);
883         }
884     }
885
886     enc = ost->st->codec;
887     if (enc->codec_type == CODEC_TYPE_VIDEO) {
888         frame_number = ost->frame_number;
889         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
890         if (enc->flags&CODEC_FLAG_PSNR)
891             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
892
893         fprintf(vstats_file,"f_size= %6d ", frame_size);
894         /* compute pts value */
895         ti1 = ost->sync_opts * av_q2d(enc->time_base);
896         if (ti1 < 0.01)
897             ti1 = 0.01;
898
899         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
900         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
901         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
902             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
903         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
904     }
905 }
906
907 static void print_report(AVFormatContext **output_files,
908                          AVOutputStream **ost_table, int nb_ostreams,
909                          int is_last_report)
910 {
911     char buf[1024];
912     AVOutputStream *ost;
913     AVFormatContext *oc, *os;
914     int64_t total_size;
915     AVCodecContext *enc;
916     int frame_number, vid, i;
917     double bitrate, ti1, pts;
918     static int64_t last_time = -1;
919     static int qp_histogram[52];
920
921     if (!is_last_report) {
922         int64_t cur_time;
923         /* display the report every 0.5 seconds */
924         cur_time = av_gettime();
925         if (last_time == -1) {
926             last_time = cur_time;
927             return;
928         }
929         if ((cur_time - last_time) < 500000)
930             return;
931         last_time = cur_time;
932     }
933
934
935     oc = output_files[0];
936
937     total_size = url_fsize(oc->pb);
938     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
939         total_size= url_ftell(oc->pb);
940
941     buf[0] = '\0';
942     ti1 = 1e10;
943     vid = 0;
944     for(i=0;i<nb_ostreams;i++) {
945         ost = ost_table[i];
946         os = output_files[ost->file_index];
947         enc = ost->st->codec;
948         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
949             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
950                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
951         }
952         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
953             float t = (av_gettime()-timer_start) / 1000000.0;
954
955             frame_number = ost->frame_number;
956             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
957                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
958                      enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
959             if(is_last_report)
960                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
961             if(qp_hist && enc->coded_frame){
962                 int j;
963                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
964                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
965                     qp_histogram[qp]++;
966                 for(j=0; j<32; j++)
967                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
968             }
969             if (enc->flags&CODEC_FLAG_PSNR){
970                 int j;
971                 double error, error_sum=0;
972                 double scale, scale_sum=0;
973                 char type[3]= {'Y','U','V'};
974                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
975                 for(j=0; j<3; j++){
976                     if(is_last_report){
977                         error= enc->error[j];
978                         scale= enc->width*enc->height*255.0*255.0*frame_number;
979                     }else{
980                         error= enc->coded_frame->error[j];
981                         scale= enc->width*enc->height*255.0*255.0;
982                     }
983                     if(j) scale/=4;
984                     error_sum += error;
985                     scale_sum += scale;
986                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
987                 }
988                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
989             }
990             vid = 1;
991         }
992         /* compute min output value */
993         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
994         if ((pts < ti1) && (pts > 0))
995             ti1 = pts;
996     }
997     if (ti1 < 0.01)
998         ti1 = 0.01;
999
1000     if (verbose || is_last_report) {
1001         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1002
1003         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1004             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1005             (double)total_size / 1024, ti1, bitrate);
1006
1007         if (verbose > 1)
1008           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1009                   nb_frames_dup, nb_frames_drop);
1010
1011         if (verbose >= 0)
1012             fprintf(stderr, "%s    \r", buf);
1013
1014         fflush(stderr);
1015     }
1016
1017     if (is_last_report && verbose >= 0){
1018         int64_t raw= audio_size + video_size + extra_size;
1019         fprintf(stderr, "\n");
1020         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1021                 video_size/1024.0,
1022                 audio_size/1024.0,
1023                 extra_size/1024.0,
1024                 100.0*(total_size - raw)/raw
1025         );
1026     }
1027 }
1028
1029 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1030 static int output_packet(AVInputStream *ist, int ist_index,
1031                          AVOutputStream **ost_table, int nb_ostreams,
1032                          const AVPacket *pkt)
1033 {
1034     AVFormatContext *os;
1035     AVOutputStream *ost;
1036     uint8_t *ptr;
1037     int len, ret, i;
1038     uint8_t *data_buf;
1039     int data_size, got_picture;
1040     AVFrame picture;
1041     void *buffer_to_free;
1042     static unsigned int samples_size= 0;
1043     static short *samples= NULL;
1044     AVSubtitle subtitle, *subtitle_to_free;
1045     int got_subtitle;
1046
1047     if(!pkt){
1048         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1049     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1050         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1051     } else {
1052 //        assert(ist->pts == ist->next_pts);
1053     }
1054
1055     if (pkt == NULL) {
1056         /* EOF handling */
1057         ptr = NULL;
1058         len = 0;
1059         goto handle_eof;
1060     }
1061
1062     len = pkt->size;
1063     ptr = pkt->data;
1064     while (len > 0) {
1065     handle_eof:
1066         /* decode the packet if needed */
1067         data_buf = NULL; /* fail safe */
1068         data_size = 0;
1069         subtitle_to_free = NULL;
1070         if (ist->decoding_needed) {
1071             switch(ist->st->codec->codec_type) {
1072             case CODEC_TYPE_AUDIO:{
1073                 if(pkt)
1074                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1075                 data_size= samples_size;
1076                     /* XXX: could avoid copy if PCM 16 bits with same
1077                        endianness as CPU */
1078                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1079                                            ptr, len);
1080                 if (ret < 0)
1081                     goto fail_decode;
1082                 ptr += ret;
1083                 len -= ret;
1084                 /* Some bug in mpeg audio decoder gives */
1085                 /* data_size < 0, it seems they are overflows */
1086                 if (data_size <= 0) {
1087                     /* no audio frame */
1088                     continue;
1089                 }
1090                 data_buf = (uint8_t *)samples;
1091                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1092                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1093                 break;}
1094             case CODEC_TYPE_VIDEO:
1095                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1096                     /* XXX: allocate picture correctly */
1097                     avcodec_get_frame_defaults(&picture);
1098
1099                     ret = avcodec_decode_video(ist->st->codec,
1100                                                &picture, &got_picture, ptr, len);
1101                     ist->st->quality= picture.quality;
1102                     if (ret < 0)
1103                         goto fail_decode;
1104                     if (!got_picture) {
1105                         /* no picture yet */
1106                         goto discard_packet;
1107                     }
1108                     if (ist->st->codec->time_base.num != 0) {
1109                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1110                                           ist->st->codec->time_base.num) /
1111                             ist->st->codec->time_base.den;
1112                     }
1113                     len = 0;
1114                     break;
1115             case CODEC_TYPE_SUBTITLE:
1116                 ret = avcodec_decode_subtitle(ist->st->codec,
1117                                               &subtitle, &got_subtitle, ptr, len);
1118                 if (ret < 0)
1119                     goto fail_decode;
1120                 if (!got_subtitle) {
1121                     goto discard_packet;
1122                 }
1123                 subtitle_to_free = &subtitle;
1124                 len = 0;
1125                 break;
1126             default:
1127                 goto fail_decode;
1128             }
1129         } else {
1130             switch(ist->st->codec->codec_type) {
1131             case CODEC_TYPE_AUDIO:
1132                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1133                     ist->st->codec->sample_rate;
1134                 break;
1135             case CODEC_TYPE_VIDEO:
1136                 if (ist->st->codec->time_base.num != 0) {
1137                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1138                                       ist->st->codec->time_base.num) /
1139                         ist->st->codec->time_base.den;
1140                 }
1141                 break;
1142             }
1143             data_buf = ptr;
1144             data_size = len;
1145             ret = len;
1146             len = 0;
1147         }
1148
1149         buffer_to_free = NULL;
1150         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1151             pre_process_video_frame(ist, (AVPicture *)&picture,
1152                                     &buffer_to_free);
1153         }
1154
1155         // preprocess audio (volume)
1156         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1157             if (audio_volume != 256) {
1158                 short *volp;
1159                 volp = samples;
1160                 for(i=0;i<(data_size / sizeof(short));i++) {
1161                     int v = ((*volp) * audio_volume + 128) >> 8;
1162                     if (v < -32768) v = -32768;
1163                     if (v >  32767) v = 32767;
1164                     *volp++ = v;
1165                 }
1166             }
1167         }
1168
1169         /* frame rate emulation */
1170         if (ist->st->codec->rate_emu) {
1171             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1172             int64_t now = av_gettime() - ist->start;
1173             if (pts > now)
1174                 usleep(pts - now);
1175
1176             ist->frame++;
1177         }
1178
1179 #if 0
1180         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1181            is the one of the next displayed one */
1182         /* XXX: add mpeg4 too ? */
1183         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1184             if (ist->st->codec->pict_type != B_TYPE) {
1185                 int64_t tmp;
1186                 tmp = ist->last_ip_pts;
1187                 ist->last_ip_pts  = ist->frac_pts.val;
1188                 ist->frac_pts.val = tmp;
1189             }
1190         }
1191 #endif
1192         /* if output time reached then transcode raw format,
1193            encode packets and output them */
1194         if (start_time == 0 || ist->pts >= start_time)
1195             for(i=0;i<nb_ostreams;i++) {
1196                 int frame_size;
1197
1198                 ost = ost_table[i];
1199                 if (ost->source_index == ist_index) {
1200                     os = output_files[ost->file_index];
1201
1202 #if 0
1203                     printf("%d: got pts=%0.3f %0.3f\n", i,
1204                            (double)pkt->pts / AV_TIME_BASE,
1205                            ((double)ist->pts / AV_TIME_BASE) -
1206                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1207 #endif
1208                     /* set the input output pts pairs */
1209                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1210
1211                     if (ost->encoding_needed) {
1212                         switch(ost->st->codec->codec_type) {
1213                         case CODEC_TYPE_AUDIO:
1214                             do_audio_out(os, ost, ist, data_buf, data_size);
1215                             break;
1216                         case CODEC_TYPE_VIDEO:
1217                             do_video_out(os, ost, ist, &picture, &frame_size);
1218                             video_size += frame_size;
1219                             if (vstats_filename && frame_size)
1220                                 do_video_stats(os, ost, frame_size);
1221                             break;
1222                         case CODEC_TYPE_SUBTITLE:
1223                             do_subtitle_out(os, ost, ist, &subtitle,
1224                                             pkt->pts);
1225                             break;
1226                         default:
1227                             abort();
1228                         }
1229                     } else {
1230                         AVFrame avframe; //FIXME/XXX remove this
1231                         AVPacket opkt;
1232                         av_init_packet(&opkt);
1233
1234                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1235                             continue;
1236
1237                         /* no reencoding needed : output the packet directly */
1238                         /* force the input stream PTS */
1239
1240                         avcodec_get_frame_defaults(&avframe);
1241                         ost->st->codec->coded_frame= &avframe;
1242                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1243
1244                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1245                             audio_size += data_size;
1246                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1247                             video_size += data_size;
1248                             ost->sync_opts++;
1249                         }
1250
1251                         opkt.stream_index= ost->index;
1252                         if(pkt->pts != AV_NOPTS_VALUE)
1253                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1254                         else
1255                             opkt.pts= AV_NOPTS_VALUE;
1256
1257                             if (pkt->dts == AV_NOPTS_VALUE)
1258                                 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1259                             else
1260                                 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1261
1262                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1263                         opkt.flags= pkt->flags;
1264
1265                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1266                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1267                             opkt.destruct= av_destruct_packet;
1268
1269                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1270                         ost->st->codec->frame_number++;
1271                         ost->frame_number++;
1272                         av_free_packet(&opkt);
1273                     }
1274                 }
1275             }
1276         av_free(buffer_to_free);
1277         /* XXX: allocate the subtitles in the codec ? */
1278         if (subtitle_to_free) {
1279             if (subtitle_to_free->rects != NULL) {
1280                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1281                     av_free(subtitle_to_free->rects[i].bitmap);
1282                     av_free(subtitle_to_free->rects[i].rgba_palette);
1283                 }
1284                 av_freep(&subtitle_to_free->rects);
1285             }
1286             subtitle_to_free->num_rects = 0;
1287             subtitle_to_free = NULL;
1288         }
1289     }
1290  discard_packet:
1291     if (pkt == NULL) {
1292         /* EOF handling */
1293
1294         for(i=0;i<nb_ostreams;i++) {
1295             ost = ost_table[i];
1296             if (ost->source_index == ist_index) {
1297                 AVCodecContext *enc= ost->st->codec;
1298                 os = output_files[ost->file_index];
1299
1300                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1301                     continue;
1302                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1303                     continue;
1304
1305                 if (ost->encoding_needed) {
1306                     for(;;) {
1307                         AVPacket pkt;
1308                         int fifo_bytes;
1309                         av_init_packet(&pkt);
1310                         pkt.stream_index= ost->index;
1311
1312                         switch(ost->st->codec->codec_type) {
1313                         case CODEC_TYPE_AUDIO:
1314                             fifo_bytes = av_fifo_size(&ost->fifo);
1315                             ret = 0;
1316                             /* encode any samples remaining in fifo */
1317                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1318                                 int fs_tmp = enc->frame_size;
1319                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1320                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1321                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1322                                 }
1323                                 enc->frame_size = fs_tmp;
1324                             }
1325                             if(ret <= 0) {
1326                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1327                             }
1328                             audio_size += ret;
1329                             pkt.flags |= PKT_FLAG_KEY;
1330                             break;
1331                         case CODEC_TYPE_VIDEO:
1332                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1333                             video_size += ret;
1334                             if(enc->coded_frame && enc->coded_frame->key_frame)
1335                                 pkt.flags |= PKT_FLAG_KEY;
1336                             if (ost->logfile && enc->stats_out) {
1337                                 fprintf(ost->logfile, "%s", enc->stats_out);
1338                             }
1339                             break;
1340                         default:
1341                             ret=-1;
1342                         }
1343
1344                         if(ret<=0)
1345                             break;
1346                         pkt.data= bit_buffer;
1347                         pkt.size= ret;
1348                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1349                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1350                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1351                     }
1352                 }
1353             }
1354         }
1355     }
1356
1357     return 0;
1358  fail_decode:
1359     return -1;
1360 }
1361
1362 static void print_sdp(AVFormatContext **avc, int n)
1363 {
1364     char sdp[2048];
1365
1366     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1367     printf("SDP:\n%s\n", sdp);
1368 }
1369
1370 static int stream_index_from_inputs(AVFormatContext **input_files,
1371                                     int nb_input_files,
1372                                     AVInputFile *file_table,
1373                                     AVInputStream **ist_table,
1374                                     enum CodecType type,
1375                                     int programid)
1376 {
1377     int p, q, z;
1378     for(z=0; z<nb_input_files; z++) {
1379         AVFormatContext *ic = input_files[z];
1380         for(p=0; p<ic->nb_programs; p++) {
1381             AVProgram *program = ic->programs[p];
1382             if(program->id != programid)
1383                 continue;
1384             for(q=0; q<program->nb_stream_indexes; q++) {
1385                 int sidx = program->stream_index[q];
1386                 int ris = file_table[z].ist_index + sidx;
1387                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1388                     return ris;
1389             }
1390         }
1391     }
1392
1393     return -1;
1394 }
1395
1396 /*
1397  * The following code is the main loop of the file converter
1398  */
1399 static int av_encode(AVFormatContext **output_files,
1400                      int nb_output_files,
1401                      AVFormatContext **input_files,
1402                      int nb_input_files,
1403                      AVStreamMap *stream_maps, int nb_stream_maps)
1404 {
1405     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1406     AVFormatContext *is, *os;
1407     AVCodecContext *codec, *icodec;
1408     AVOutputStream *ost, **ost_table = NULL;
1409     AVInputStream *ist, **ist_table = NULL;
1410     AVInputFile *file_table;
1411     int key;
1412     int want_sdp = 1;
1413
1414     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1415     if (!file_table)
1416         goto fail;
1417
1418     /* input stream init */
1419     j = 0;
1420     for(i=0;i<nb_input_files;i++) {
1421         is = input_files[i];
1422         file_table[i].ist_index = j;
1423         file_table[i].nb_streams = is->nb_streams;
1424         j += is->nb_streams;
1425     }
1426     nb_istreams = j;
1427
1428     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1429     if (!ist_table)
1430         goto fail;
1431
1432     for(i=0;i<nb_istreams;i++) {
1433         ist = av_mallocz(sizeof(AVInputStream));
1434         if (!ist)
1435             goto fail;
1436         ist_table[i] = ist;
1437     }
1438     j = 0;
1439     for(i=0;i<nb_input_files;i++) {
1440         is = input_files[i];
1441         for(k=0;k<is->nb_streams;k++) {
1442             ist = ist_table[j++];
1443             ist->st = is->streams[k];
1444             ist->file_index = i;
1445             ist->index = k;
1446             ist->discard = 1; /* the stream is discarded by default
1447                                  (changed later) */
1448
1449             if (ist->st->codec->rate_emu) {
1450                 ist->start = av_gettime();
1451                 ist->frame = 0;
1452             }
1453         }
1454     }
1455
1456     /* output stream init */
1457     nb_ostreams = 0;
1458     for(i=0;i<nb_output_files;i++) {
1459         os = output_files[i];
1460         if (!os->nb_streams) {
1461             fprintf(stderr, "Output file does not contain any stream\n");
1462             exit(1);
1463         }
1464         nb_ostreams += os->nb_streams;
1465     }
1466     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1467         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1468         exit(1);
1469     }
1470
1471     /* Sanity check the mapping args -- do the input files & streams exist? */
1472     for(i=0;i<nb_stream_maps;i++) {
1473         int fi = stream_maps[i].file_index;
1474         int si = stream_maps[i].stream_index;
1475
1476         if (fi < 0 || fi > nb_input_files - 1 ||
1477             si < 0 || si > file_table[fi].nb_streams - 1) {
1478             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1479             exit(1);
1480         }
1481         fi = stream_maps[i].sync_file_index;
1482         si = stream_maps[i].sync_stream_index;
1483         if (fi < 0 || fi > nb_input_files - 1 ||
1484             si < 0 || si > file_table[fi].nb_streams - 1) {
1485             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1486             exit(1);
1487         }
1488     }
1489
1490     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1491     if (!ost_table)
1492         goto fail;
1493     for(i=0;i<nb_ostreams;i++) {
1494         ost = av_mallocz(sizeof(AVOutputStream));
1495         if (!ost)
1496             goto fail;
1497         ost_table[i] = ost;
1498     }
1499
1500     n = 0;
1501     for(k=0;k<nb_output_files;k++) {
1502         os = output_files[k];
1503         for(i=0;i<os->nb_streams;i++) {
1504             int found;
1505             ost = ost_table[n++];
1506             ost->file_index = k;
1507             ost->index = i;
1508             ost->st = os->streams[i];
1509             if (nb_stream_maps > 0) {
1510                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1511                     stream_maps[n-1].stream_index;
1512
1513                 /* Sanity check that the stream types match */
1514                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1515                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1516                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1517                         ost->file_index, ost->index);
1518                     exit(1);
1519                 }
1520
1521             } else {
1522                 if(opt_programid) {
1523                     found = 0;
1524                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1525                     if(j != -1) {
1526                         ost->source_index = j;
1527                         found = 1;
1528                     }
1529                 } else {
1530                     /* get corresponding input stream index : we select the first one with the right type */
1531                     found = 0;
1532                     for(j=0;j<nb_istreams;j++) {
1533                         ist = ist_table[j];
1534                         if (ist->discard &&
1535                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1536                             ost->source_index = j;
1537                             found = 1;
1538                             break;
1539                         }
1540                     }
1541                 }
1542
1543                 if (!found) {
1544                     if(! opt_programid) {
1545                         /* try again and reuse existing stream */
1546                         for(j=0;j<nb_istreams;j++) {
1547                             ist = ist_table[j];
1548                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1549                                 ost->source_index = j;
1550                                 found = 1;
1551                             }
1552                         }
1553                     }
1554                     if (!found) {
1555                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1556                                 ost->file_index, ost->index);
1557                         exit(1);
1558                     }
1559                 }
1560             }
1561             ist = ist_table[ost->source_index];
1562             ist->discard = 0;
1563             ost->sync_ist = (nb_stream_maps > 0) ?
1564                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1565                          stream_maps[n-1].sync_stream_index] : ist;
1566         }
1567     }
1568
1569     /* for each output stream, we compute the right encoding parameters */
1570     for(i=0;i<nb_ostreams;i++) {
1571         ost = ost_table[i];
1572         os = output_files[ost->file_index];
1573         ist = ist_table[ost->source_index];
1574
1575         codec = ost->st->codec;
1576         icodec = ist->st->codec;
1577
1578         if (!ost->st->language[0])
1579             av_strlcpy(ost->st->language, ist->st->language,
1580                        sizeof(ost->st->language));
1581
1582         if (ost->st->stream_copy) {
1583             /* if stream_copy is selected, no need to decode or encode */
1584             codec->codec_id = icodec->codec_id;
1585             codec->codec_type = icodec->codec_type;
1586
1587             if(!codec->codec_tag){
1588                 if(   !os->oformat->codec_tag
1589                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1590                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1591                     codec->codec_tag = icodec->codec_tag;
1592             }
1593
1594             codec->bit_rate = icodec->bit_rate;
1595             codec->extradata= icodec->extradata;
1596             codec->extradata_size= icodec->extradata_size;
1597             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1598                 codec->time_base = icodec->time_base;
1599             else
1600                 codec->time_base = ist->st->time_base;
1601             switch(codec->codec_type) {
1602             case CODEC_TYPE_AUDIO:
1603                 codec->sample_rate = icodec->sample_rate;
1604                 codec->channels = icodec->channels;
1605                 codec->frame_size = icodec->frame_size;
1606                 codec->block_align= icodec->block_align;
1607                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1608                     codec->block_align= 0;
1609                 break;
1610             case CODEC_TYPE_VIDEO:
1611                 if(using_vhook) {
1612                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1613                     exit(1);
1614                 }
1615                 codec->pix_fmt = icodec->pix_fmt;
1616                 codec->width = icodec->width;
1617                 codec->height = icodec->height;
1618                 codec->has_b_frames = icodec->has_b_frames;
1619                 break;
1620             case CODEC_TYPE_SUBTITLE:
1621                 break;
1622             default:
1623                 abort();
1624             }
1625         } else {
1626             switch(codec->codec_type) {
1627             case CODEC_TYPE_AUDIO:
1628                 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1629                     goto fail;
1630                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1631                 icodec->request_channels = codec->channels;
1632                 ist->decoding_needed = 1;
1633                 ost->encoding_needed = 1;
1634                 break;
1635             case CODEC_TYPE_VIDEO:
1636                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1637                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1638                 ost->video_resample = ((codec->width != icodec->width -
1639                                 (frame_leftBand + frame_rightBand) +
1640                                 (frame_padleft + frame_padright)) ||
1641                         (codec->height != icodec->height -
1642                                 (frame_topBand  + frame_bottomBand) +
1643                                 (frame_padtop + frame_padbottom)) ||
1644                         (codec->pix_fmt != icodec->pix_fmt));
1645                 if (ost->video_crop) {
1646                     ost->topBand = frame_topBand;
1647                     ost->leftBand = frame_leftBand;
1648                 }
1649                 if (ost->video_pad) {
1650                     ost->padtop = frame_padtop;
1651                     ost->padleft = frame_padleft;
1652                     ost->padbottom = frame_padbottom;
1653                     ost->padright = frame_padright;
1654                     if (!ost->video_resample) {
1655                         avcodec_get_frame_defaults(&ost->pict_tmp);
1656                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1657                                          codec->width, codec->height ) )
1658                             goto fail;
1659                     }
1660                 }
1661                 if (ost->video_resample) {
1662                     avcodec_get_frame_defaults(&ost->pict_tmp);
1663                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1664                                          codec->width, codec->height ) ) {
1665                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1666                         exit(1);
1667                     }
1668                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1669                     ost->img_resample_ctx = sws_getContext(
1670                             icodec->width - (frame_leftBand + frame_rightBand),
1671                             icodec->height - (frame_topBand + frame_bottomBand),
1672                             icodec->pix_fmt,
1673                             codec->width - (frame_padleft + frame_padright),
1674                             codec->height - (frame_padtop + frame_padbottom),
1675                             codec->pix_fmt,
1676                             sws_flags, NULL, NULL, NULL);
1677                     if (ost->img_resample_ctx == NULL) {
1678                         fprintf(stderr, "Cannot get resampling context\n");
1679                         exit(1);
1680                     }
1681                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1682                 }
1683                 ost->encoding_needed = 1;
1684                 ist->decoding_needed = 1;
1685                 break;
1686             case CODEC_TYPE_SUBTITLE:
1687                 ost->encoding_needed = 1;
1688                 ist->decoding_needed = 1;
1689                 break;
1690             default:
1691                 abort();
1692                 break;
1693             }
1694             /* two pass mode */
1695             if (ost->encoding_needed &&
1696                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1697                 char logfilename[1024];
1698                 FILE *f;
1699                 int size;
1700                 char *logbuffer;
1701
1702                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1703                          pass_logfilename ?
1704                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1705                 if (codec->flags & CODEC_FLAG_PASS1) {
1706                     f = fopen(logfilename, "w");
1707                     if (!f) {
1708                         perror(logfilename);
1709                         exit(1);
1710                     }
1711                     ost->logfile = f;
1712                 } else {
1713                     /* read the log file */
1714                     f = fopen(logfilename, "r");
1715                     if (!f) {
1716                         perror(logfilename);
1717                         exit(1);
1718                     }
1719                     fseek(f, 0, SEEK_END);
1720                     size = ftell(f);
1721                     fseek(f, 0, SEEK_SET);
1722                     logbuffer = av_malloc(size + 1);
1723                     if (!logbuffer) {
1724                         fprintf(stderr, "Could not allocate log buffer\n");
1725                         exit(1);
1726                     }
1727                     size = fread(logbuffer, 1, size, f);
1728                     fclose(f);
1729                     logbuffer[size] = '\0';
1730                     codec->stats_in = logbuffer;
1731                 }
1732             }
1733         }
1734         if(codec->codec_type == CODEC_TYPE_VIDEO){
1735             int size= codec->width * codec->height;
1736             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1737         }
1738     }
1739
1740     if (!bit_buffer)
1741         bit_buffer = av_malloc(bit_buffer_size);
1742     if (!bit_buffer)
1743         goto fail;
1744
1745     /* dump the file output parameters - cannot be done before in case
1746        of stream copy */
1747     for(i=0;i<nb_output_files;i++) {
1748         dump_format(output_files[i], i, output_files[i]->filename, 1);
1749     }
1750
1751     /* dump the stream mapping */
1752     if (verbose >= 0) {
1753         fprintf(stderr, "Stream mapping:\n");
1754         for(i=0;i<nb_ostreams;i++) {
1755             ost = ost_table[i];
1756             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1757                     ist_table[ost->source_index]->file_index,
1758                     ist_table[ost->source_index]->index,
1759                     ost->file_index,
1760                     ost->index);
1761             if (ost->sync_ist != ist_table[ost->source_index])
1762                 fprintf(stderr, " [sync #%d.%d]",
1763                         ost->sync_ist->file_index,
1764                         ost->sync_ist->index);
1765             fprintf(stderr, "\n");
1766         }
1767     }
1768
1769     /* open each encoder */
1770     for(i=0;i<nb_ostreams;i++) {
1771         ost = ost_table[i];
1772         if (ost->encoding_needed) {
1773             AVCodec *codec;
1774             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1775             if (!codec) {
1776                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1777                         ost->file_index, ost->index);
1778                 exit(1);
1779             }
1780             if (avcodec_open(ost->st->codec, codec) < 0) {
1781                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1782                         ost->file_index, ost->index);
1783                 exit(1);
1784             }
1785             extra_size += ost->st->codec->extradata_size;
1786         }
1787     }
1788
1789     /* open each decoder */
1790     for(i=0;i<nb_istreams;i++) {
1791         ist = ist_table[i];
1792         if (ist->decoding_needed) {
1793             AVCodec *codec;
1794             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1795             if (!codec) {
1796                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1797                         ist->st->codec->codec_id, ist->file_index, ist->index);
1798                 exit(1);
1799             }
1800             if (avcodec_open(ist->st->codec, codec) < 0) {
1801                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1802                         ist->file_index, ist->index);
1803                 exit(1);
1804             }
1805             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1806             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1807         }
1808     }
1809
1810     /* init pts */
1811     for(i=0;i<nb_istreams;i++) {
1812         ist = ist_table[i];
1813         is = input_files[ist->file_index];
1814         ist->pts = 0;
1815         ist->next_pts=0;
1816         if(   input_files_ts_offset[ist->file_index] != -is->start_time
1817            && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1818             ist->next_pts= AV_NOPTS_VALUE;
1819         ist->is_start = 1;
1820     }
1821
1822     /* set meta data information from input file if required */
1823     for (i=0;i<nb_meta_data_maps;i++) {
1824         AVFormatContext *out_file;
1825         AVFormatContext *in_file;
1826
1827         int out_file_index = meta_data_maps[i].out_file;
1828         int in_file_index = meta_data_maps[i].in_file;
1829         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1830             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1831             ret = AVERROR(EINVAL);
1832             goto fail;
1833         }
1834         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1835             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1836             ret = AVERROR(EINVAL);
1837             goto fail;
1838         }
1839
1840         out_file = output_files[out_file_index];
1841         in_file = input_files[in_file_index];
1842
1843         strcpy(out_file->title, in_file->title);
1844         strcpy(out_file->author, in_file->author);
1845         strcpy(out_file->copyright, in_file->copyright);
1846         strcpy(out_file->comment, in_file->comment);
1847         strcpy(out_file->album, in_file->album);
1848         out_file->year = in_file->year;
1849         out_file->track = in_file->track;
1850         strcpy(out_file->genre, in_file->genre);
1851     }
1852
1853     /* open files and write file headers */
1854     for(i=0;i<nb_output_files;i++) {
1855         os = output_files[i];
1856         if (av_write_header(os) < 0) {
1857             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1858             ret = AVERROR(EINVAL);
1859             goto fail;
1860         }
1861         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1862             want_sdp = 0;
1863         }
1864     }
1865     if (want_sdp) {
1866         print_sdp(output_files, nb_output_files);
1867     }
1868
1869     if ( !using_stdin && verbose >= 0) {
1870         fprintf(stderr, "Press [q] to stop encoding\n");
1871         url_set_interrupt_cb(decode_interrupt_cb);
1872     }
1873     term_init();
1874
1875     key = -1;
1876     timer_start = av_gettime();
1877
1878     for(; received_sigterm == 0;) {
1879         int file_index, ist_index;
1880         AVPacket pkt;
1881         double ipts_min;
1882         double opts_min;
1883
1884     redo:
1885         ipts_min= 1e100;
1886         opts_min= 1e100;
1887         /* if 'q' pressed, exits */
1888         if (!using_stdin) {
1889             if (q_pressed)
1890                 break;
1891             /* read_key() returns 0 on EOF */
1892             key = read_key();
1893             if (key == 'q')
1894                 break;
1895         }
1896
1897         /* select the stream that we must read now by looking at the
1898            smallest output pts */
1899         file_index = -1;
1900         for(i=0;i<nb_ostreams;i++) {
1901             double ipts, opts;
1902             ost = ost_table[i];
1903             os = output_files[ost->file_index];
1904             ist = ist_table[ost->source_index];
1905             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1906                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1907             else
1908                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1909             ipts = (double)ist->pts;
1910             if (!file_table[ist->file_index].eof_reached){
1911                 if(ipts < ipts_min) {
1912                     ipts_min = ipts;
1913                     if(input_sync ) file_index = ist->file_index;
1914                 }
1915                 if(opts < opts_min) {
1916                     opts_min = opts;
1917                     if(!input_sync) file_index = ist->file_index;
1918                 }
1919             }
1920             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1921                 file_index= -1;
1922                 break;
1923             }
1924         }
1925         /* if none, if is finished */
1926         if (file_index < 0) {
1927             break;
1928         }
1929
1930         /* finish if recording time exhausted */
1931         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1932             break;
1933
1934         /* finish if limit size exhausted */
1935         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1936             break;
1937
1938         /* read a frame from it and output it in the fifo */
1939         is = input_files[file_index];
1940         if (av_read_frame(is, &pkt) < 0) {
1941             file_table[file_index].eof_reached = 1;
1942             if (opt_shortest)
1943                 break;
1944             else
1945                 continue;
1946         }
1947
1948         if (do_pkt_dump) {
1949             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1950         }
1951         /* the following test is needed in case new streams appear
1952            dynamically in stream : we ignore them */
1953         if (pkt.stream_index >= file_table[file_index].nb_streams)
1954             goto discard_packet;
1955         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1956         ist = ist_table[ist_index];
1957         if (ist->discard)
1958             goto discard_packet;
1959
1960         if (pkt.dts != AV_NOPTS_VALUE)
1961             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1962         if (pkt.pts != AV_NOPTS_VALUE)
1963             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1964
1965 //        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);
1966         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1967             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1968             int64_t delta= pkt_dts - ist->next_pts;
1969             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1970                 input_files_ts_offset[ist->file_index]-= delta;
1971                 if (verbose > 2)
1972                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1973                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1974                 if(pkt.pts != AV_NOPTS_VALUE)
1975                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1976             }
1977         }
1978
1979         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1980         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1981
1982             if (verbose >= 0)
1983                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1984                         ist->file_index, ist->index);
1985
1986             av_free_packet(&pkt);
1987             goto redo;
1988         }
1989
1990     discard_packet:
1991         av_free_packet(&pkt);
1992
1993         /* dump report by using the output first video and audio streams */
1994         print_report(output_files, ost_table, nb_ostreams, 0);
1995     }
1996
1997     /* at the end of stream, we must flush the decoder buffers */
1998     for(i=0;i<nb_istreams;i++) {
1999         ist = ist_table[i];
2000         if (ist->decoding_needed) {
2001             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2002         }
2003     }
2004
2005     term_exit();
2006
2007     /* write the trailer if needed and close file */
2008     for(i=0;i<nb_output_files;i++) {
2009         os = output_files[i];
2010         av_write_trailer(os);
2011     }
2012
2013     /* dump report by using the first video and audio streams */
2014     print_report(output_files, ost_table, nb_ostreams, 1);
2015
2016     /* close each encoder */
2017     for(i=0;i<nb_ostreams;i++) {
2018         ost = ost_table[i];
2019         if (ost->encoding_needed) {
2020             av_freep(&ost->st->codec->stats_in);
2021             avcodec_close(ost->st->codec);
2022         }
2023     }
2024
2025     /* close each decoder */
2026     for(i=0;i<nb_istreams;i++) {
2027         ist = ist_table[i];
2028         if (ist->decoding_needed) {
2029             avcodec_close(ist->st->codec);
2030         }
2031     }
2032
2033     /* finished ! */
2034
2035     ret = 0;
2036  fail1:
2037     av_freep(&bit_buffer);
2038     av_free(file_table);
2039
2040     if (ist_table) {
2041         for(i=0;i<nb_istreams;i++) {
2042             ist = ist_table[i];
2043             av_free(ist);
2044         }
2045         av_free(ist_table);
2046     }
2047     if (ost_table) {
2048         for(i=0;i<nb_ostreams;i++) {
2049             ost = ost_table[i];
2050             if (ost) {
2051                 if (ost->logfile) {
2052                     fclose(ost->logfile);
2053                     ost->logfile = NULL;
2054                 }
2055                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2056                                              initialized but set to zero */
2057                 av_free(ost->pict_tmp.data[0]);
2058                 if (ost->video_resample)
2059                     sws_freeContext(ost->img_resample_ctx);
2060                 if (ost->resample)
2061                     audio_resample_close(ost->resample);
2062                 av_free(ost);
2063             }
2064         }
2065         av_free(ost_table);
2066     }
2067     return ret;
2068  fail:
2069     ret = AVERROR(ENOMEM);
2070     goto fail1;
2071 }
2072
2073 #if 0
2074 int file_read(const char *filename)
2075 {
2076     URLContext *h;
2077     unsigned char buffer[1024];
2078     int len, i;
2079
2080     if (url_open(&h, filename, O_RDONLY) < 0) {
2081         printf("could not open '%s'\n", filename);
2082         return -1;
2083     }
2084     for(;;) {
2085         len = url_read(h, buffer, sizeof(buffer));
2086         if (len <= 0)
2087             break;
2088         for(i=0;i<len;i++) putchar(buffer[i]);
2089     }
2090     url_close(h);
2091     return 0;
2092 }
2093 #endif
2094
2095 static void opt_format(const char *arg)
2096 {
2097     /* compatibility stuff for pgmyuv */
2098     if (!strcmp(arg, "pgmyuv")) {
2099         pgmyuv_compatibility_hack=1;
2100 //        opt_image_format(arg);
2101         arg = "image2";
2102         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2103     }
2104
2105     file_iformat = av_find_input_format(arg);
2106     file_oformat = guess_format(arg, NULL, NULL);
2107     if (!file_iformat && !file_oformat) {
2108         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2109         exit(1);
2110     }
2111 }
2112
2113 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2114 extern int ffm_nopts;
2115 #endif
2116
2117 static int opt_default(const char *opt, const char *arg){
2118     int type;
2119     const AVOption *o= NULL;
2120     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2121
2122     for(type=0; type<CODEC_TYPE_NB; type++){
2123         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2124         if(o2)
2125             o = av_set_string(avctx_opts[type], opt, arg);
2126     }
2127     if(!o)
2128         o = av_set_string(avformat_opts, opt, arg);
2129     if(!o)
2130         o = av_set_string(sws_opts, opt, arg);
2131     if(!o){
2132         if(opt[0] == 'a')
2133             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2134         else if(opt[0] == 'v')
2135             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2136         else if(opt[0] == 's')
2137             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2138     }
2139     if(!o)
2140         return -1;
2141
2142 //    av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2143
2144     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2145     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2146     opt_names[opt_name_count++]= o->name;
2147
2148 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2149     /* disable generate of real time pts in ffm (need to be supressed anyway) */
2150     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2151         ffm_nopts = 1;
2152 #endif
2153
2154     if(avctx_opts[0]->debug)
2155         av_log_set_level(AV_LOG_DEBUG);
2156     return 0;
2157 }
2158
2159 static void opt_video_rc_override_string(const char *arg)
2160 {
2161     video_rc_override_string = arg;
2162 }
2163
2164 static void opt_me_threshold(const char *arg)
2165 {
2166     me_threshold = atoi(arg);
2167 }
2168
2169 static void opt_verbose(const char *arg)
2170 {
2171     verbose = atoi(arg);
2172     av_log_set_level(atoi(arg));
2173 }
2174
2175 static void opt_frame_rate(const char *arg)
2176 {
2177     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2178         fprintf(stderr, "Incorrect frame rate\n");
2179         exit(1);
2180     }
2181 }
2182
2183 static int opt_bitrate(const char *opt, const char *arg)
2184 {
2185     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2186
2187     opt_default(opt, arg);
2188
2189     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2190         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2191
2192     return 0;
2193 }
2194
2195 static void opt_frame_crop_top(const char *arg)
2196 {
2197     frame_topBand = atoi(arg);
2198     if (frame_topBand < 0) {
2199         fprintf(stderr, "Incorrect top crop size\n");
2200         exit(1);
2201     }
2202     if ((frame_topBand % 2) != 0) {
2203         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2204         exit(1);
2205     }
2206     if ((frame_topBand) >= frame_height){
2207         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2208         exit(1);
2209     }
2210     frame_height -= frame_topBand;
2211 }
2212
2213 static void opt_frame_crop_bottom(const char *arg)
2214 {
2215     frame_bottomBand = atoi(arg);
2216     if (frame_bottomBand < 0) {
2217         fprintf(stderr, "Incorrect bottom crop size\n");
2218         exit(1);
2219     }
2220     if ((frame_bottomBand % 2) != 0) {
2221         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2222         exit(1);
2223     }
2224     if ((frame_bottomBand) >= frame_height){
2225         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2226         exit(1);
2227     }
2228     frame_height -= frame_bottomBand;
2229 }
2230
2231 static void opt_frame_crop_left(const char *arg)
2232 {
2233     frame_leftBand = atoi(arg);
2234     if (frame_leftBand < 0) {
2235         fprintf(stderr, "Incorrect left crop size\n");
2236         exit(1);
2237     }
2238     if ((frame_leftBand % 2) != 0) {
2239         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2240         exit(1);
2241     }
2242     if ((frame_leftBand) >= frame_width){
2243         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2244         exit(1);
2245     }
2246     frame_width -= frame_leftBand;
2247 }
2248
2249 static void opt_frame_crop_right(const char *arg)
2250 {
2251     frame_rightBand = atoi(arg);
2252     if (frame_rightBand < 0) {
2253         fprintf(stderr, "Incorrect right crop size\n");
2254         exit(1);
2255     }
2256     if ((frame_rightBand % 2) != 0) {
2257         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2258         exit(1);
2259     }
2260     if ((frame_rightBand) >= frame_width){
2261         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2262         exit(1);
2263     }
2264     frame_width -= frame_rightBand;
2265 }
2266
2267 static void opt_frame_size(const char *arg)
2268 {
2269     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2270         fprintf(stderr, "Incorrect frame size\n");
2271         exit(1);
2272     }
2273     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2274         fprintf(stderr, "Frame size must be a multiple of 2\n");
2275         exit(1);
2276     }
2277 }
2278
2279
2280 #define SCALEBITS 10
2281 #define ONE_HALF  (1 << (SCALEBITS - 1))
2282 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2283
2284 #define RGB_TO_Y(r, g, b) \
2285 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2286   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2287
2288 #define RGB_TO_U(r1, g1, b1, shift)\
2289 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2290      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2291
2292 #define RGB_TO_V(r1, g1, b1, shift)\
2293 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2294    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2295
2296 static void opt_pad_color(const char *arg) {
2297     /* Input is expected to be six hex digits similar to
2298        how colors are expressed in html tags (but without the #) */
2299     int rgb = strtol(arg, NULL, 16);
2300     int r,g,b;
2301
2302     r = (rgb >> 16);
2303     g = ((rgb >> 8) & 255);
2304     b = (rgb & 255);
2305
2306     padcolor[0] = RGB_TO_Y(r,g,b);
2307     padcolor[1] = RGB_TO_U(r,g,b,0);
2308     padcolor[2] = RGB_TO_V(r,g,b,0);
2309 }
2310
2311 static void opt_frame_pad_top(const char *arg)
2312 {
2313     frame_padtop = atoi(arg);
2314     if (frame_padtop < 0) {
2315         fprintf(stderr, "Incorrect top pad size\n");
2316         exit(1);
2317     }
2318     if ((frame_padtop % 2) != 0) {
2319         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2320         exit(1);
2321     }
2322 }
2323
2324 static void opt_frame_pad_bottom(const char *arg)
2325 {
2326     frame_padbottom = atoi(arg);
2327     if (frame_padbottom < 0) {
2328         fprintf(stderr, "Incorrect bottom pad size\n");
2329         exit(1);
2330     }
2331     if ((frame_padbottom % 2) != 0) {
2332         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2333         exit(1);
2334     }
2335 }
2336
2337
2338 static void opt_frame_pad_left(const char *arg)
2339 {
2340     frame_padleft = atoi(arg);
2341     if (frame_padleft < 0) {
2342         fprintf(stderr, "Incorrect left pad size\n");
2343         exit(1);
2344     }
2345     if ((frame_padleft % 2) != 0) {
2346         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2347         exit(1);
2348     }
2349 }
2350
2351
2352 static void opt_frame_pad_right(const char *arg)
2353 {
2354     frame_padright = atoi(arg);
2355     if (frame_padright < 0) {
2356         fprintf(stderr, "Incorrect right pad size\n");
2357         exit(1);
2358     }
2359     if ((frame_padright % 2) != 0) {
2360         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2361         exit(1);
2362     }
2363 }
2364
2365 void list_pix_fmts(void)
2366 {
2367     int i;
2368     char pix_fmt_str[128];
2369     for (i=-1; i < PIX_FMT_NB; i++) {
2370         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2371         fprintf(stdout, "%s\n", pix_fmt_str);
2372     }
2373 }
2374
2375 static void opt_frame_pix_fmt(const char *arg)
2376 {
2377     if (strcmp(arg, "list"))
2378         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2379     else {
2380         list_pix_fmts();
2381         exit(0);
2382     }
2383 }
2384
2385 static void opt_frame_aspect_ratio(const char *arg)
2386 {
2387     int x = 0, y = 0;
2388     double ar = 0;
2389     const char *p;
2390
2391     p = strchr(arg, ':');
2392     if (p) {
2393         x = strtol(arg, (char **)&arg, 10);
2394         if (arg == p)
2395             y = strtol(arg+1, (char **)&arg, 10);
2396         if (x > 0 && y > 0)
2397             ar = (double)x / (double)y;
2398     } else
2399         ar = strtod(arg, (char **)&arg);
2400
2401     if (!ar) {
2402         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2403         exit(1);
2404     }
2405     frame_aspect_ratio = ar;
2406 }
2407
2408 static void opt_qscale(const char *arg)
2409 {
2410     video_qscale = atof(arg);
2411     if (video_qscale <= 0 ||
2412         video_qscale > 255) {
2413         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2414         exit(1);
2415     }
2416 }
2417
2418 static void opt_qdiff(const char *arg)
2419 {
2420     video_qdiff = atoi(arg);
2421     if (video_qdiff < 0 ||
2422         video_qdiff > 31) {
2423         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2424         exit(1);
2425     }
2426 }
2427
2428 static void opt_strict(const char *arg)
2429 {
2430     strict= atoi(arg);
2431 }
2432
2433 static void opt_top_field_first(const char *arg)
2434 {
2435     top_field_first= atoi(arg);
2436 }
2437
2438 static void opt_thread_count(const char *arg)
2439 {
2440     thread_count= atoi(arg);
2441 #if !defined(HAVE_THREADS)
2442     if (verbose >= 0)
2443         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2444 #endif
2445 }
2446
2447 static void opt_audio_rate(const char *arg)
2448 {
2449     audio_sample_rate = atoi(arg);
2450 }
2451
2452 static void opt_audio_channels(const char *arg)
2453 {
2454     audio_channels = atoi(arg);
2455 }
2456
2457 static void opt_video_channel(const char *arg)
2458 {
2459     video_channel = strtol(arg, NULL, 0);
2460 }
2461
2462 static void opt_video_standard(const char *arg)
2463 {
2464     video_standard = av_strdup(arg);
2465 }
2466
2467 static void opt_codec(int *pstream_copy, char **pcodec_name,
2468                       int codec_type, const char *arg)
2469 {
2470     av_freep(pcodec_name);
2471     if (!strcmp(arg, "copy")) {
2472         *pstream_copy = 1;
2473     } else {
2474         *pcodec_name = av_strdup(arg);
2475     }
2476 }
2477
2478 static void opt_audio_codec(const char *arg)
2479 {
2480     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2481 }
2482
2483 static void opt_audio_tag(const char *arg)
2484 {
2485     char *tail;
2486     audio_codec_tag= strtol(arg, &tail, 0);
2487
2488     if(!tail || *tail)
2489         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2490 }
2491
2492 static void opt_video_tag(const char *arg)
2493 {
2494     char *tail;
2495     video_codec_tag= strtol(arg, &tail, 0);
2496
2497     if(!tail || *tail)
2498         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2499 }
2500
2501 #ifdef CONFIG_VHOOK
2502 static void add_frame_hooker(const char *arg)
2503 {
2504     int argc = 0;
2505     char *argv[64];
2506     int i;
2507     char *args = av_strdup(arg);
2508
2509     using_vhook = 1;
2510
2511     argv[0] = strtok(args, " ");
2512     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2513     }
2514
2515     i = frame_hook_add(argc, argv);
2516
2517     if (i != 0) {
2518         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2519         exit(1);
2520     }
2521 }
2522 #endif
2523
2524 static void opt_video_codec(const char *arg)
2525 {
2526     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2527 }
2528
2529 static void opt_subtitle_codec(const char *arg)
2530 {
2531     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2532 }
2533
2534 static void opt_map(const char *arg)
2535 {
2536     AVStreamMap *m;
2537     const char *p;
2538
2539     p = arg;
2540     m = &stream_maps[nb_stream_maps++];
2541
2542     m->file_index = strtol(arg, (char **)&p, 0);
2543     if (*p)
2544         p++;
2545
2546     m->stream_index = strtol(p, (char **)&p, 0);
2547     if (*p) {
2548         p++;
2549         m->sync_file_index = strtol(p, (char **)&p, 0);
2550         if (*p)
2551             p++;
2552         m->sync_stream_index = strtol(p, (char **)&p, 0);
2553     } else {
2554         m->sync_file_index = m->file_index;
2555         m->sync_stream_index = m->stream_index;
2556     }
2557 }
2558
2559 static void opt_map_meta_data(const char *arg)
2560 {
2561     AVMetaDataMap *m;
2562     const char *p;
2563
2564     p = arg;
2565     m = &meta_data_maps[nb_meta_data_maps++];
2566
2567     m->out_file = strtol(arg, (char **)&p, 0);
2568     if (*p)
2569         p++;
2570
2571     m->in_file = strtol(p, (char **)&p, 0);
2572 }
2573
2574 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2575 {
2576     int64_t us = parse_date(timestr, is_duration);
2577     if (us == INT64_MIN) {
2578         fprintf(stderr, "Invalid %s specification: %s\n",
2579                 is_duration ? "duration" : "date", timestr);
2580         exit(1);
2581     }
2582     return us;
2583 }
2584
2585 static void opt_recording_time(const char *arg)
2586 {
2587     recording_time = parse_time_or_die(arg, 1);
2588 }
2589
2590 static void opt_start_time(const char *arg)
2591 {
2592     start_time = parse_time_or_die(arg, 1);
2593 }
2594
2595 static void opt_rec_timestamp(const char *arg)
2596 {
2597     rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2598 }
2599
2600 static void opt_input_ts_offset(const char *arg)
2601 {
2602     input_ts_offset = parse_time_or_die(arg, 1);
2603 }
2604
2605 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2606 {
2607     char *codec_string = encoder ? "encoder" : "decoder";
2608     AVCodec *codec;
2609
2610     if(!name)
2611         return CODEC_ID_NONE;
2612     codec = encoder ?
2613         avcodec_find_encoder_by_name(name) :
2614         avcodec_find_decoder_by_name(name);
2615     if(!codec) {
2616         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2617         exit(1);
2618     }
2619     if(codec->type != type) {
2620         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2621         exit(1);
2622     }
2623     return codec->id;
2624 }
2625
2626 static void opt_input_file(const char *filename)
2627 {
2628     AVFormatContext *ic;
2629     AVFormatParameters params, *ap = &params;
2630     int err, i, ret, rfps, rfps_base;
2631     int64_t timestamp;
2632
2633     if (!strcmp(filename, "-"))
2634         filename = "pipe:";
2635
2636     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2637                    !strcmp( filename, "/dev/stdin" );
2638
2639     /* get default parameters from command line */
2640     ic = av_alloc_format_context();
2641
2642     memset(ap, 0, sizeof(*ap));
2643     ap->prealloced_context = 1;
2644     ap->sample_rate = audio_sample_rate;
2645     ap->channels = audio_channels;
2646     ap->time_base.den = frame_rate.num;
2647     ap->time_base.num = frame_rate.den;
2648     ap->width = frame_width + frame_padleft + frame_padright;
2649     ap->height = frame_height + frame_padtop + frame_padbottom;
2650     ap->pix_fmt = frame_pix_fmt;
2651     ap->channel = video_channel;
2652     ap->standard = video_standard;
2653     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2654     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2655     if(pgmyuv_compatibility_hack)
2656         ap->video_codec_id= CODEC_ID_PGMYUV;
2657
2658     for(i=0; i<opt_name_count; i++){
2659         char buf[256];
2660         const AVOption *opt;
2661         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2662         if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2663             av_set_string(ic, opt_names[i], str);
2664     }
2665
2666     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2667     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2668     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2669
2670     /* open the input file with generic libav function */
2671     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2672     if (err < 0) {
2673         print_error(filename, err);
2674         exit(1);
2675     }
2676     if(opt_programid) {
2677         int i;
2678         for(i=0; i<ic->nb_programs; i++)
2679             if(ic->programs[i]->id != opt_programid)
2680                 ic->programs[i]->discard = AVDISCARD_ALL;
2681     }
2682
2683     ic->loop_input = loop_input;
2684
2685     /* If not enough info to get the stream parameters, we decode the
2686        first frames to get it. (used in mpeg case for example) */
2687     ret = av_find_stream_info(ic);
2688     if (ret < 0 && verbose >= 0) {
2689         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2690         exit(1);
2691     }
2692
2693     timestamp = start_time;
2694     /* add the stream start time */
2695     if (ic->start_time != AV_NOPTS_VALUE)
2696         timestamp += ic->start_time;
2697
2698     /* if seeking requested, we execute it */
2699     if (start_time != 0) {
2700         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2701         if (ret < 0) {
2702             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2703                     filename, (double)timestamp / AV_TIME_BASE);
2704         }
2705         /* reset seek info */
2706         start_time = 0;
2707     }
2708
2709     /* update the current parameters so that they match the one of the input stream */
2710     for(i=0;i<ic->nb_streams;i++) {
2711         int j;
2712         AVCodecContext *enc = ic->streams[i]->codec;
2713         if(thread_count>1)
2714             avcodec_thread_init(enc, thread_count);
2715         enc->thread_count= thread_count;
2716         switch(enc->codec_type) {
2717         case CODEC_TYPE_AUDIO:
2718             for(j=0; j<opt_name_count; j++){
2719                 char buf[256];
2720                 const AVOption *opt;
2721                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2722                 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2723                     av_set_string(enc, opt_names[j], str);
2724             }
2725             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2726             audio_channels = enc->channels;
2727             audio_sample_rate = enc->sample_rate;
2728             if(audio_disable)
2729                 ic->streams[i]->discard= AVDISCARD_ALL;
2730             break;
2731         case CODEC_TYPE_VIDEO:
2732             for(j=0; j<opt_name_count; j++){
2733                 char buf[256];
2734                 const AVOption *opt;
2735                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2736                 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2737                     av_set_string(enc, opt_names[j], str);
2738             }
2739             frame_height = enc->height;
2740             frame_width = enc->width;
2741             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2742             frame_pix_fmt = enc->pix_fmt;
2743             rfps      = ic->streams[i]->r_frame_rate.num;
2744             rfps_base = ic->streams[i]->r_frame_rate.den;
2745             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2746             if(me_threshold)
2747                 enc->debug |= FF_DEBUG_MV;
2748
2749             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2750
2751                 if (verbose >= 0)
2752                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2753                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2754
2755                     (float)rfps / rfps_base, rfps, rfps_base);
2756             }
2757             /* update the current frame rate to match the stream frame rate */
2758             frame_rate.num = rfps;
2759             frame_rate.den = rfps_base;
2760
2761             enc->rate_emu = rate_emu;
2762             if(video_disable)
2763                 ic->streams[i]->discard= AVDISCARD_ALL;
2764             else if(video_discard)
2765                 ic->streams[i]->discard= video_discard;
2766             break;
2767         case CODEC_TYPE_DATA:
2768             break;
2769         case CODEC_TYPE_SUBTITLE:
2770             if(subtitle_disable)
2771                 ic->streams[i]->discard = AVDISCARD_ALL;
2772             break;
2773         case CODEC_TYPE_UNKNOWN:
2774             break;
2775         default:
2776             abort();
2777         }
2778     }
2779
2780     input_files[nb_input_files] = ic;
2781     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2782     /* dump the file content */
2783     if (verbose >= 0)
2784         dump_format(ic, nb_input_files, filename, 0);
2785
2786     nb_input_files++;
2787     file_iformat = NULL;
2788     file_oformat = NULL;
2789
2790     video_channel = 0;
2791
2792     rate_emu = 0;
2793     av_freep(&video_codec_name);
2794     av_freep(&audio_codec_name);
2795     av_freep(&subtitle_codec_name);
2796 }
2797
2798 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2799                                          int *has_subtitle_ptr)
2800 {
2801     int has_video, has_audio, has_subtitle, i, j;
2802     AVFormatContext *ic;
2803
2804     has_video = 0;
2805     has_audio = 0;
2806     has_subtitle = 0;
2807     for(j=0;j<nb_input_files;j++) {
2808         ic = input_files[j];
2809         for(i=0;i<ic->nb_streams;i++) {
2810             AVCodecContext *enc = ic->streams[i]->codec;
2811             switch(enc->codec_type) {
2812             case CODEC_TYPE_AUDIO:
2813                 has_audio = 1;
2814                 break;
2815             case CODEC_TYPE_VIDEO:
2816                 has_video = 1;
2817                 break;
2818             case CODEC_TYPE_SUBTITLE:
2819                 has_subtitle = 1;
2820                 break;
2821             case CODEC_TYPE_DATA:
2822             case CODEC_TYPE_UNKNOWN:
2823                 break;
2824             default:
2825                 abort();
2826             }
2827         }
2828     }
2829     *has_video_ptr = has_video;
2830     *has_audio_ptr = has_audio;
2831     *has_subtitle_ptr = has_subtitle;
2832 }
2833
2834 static void new_video_stream(AVFormatContext *oc)
2835 {
2836     AVStream *st;
2837     AVCodecContext *video_enc;
2838     int codec_id;
2839
2840     st = av_new_stream(oc, oc->nb_streams);
2841     if (!st) {
2842         fprintf(stderr, "Could not alloc stream\n");
2843         exit(1);
2844     }
2845     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2846     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2847     video_bitstream_filters= NULL;
2848
2849     if(thread_count>1)
2850         avcodec_thread_init(st->codec, thread_count);
2851
2852     video_enc = st->codec;
2853
2854     if(video_codec_tag)
2855         video_enc->codec_tag= video_codec_tag;
2856
2857     if(   (video_global_header&1)
2858        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2859         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2860         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2861     }
2862     if(video_global_header&2){
2863         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2864         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2865     }
2866
2867     if (video_stream_copy) {
2868         st->stream_copy = 1;
2869         video_enc->codec_type = CODEC_TYPE_VIDEO;
2870     } else {
2871         const char *p;
2872         int i;
2873         AVCodec *codec;
2874         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2875
2876         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2877         if (video_codec_name)
2878             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2879
2880         video_enc->codec_id = codec_id;
2881         codec = avcodec_find_encoder(codec_id);
2882
2883         for(i=0; i<opt_name_count; i++){
2884             char buf[256];
2885             const AVOption *opt;
2886             const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2887             if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2888                 av_set_string(video_enc, opt_names[i], str);
2889         }
2890
2891         video_enc->time_base.den = fps.num;
2892         video_enc->time_base.num = fps.den;
2893         if(codec && codec->supported_framerates){
2894             const AVRational *p= codec->supported_framerates;
2895             const AVRational *best=NULL;
2896             AVRational best_error= (AVRational){INT_MAX, 1};
2897             for(; p->den!=0; p++){
2898                 AVRational error= av_sub_q(fps, *p);
2899                 if(error.num <0) error.num *= -1;
2900                 if(av_cmp_q(error, best_error) < 0){
2901                     best_error= error;
2902                     best= p;
2903                 }
2904             }
2905             video_enc->time_base.den= best->num;
2906             video_enc->time_base.num= best->den;
2907         }
2908
2909         video_enc->width = frame_width + frame_padright + frame_padleft;
2910         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2911         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2912         video_enc->pix_fmt = frame_pix_fmt;
2913
2914         if(codec && codec->pix_fmts){
2915             const enum PixelFormat *p= codec->pix_fmts;
2916             for(; *p!=-1; p++){
2917                 if(*p == video_enc->pix_fmt)
2918                     break;
2919             }
2920             if(*p == -1)
2921                 video_enc->pix_fmt = codec->pix_fmts[0];
2922         }
2923
2924         if (intra_only)
2925             video_enc->gop_size = 0;
2926         if (video_qscale || same_quality) {
2927             video_enc->flags |= CODEC_FLAG_QSCALE;
2928             video_enc->global_quality=
2929                 st->quality = FF_QP2LAMBDA * video_qscale;
2930         }
2931
2932         if(intra_matrix)
2933             video_enc->intra_matrix = intra_matrix;
2934         if(inter_matrix)
2935             video_enc->inter_matrix = inter_matrix;
2936
2937         video_enc->max_qdiff = video_qdiff;
2938         video_enc->thread_count = thread_count;
2939         p= video_rc_override_string;
2940         for(i=0; p; i++){
2941             int start, end, q;
2942             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2943             if(e!=3){
2944                 fprintf(stderr, "error parsing rc_override\n");
2945                 exit(1);
2946             }
2947             video_enc->rc_override=
2948                 av_realloc(video_enc->rc_override,
2949                            sizeof(RcOverride)*(i+1));
2950             video_enc->rc_override[i].start_frame= start;
2951             video_enc->rc_override[i].end_frame  = end;
2952             if(q>0){
2953                 video_enc->rc_override[i].qscale= q;
2954                 video_enc->rc_override[i].quality_factor= 1.0;
2955             }
2956             else{
2957                 video_enc->rc_override[i].qscale= 0;
2958                 video_enc->rc_override[i].quality_factor= -q/100.0;
2959             }
2960             p= strchr(p, '/');
2961             if(p) p++;
2962         }
2963         video_enc->rc_override_count=i;
2964         if (!video_enc->rc_initial_buffer_occupancy)
2965             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2966         video_enc->me_threshold= me_threshold;
2967         video_enc->intra_dc_precision= intra_dc_precision - 8;
2968         video_enc->strict_std_compliance = strict;
2969
2970         if (do_psnr)
2971             video_enc->flags|= CODEC_FLAG_PSNR;
2972
2973         /* two pass mode */
2974         if (do_pass) {
2975             if (do_pass == 1) {
2976                 video_enc->flags |= CODEC_FLAG_PASS1;
2977             } else {
2978                 video_enc->flags |= CODEC_FLAG_PASS2;
2979             }
2980         }
2981     }
2982
2983     /* reset some key parameters */
2984     video_disable = 0;
2985     av_freep(&video_codec_name);
2986     video_stream_copy = 0;
2987 }
2988
2989 static void new_audio_stream(AVFormatContext *oc)
2990 {
2991     AVStream *st;
2992     AVCodecContext *audio_enc;
2993     int codec_id, i;
2994
2995     st = av_new_stream(oc, oc->nb_streams);
2996     if (!st) {
2997         fprintf(stderr, "Could not alloc stream\n");
2998         exit(1);
2999     }
3000     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3001
3002     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3003     audio_bitstream_filters= NULL;
3004
3005     if(thread_count>1)
3006         avcodec_thread_init(st->codec, thread_count);
3007
3008     audio_enc = st->codec;
3009     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3010     audio_enc->strict_std_compliance = strict;
3011
3012     if(audio_codec_tag)
3013         audio_enc->codec_tag= audio_codec_tag;
3014
3015     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3016         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3017         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3018     }
3019     if (audio_stream_copy) {
3020         st->stream_copy = 1;
3021         audio_enc->channels = audio_channels;
3022     } else {
3023         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3024
3025         for(i=0; i<opt_name_count; i++){
3026             char buf[256];
3027             const AVOption *opt;
3028             const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3029             if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3030                 av_set_string(audio_enc, opt_names[i], str);
3031         }
3032
3033         if (audio_codec_name)
3034             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3035         audio_enc->codec_id = codec_id;
3036
3037         if (audio_qscale > QSCALE_NONE) {
3038             audio_enc->flags |= CODEC_FLAG_QSCALE;
3039             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3040         }
3041         audio_enc->thread_count = thread_count;
3042         audio_enc->channels = audio_channels;
3043     }
3044     audio_enc->sample_rate = audio_sample_rate;
3045     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3046     if (audio_language) {
3047         av_strlcpy(st->language, audio_language, sizeof(st->language));
3048         av_free(audio_language);
3049         audio_language = NULL;
3050     }
3051
3052     /* reset some key parameters */
3053     audio_disable = 0;
3054     av_freep(&audio_codec_name);
3055     audio_stream_copy = 0;
3056 }
3057
3058 static void new_subtitle_stream(AVFormatContext *oc)
3059 {
3060     AVStream *st;
3061     AVCodecContext *subtitle_enc;
3062     int i;
3063
3064     st = av_new_stream(oc, oc->nb_streams);
3065     if (!st) {
3066         fprintf(stderr, "Could not alloc stream\n");
3067         exit(1);
3068     }
3069     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3070
3071     subtitle_enc = st->codec;
3072     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3073     if (subtitle_stream_copy) {
3074         st->stream_copy = 1;
3075     } else {
3076         for(i=0; i<opt_name_count; i++){
3077             char buf[256];
3078             const AVOption *opt;
3079             const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3080             if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3081                 av_set_string(subtitle_enc, opt_names[i], str);
3082         }
3083         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3084     }
3085
3086     if (subtitle_language) {
3087         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3088         av_free(subtitle_language);
3089         subtitle_language = NULL;
3090     }
3091
3092     subtitle_disable = 0;
3093     av_freep(&subtitle_codec_name);
3094     subtitle_stream_copy = 0;
3095 }
3096
3097 static void opt_new_audio_stream(void)
3098 {
3099     AVFormatContext *oc;
3100     if (nb_output_files <= 0) {
3101         fprintf(stderr, "At least one output file must be specified\n");
3102         exit(1);
3103     }
3104     oc = output_files[nb_output_files - 1];
3105     new_audio_stream(oc);
3106 }
3107
3108 static void opt_new_video_stream(void)
3109 {
3110     AVFormatContext *oc;
3111     if (nb_output_files <= 0) {
3112         fprintf(stderr, "At least one output file must be specified\n");
3113         exit(1);
3114     }
3115     oc = output_files[nb_output_files - 1];
3116     new_video_stream(oc);
3117 }
3118
3119 static void opt_new_subtitle_stream(void)
3120 {
3121     AVFormatContext *oc;
3122     if (nb_output_files <= 0) {
3123         fprintf(stderr, "At least one output file must be specified\n");
3124         exit(1);
3125     }
3126     oc = output_files[nb_output_files - 1];
3127     new_subtitle_stream(oc);
3128 }
3129
3130 static void opt_output_file(const char *filename)
3131 {
3132     AVFormatContext *oc;
3133     int use_video, use_audio, use_subtitle;
3134     int input_has_video, input_has_audio, input_has_subtitle, i;
3135     AVFormatParameters params, *ap = &params;
3136
3137     if (!strcmp(filename, "-"))
3138         filename = "pipe:";
3139
3140     oc = av_alloc_format_context();
3141
3142     if (!file_oformat) {
3143         file_oformat = guess_format(NULL, filename, NULL);
3144         if (!file_oformat) {
3145             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3146                     filename);
3147             exit(1);
3148         }
3149     }
3150
3151     oc->oformat = file_oformat;
3152     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3153
3154     if (!strcmp(file_oformat->name, "ffm") &&
3155         av_strstart(filename, "http:", NULL)) {
3156         /* special case for files sent to ffserver: we get the stream
3157            parameters from ffserver */
3158         if (read_ffserver_streams(oc, filename) < 0) {
3159             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3160             exit(1);
3161         }
3162     } else {
3163         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3164         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3165         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3166
3167         /* disable if no corresponding type found and at least one
3168            input file */
3169         if (nb_input_files > 0) {
3170             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3171                                          &input_has_subtitle);
3172             if (!input_has_video)
3173                 use_video = 0;
3174             if (!input_has_audio)
3175                 use_audio = 0;
3176             if (!input_has_subtitle)
3177                 use_subtitle = 0;
3178         }
3179
3180         /* manual disable */
3181         if (audio_disable) {
3182             use_audio = 0;
3183         }
3184         if (video_disable) {
3185             use_video = 0;
3186         }
3187         if (subtitle_disable) {
3188             use_subtitle = 0;
3189         }
3190
3191         if (use_video) {
3192             new_video_stream(oc);
3193         }
3194
3195         if (use_audio) {
3196             new_audio_stream(oc);
3197         }
3198
3199         if (use_subtitle) {
3200             new_subtitle_stream(oc);
3201         }
3202
3203         oc->timestamp = rec_timestamp;
3204
3205         if (str_title)
3206             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3207         if (str_author)
3208             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3209         if (str_copyright)
3210             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3211         if (str_comment)
3212             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3213         if (str_album)
3214             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3215     }
3216
3217     output_files[nb_output_files++] = oc;
3218
3219     /* check filename in case of an image number is expected */
3220     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3221         if (!av_filename_number_test(oc->filename)) {
3222             print_error(oc->filename, AVERROR_NUMEXPECTED);
3223             exit(1);
3224         }
3225     }
3226
3227     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3228         /* test if it already exists to avoid loosing precious files */
3229         if (!file_overwrite &&
3230             (strchr(filename, ':') == NULL ||
3231              filename[1] == ':' ||
3232              av_strstart(filename, "file:", NULL))) {
3233             if (url_exist(filename)) {
3234                 int c;
3235
3236                 if ( !using_stdin ) {
3237                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3238                     fflush(stderr);
3239                     c = getchar();
3240                     if (toupper(c) != 'Y') {
3241                         fprintf(stderr, "Not overwriting - exiting\n");
3242                         exit(1);
3243                     }
3244                                 }
3245                                 else {
3246                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3247                     exit(1);
3248                                 }
3249             }
3250         }
3251
3252         /* open the file */
3253         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3254             fprintf(stderr, "Could not open '%s'\n", filename);
3255             exit(1);
3256         }
3257     }
3258
3259     memset(ap, 0, sizeof(*ap));
3260     if (av_set_parameters(oc, ap) < 0) {
3261         fprintf(stderr, "%s: Invalid encoding parameters\n",
3262                 oc->filename);
3263         exit(1);
3264     }
3265
3266     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3267     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3268     oc->loop_output = loop_output;
3269
3270     for(i=0; i<opt_name_count; i++){
3271         char buf[256];
3272         const AVOption *opt;
3273         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3274         if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3275             av_set_string(oc, opt_names[i], str);
3276     }
3277
3278     /* reset some options */
3279     file_oformat = NULL;
3280     file_iformat = NULL;
3281 }
3282
3283 /* same option as mencoder */
3284 static void opt_pass(const char *pass_str)
3285 {
3286     int pass;
3287     pass = atoi(pass_str);
3288     if (pass != 1 && pass != 2) {
3289         fprintf(stderr, "pass number can be only 1 or 2\n");
3290         exit(1);
3291     }
3292     do_pass = pass;
3293 }
3294
3295 static int64_t getutime(void)
3296 {
3297 #ifdef HAVE_GETRUSAGE
3298     struct rusage rusage;
3299
3300     getrusage(RUSAGE_SELF, &rusage);
3301     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3302 #elif defined(HAVE_GETPROCESSTIMES)
3303     HANDLE proc;
3304     FILETIME c, e, k, u;
3305     proc = GetCurrentProcess();
3306     GetProcessTimes(proc, &c, &e, &k, &u);
3307     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3308 #else
3309     return av_gettime();
3310 #endif
3311 }
3312
3313 static void opt_show_formats(void)
3314 {
3315     AVInputFormat *ifmt=NULL;
3316     AVOutputFormat *ofmt=NULL;
3317     URLProtocol *up=NULL;
3318     AVCodec *p=NULL, *p2;
3319     AVBitStreamFilter *bsf=NULL;
3320     const char *last_name;
3321
3322     printf("File formats:\n");
3323     last_name= "000";
3324     for(;;){
3325         int decode=0;
3326         int encode=0;
3327         const char *name=NULL;
3328         const char *long_name=NULL;
3329
3330         while((ofmt= av_oformat_next(ofmt))) {
3331             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3332                 strcmp(ofmt->name, last_name)>0){
3333                 name= ofmt->name;
3334                 long_name= ofmt->long_name;
3335                 encode=1;
3336             }
3337         }
3338         while((ifmt= av_iformat_next(ifmt))) {
3339             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3340                 strcmp(ifmt->name, last_name)>0){
3341                 name= ifmt->name;
3342                 long_name= ifmt->long_name;
3343                 encode=0;
3344             }
3345             if(name && strcmp(ifmt->name, name)==0)
3346                 decode=1;
3347         }
3348         if(name==NULL)
3349             break;
3350         last_name= name;
3351
3352         printf(
3353             " %s%s %-15s %s\n",
3354             decode ? "D":" ",
3355             encode ? "E":" ",
3356             name,
3357             long_name ? long_name:" ");
3358     }
3359     printf("\n");
3360
3361     printf("Codecs:\n");
3362     last_name= "000";
3363     for(;;){
3364         int decode=0;
3365         int encode=0;
3366         int cap=0;
3367         const char *type_str;
3368
3369         p2=NULL;
3370         while((p= av_codec_next(p))) {
3371             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3372                 strcmp(p->name, last_name)>0){
3373                 p2= p;
3374                 decode= encode= cap=0;
3375             }
3376             if(p2 && strcmp(p->name, p2->name)==0){
3377                 if(p->decode) decode=1;
3378                 if(p->encode) encode=1;
3379                 cap |= p->capabilities;
3380             }
3381         }
3382         if(p2==NULL)
3383             break;
3384         last_name= p2->name;
3385
3386         switch(p2->type) {
3387         case CODEC_TYPE_VIDEO:
3388             type_str = "V";
3389             break;
3390         case CODEC_TYPE_AUDIO:
3391             type_str = "A";
3392             break;
3393         case CODEC_TYPE_SUBTITLE:
3394             type_str = "S";
3395             break;
3396         default:
3397             type_str = "?";
3398             break;
3399         }
3400         printf(
3401             " %s%s%s%s%s%s %s",
3402             decode ? "D": (/*p2->decoder ? "d":*/" "),
3403             encode ? "E":" ",
3404             type_str,
3405             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3406             cap & CODEC_CAP_DR1 ? "D":" ",
3407             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3408             p2->name);
3409        /* if(p2->decoder && decode==0)
3410             printf(" use %s for decoding", p2->decoder->name);*/
3411         printf("\n");
3412     }
3413     printf("\n");
3414
3415     printf("Bitstream filters:\n");
3416     while((bsf = av_bitstream_filter_next(bsf)))
3417         printf(" %s", bsf->name);
3418     printf("\n");
3419
3420     printf("Supported file protocols:\n");
3421     while((up = av_protocol_next(up)))
3422         printf(" %s:", up->name);
3423     printf("\n");
3424
3425     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3426     printf("\n");
3427     printf(
3428 "Note, the names of encoders and decoders do not always match, so there are\n"
3429 "several cases where the above table shows encoder only or decoder only entries\n"
3430 "even though both encoding and decoding are supported. For example, the h263\n"
3431 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3432 "worse.\n");
3433     exit(0);
3434 }
3435
3436 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3437 {
3438     int i;
3439     const char *p = str;
3440     for(i = 0;; i++) {
3441         dest[i] = atoi(p);
3442         if(i == 63)
3443             break;
3444         p = strchr(p, ',');
3445         if(!p) {
3446             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3447             exit(1);
3448         }
3449         p++;
3450     }
3451 }
3452
3453 static void opt_inter_matrix(const char *arg)
3454 {
3455     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3456     parse_matrix_coeffs(inter_matrix, arg);
3457 }
3458
3459 static void opt_intra_matrix(const char *arg)
3460 {
3461     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3462     parse_matrix_coeffs(intra_matrix, arg);
3463 }
3464
3465 /**
3466  * Trivial log callback.
3467  * Only suitable for show_help and similar since it lacks prefix handling.
3468  */
3469 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3470 {
3471     vfprintf(stdout, fmt, vl);
3472 }
3473
3474 static void show_help(void)
3475 {
3476     av_log_set_callback(log_callback_help);
3477     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3478            "Hyper fast Audio and Video encoder\n");
3479     printf("\n");
3480     show_help_options(options, "Main options:\n",
3481                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3482     show_help_options(options, "\nVideo options:\n",
3483                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3484                       OPT_VIDEO);
3485     show_help_options(options, "\nAdvanced Video options:\n",
3486                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3487                       OPT_VIDEO | OPT_EXPERT);
3488     show_help_options(options, "\nAudio options:\n",
3489                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3490                       OPT_AUDIO);
3491     show_help_options(options, "\nAdvanced Audio options:\n",
3492                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3493                       OPT_AUDIO | OPT_EXPERT);
3494     show_help_options(options, "\nSubtitle options:\n",
3495                       OPT_SUBTITLE | OPT_GRAB,
3496                       OPT_SUBTITLE);
3497     show_help_options(options, "\nAudio/Video grab options:\n",
3498                       OPT_GRAB,
3499                       OPT_GRAB);
3500     show_help_options(options, "\nAdvanced options:\n",
3501                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3502                       OPT_EXPERT);
3503     av_opt_show(avctx_opts[0], NULL);
3504     av_opt_show(avformat_opts, NULL);
3505     av_opt_show(sws_opts, NULL);
3506 }
3507
3508 static void opt_show_help(void)
3509 {
3510     show_help();
3511     exit(0);
3512 }
3513
3514 static void opt_target(const char *arg)
3515 {
3516     int norm = -1;
3517     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3518
3519     if(!strncmp(arg, "pal-", 4)) {
3520         norm = 0;
3521         arg += 4;
3522     } else if(!strncmp(arg, "ntsc-", 5)) {
3523         norm = 1;
3524         arg += 5;
3525     } else if(!strncmp(arg, "film-", 5)) {
3526         norm = 2;
3527         arg += 5;
3528     } else {
3529         int fr;
3530         /* Calculate FR via float to avoid int overflow */
3531         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3532         if(fr == 25000) {
3533             norm = 0;
3534         } else if((fr == 29970) || (fr == 23976)) {
3535             norm = 1;
3536         } else {
3537             /* Try to determine PAL/NTSC by peeking in the input files */
3538             if(nb_input_files) {
3539                 int i, j;
3540                 for(j = 0; j < nb_input_files; j++) {
3541                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3542                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3543                         if(c->codec_type != CODEC_TYPE_VIDEO)
3544                             continue;
3545                         fr = c->time_base.den * 1000 / c->time_base.num;
3546                         if(fr == 25000) {
3547                             norm = 0;
3548                             break;
3549                         } else if((fr == 29970) || (fr == 23976)) {
3550                             norm = 1;
3551                             break;
3552                         }
3553                     }
3554                     if(norm >= 0)
3555                         break;
3556                 }
3557             }
3558         }
3559         if(verbose && norm >= 0)
3560             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3561     }
3562
3563     if(norm < 0) {
3564         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3565         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3566         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3567         exit(1);
3568     }
3569
3570     if(!strcmp(arg, "vcd")) {
3571
3572         opt_video_codec("mpeg1video");
3573         opt_audio_codec("mp2");
3574         opt_format("vcd");
3575
3576         opt_frame_size(norm ? "352x240" : "352x288");
3577         opt_frame_rate(frame_rates[norm]);
3578         opt_default("gop", norm ? "18" : "15");
3579
3580         opt_default("b", "1150000");
3581         opt_default("maxrate", "1150000");
3582         opt_default("minrate", "1150000");
3583         opt_default("bufsize", "327680"); // 40*1024*8;
3584
3585         opt_default("ab", "224000");
3586         audio_sample_rate = 44100;
3587         audio_channels = 2;
3588
3589         opt_default("packetsize", "2324");
3590         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3591
3592         /* We have to offset the PTS, so that it is consistent with the SCR.
3593            SCR starts at 36000, but the first two packs contain only padding
3594            and the first pack from the other stream, respectively, may also have
3595            been written before.
3596            So the real data starts at SCR 36000+3*1200. */
3597         mux_preload= (36000+3*1200) / 90000.0; //0.44
3598     } else if(!strcmp(arg, "svcd")) {
3599
3600         opt_video_codec("mpeg2video");
3601         opt_audio_codec("mp2");
3602         opt_format("svcd");
3603
3604         opt_frame_size(norm ? "480x480" : "480x576");
3605         opt_frame_rate(frame_rates[norm]);
3606         opt_default("gop", norm ? "18" : "15");
3607
3608         opt_default("b", "2040000");
3609         opt_default("maxrate", "2516000");
3610         opt_default("minrate", "0"); //1145000;
3611         opt_default("bufsize", "1835008"); //224*1024*8;
3612         opt_default("flags", "+SCAN_OFFSET");
3613
3614
3615         opt_default("ab", "224000");
3616         audio_sample_rate = 44100;
3617
3618         opt_default("packetsize", "2324");
3619
3620     } else if(!strcmp(arg, "dvd")) {
3621
3622         opt_video_codec("mpeg2video");
3623         opt_audio_codec("ac3");
3624         opt_format("dvd");
3625
3626         opt_frame_size(norm ? "720x480" : "720x576");
3627         opt_frame_rate(frame_rates[norm]);
3628         opt_default("gop", norm ? "18" : "15");
3629
3630         opt_default("b", "6000000");
3631         opt_default("maxrate", "9000000");
3632         opt_default("minrate", "0"); //1500000;
3633         opt_default("bufsize", "1835008"); //224*1024*8;
3634
3635         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3636         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3637
3638         opt_default("ab", "448000");
3639         audio_sample_rate = 48000;
3640
3641     } else if(!strncmp(arg, "dv", 2)) {
3642
3643         opt_format("dv");
3644
3645         opt_frame_size(norm ? "720x480" : "720x576");
3646         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3647                                              (norm ? "yuv411p" : "yuv420p"));
3648         opt_frame_rate(frame_rates[norm]);
3649
3650         audio_sample_rate = 48000;
3651         audio_channels = 2;
3652
3653     } else {
3654         fprintf(stderr, "Unknown target: %s\n", arg);
3655         exit(1);
3656     }
3657 }
3658
3659 static void opt_vstats_file (const char *arg)
3660 {
3661     av_free (vstats_filename);
3662     vstats_filename=av_strdup (arg);
3663 }
3664
3665 static void opt_vstats (void)
3666 {
3667     char filename[40];
3668     time_t today2 = time(NULL);
3669     struct tm *today = localtime(&today2);
3670
3671     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3672              today->tm_sec);
3673     opt_vstats_file(filename);
3674 }
3675
3676 static int opt_bsf(const char *opt, const char *arg)
3677 {
3678     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3679     AVBitStreamFilterContext **bsfp;
3680
3681     if(!bsfc){
3682         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3683         exit(1);
3684     }
3685
3686     bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3687     while(*bsfp)
3688         bsfp= &(*bsfp)->next;
3689
3690     *bsfp= bsfc;
3691
3692     return 0;
3693 }
3694
3695 static void opt_show_license(void)
3696 {
3697     show_license();
3698     exit(0);
3699 }
3700
3701 static void opt_show_version(void)
3702 {
3703     show_version(program_name);
3704     exit(0);
3705 }
3706
3707 const OptionDef options[] = {
3708     /* main options */
3709     { "L", 0, {(void*)opt_show_license}, "show license" },
3710     { "h", 0, {(void*)opt_show_help}, "show help" },
3711     { "version", 0, {(void*)opt_show_version}, "show version" },
3712     { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3713     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3714     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3715     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3716     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3717     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3718     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3719     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3720     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3721     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },