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