skiprd doxygen comment from avcodec.h -> AVOption comment
[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         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                 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                 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              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         video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2872         video_enc->me_threshold= me_threshold;
2873         video_enc->intra_dc_precision= intra_dc_precision - 8;
2874         video_enc->strict_std_compliance = strict;
2875
2876         if(packet_size){
2877             video_enc->rtp_mode= 1;
2878             video_enc->rtp_payload_size= packet_size;
2879         }
2880
2881         if (do_psnr)
2882             video_enc->flags|= CODEC_FLAG_PSNR;
2883
2884         video_enc->me_method = me_method;
2885
2886         /* two pass mode */
2887         if (do_pass) {
2888             if (do_pass == 1) {
2889                 video_enc->flags |= CODEC_FLAG_PASS1;
2890             } else {
2891                 video_enc->flags |= CODEC_FLAG_PASS2;
2892             }
2893         }
2894     }
2895
2896     /* reset some key parameters */
2897     video_disable = 0;
2898     video_codec_id = CODEC_ID_NONE;
2899     video_stream_copy = 0;
2900 }
2901
2902 static void new_audio_stream(AVFormatContext *oc)
2903 {
2904     AVStream *st;
2905     AVCodecContext *audio_enc;
2906     int codec_id, i;
2907
2908     st = av_new_stream(oc, oc->nb_streams);
2909     if (!st) {
2910         fprintf(stderr, "Could not alloc stream\n");
2911         exit(1);
2912     }
2913
2914     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2915     audio_bitstream_filters= NULL;
2916
2917 #if defined(HAVE_THREADS)
2918     if(thread_count>1)
2919         avcodec_thread_init(st->codec, thread_count);
2920 #endif
2921
2922     audio_enc = st->codec;
2923     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2924     audio_enc->strict_std_compliance = strict;
2925
2926     if(audio_codec_tag)
2927         audio_enc->codec_tag= audio_codec_tag;
2928
2929     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2930         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2931         avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2932     }
2933     if (audio_stream_copy) {
2934         st->stream_copy = 1;
2935         audio_enc->channels = audio_channels;
2936     } else {
2937         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2938
2939         for(i=0; i<opt_name_count; i++){
2940             AVOption *opt;
2941             double d= av_get_double(avctx_opts, opt_names[i], &opt);
2942             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2943                 av_set_double(audio_enc, opt_names[i], d);
2944         }
2945
2946         if (audio_codec_id != CODEC_ID_NONE)
2947             codec_id = audio_codec_id;
2948         audio_enc->codec_id = codec_id;
2949
2950         audio_enc->bit_rate = audio_bit_rate;
2951         if (audio_qscale > QSCALE_NONE) {
2952             audio_enc->flags |= CODEC_FLAG_QSCALE;
2953             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2954         }
2955         audio_enc->thread_count = thread_count;
2956         /* For audio codecs other than AC3 or DTS we limit */
2957         /* the number of coded channels to stereo   */
2958         if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2959             && codec_id != CODEC_ID_DTS) {
2960             audio_enc->channels = 2;
2961         } else
2962             audio_enc->channels = audio_channels;
2963     }
2964     audio_enc->sample_rate = audio_sample_rate;
2965     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2966     if (audio_language) {
2967         pstrcpy(st->language, sizeof(st->language), audio_language);
2968         av_free(audio_language);
2969         audio_language = NULL;
2970     }
2971
2972     /* reset some key parameters */
2973     audio_disable = 0;
2974     audio_codec_id = CODEC_ID_NONE;
2975     audio_stream_copy = 0;
2976 }
2977
2978 static void opt_new_subtitle_stream(void)
2979 {
2980     AVFormatContext *oc;
2981     AVStream *st;
2982     AVCodecContext *subtitle_enc;
2983     int i;
2984
2985     if (nb_output_files <= 0) {
2986         fprintf(stderr, "At least one output file must be specified\n");
2987         exit(1);
2988     }
2989     oc = output_files[nb_output_files - 1];
2990
2991     st = av_new_stream(oc, oc->nb_streams);
2992     if (!st) {
2993         fprintf(stderr, "Could not alloc stream\n");
2994         exit(1);
2995     }
2996
2997     subtitle_enc = st->codec;
2998     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2999     if (subtitle_stream_copy) {
3000         st->stream_copy = 1;
3001     } else {
3002         for(i=0; i<opt_name_count; i++){
3003              AVOption *opt;
3004              double d= av_get_double(avctx_opts, opt_names[i], &opt);
3005              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3006                  av_set_double(subtitle_enc, opt_names[i], d);
3007         }
3008         subtitle_enc->codec_id = subtitle_codec_id;
3009     }
3010
3011     if (subtitle_language) {
3012         pstrcpy(st->language, sizeof(st->language), subtitle_language);
3013         av_free(subtitle_language);
3014         subtitle_language = NULL;
3015     }
3016
3017     subtitle_codec_id = CODEC_ID_NONE;
3018     subtitle_stream_copy = 0;
3019 }
3020
3021 static void opt_new_audio_stream(void)
3022 {
3023     AVFormatContext *oc;
3024     if (nb_output_files <= 0) {
3025         fprintf(stderr, "At least one output file must be specified\n");
3026         exit(1);
3027     }
3028     oc = output_files[nb_output_files - 1];
3029     new_audio_stream(oc);
3030 }
3031
3032 static void opt_new_video_stream(void)
3033 {
3034     AVFormatContext *oc;
3035     if (nb_output_files <= 0) {
3036         fprintf(stderr, "At least one output file must be specified\n");
3037         exit(1);
3038     }
3039     oc = output_files[nb_output_files - 1];
3040     new_video_stream(oc);
3041 }
3042
3043 static void opt_output_file(const char *filename)
3044 {
3045     AVFormatContext *oc;
3046     int use_video, use_audio, input_has_video, input_has_audio, i;
3047     AVFormatParameters params, *ap = &params;
3048
3049     if (!strcmp(filename, "-"))
3050         filename = "pipe:";
3051
3052     oc = av_alloc_format_context();
3053
3054     if (!file_oformat) {
3055         file_oformat = guess_format(NULL, filename, NULL);
3056         if (!file_oformat) {
3057             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3058                     filename);
3059             exit(1);
3060         }
3061     }
3062
3063     oc->oformat = file_oformat;
3064     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3065
3066     if (!strcmp(file_oformat->name, "ffm") &&
3067         strstart(filename, "http:", NULL)) {
3068         /* special case for files sent to ffserver: we get the stream
3069            parameters from ffserver */
3070         if (read_ffserver_streams(oc, filename) < 0) {
3071             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3072             exit(1);
3073         }
3074     } else {
3075         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3076         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3077
3078         /* disable if no corresponding type found and at least one
3079            input file */
3080         if (nb_input_files > 0) {
3081             check_audio_video_inputs(&input_has_video, &input_has_audio);
3082             if (!input_has_video)
3083                 use_video = 0;
3084             if (!input_has_audio)
3085                 use_audio = 0;
3086         }
3087
3088         /* manual disable */
3089         if (audio_disable) {
3090             use_audio = 0;
3091         }
3092         if (video_disable) {
3093             use_video = 0;
3094         }
3095
3096         if (use_video) {
3097             new_video_stream(oc);
3098         }
3099
3100         if (use_audio) {
3101             new_audio_stream(oc);
3102         }
3103
3104         oc->timestamp = rec_timestamp;
3105
3106         if (str_title)
3107             pstrcpy(oc->title, sizeof(oc->title), str_title);
3108         if (str_author)
3109             pstrcpy(oc->author, sizeof(oc->author), str_author);
3110         if (str_copyright)
3111             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3112         if (str_comment)
3113             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3114         if (str_album)
3115             pstrcpy(oc->album, sizeof(oc->album), str_album);
3116     }
3117
3118     output_files[nb_output_files++] = oc;
3119
3120     /* check filename in case of an image number is expected */
3121     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3122         if (!av_filename_number_test(oc->filename)) {
3123             print_error(oc->filename, AVERROR_NUMEXPECTED);
3124             exit(1);
3125         }
3126     }
3127
3128     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3129         /* test if it already exists to avoid loosing precious files */
3130         if (!file_overwrite &&
3131             (strchr(filename, ':') == NULL ||
3132              strstart(filename, "file:", NULL))) {
3133             if (url_exist(filename)) {
3134                 int c;
3135
3136                 if ( !using_stdin ) {
3137                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3138                     fflush(stderr);
3139                     c = getchar();
3140                     if (toupper(c) != 'Y') {
3141                         fprintf(stderr, "Not overwriting - exiting\n");
3142                         exit(1);
3143                     }
3144                                 }
3145                                 else {
3146                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3147                     exit(1);
3148                                 }
3149             }
3150         }
3151
3152         /* open the file */
3153         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3154             fprintf(stderr, "Could not open '%s'\n", filename);
3155             exit(1);
3156         }
3157     }
3158
3159     memset(ap, 0, sizeof(*ap));
3160     if (av_set_parameters(oc, ap) < 0) {
3161         fprintf(stderr, "%s: Invalid encoding parameters\n",
3162                 oc->filename);
3163         exit(1);
3164     }
3165
3166     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3167     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3168     oc->loop_output = loop_output;
3169
3170     for(i=0; i<opt_name_count; i++){
3171         AVOption *opt;
3172         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3173         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3174             av_set_double(oc, opt_names[i], d);
3175     }
3176
3177     /* reset some options */
3178     file_oformat = NULL;
3179     file_iformat = NULL;
3180 }
3181
3182 /* prepare dummy protocols for grab */
3183 static void prepare_grab(void)
3184 {
3185     int has_video, has_audio, i, j;
3186     AVFormatContext *oc;
3187     AVFormatContext *ic;
3188     AVFormatParameters vp1, *vp = &vp1;
3189     AVFormatParameters ap1, *ap = &ap1;
3190
3191     /* see if audio/video inputs are needed */
3192     has_video = 0;
3193     has_audio = 0;
3194     memset(ap, 0, sizeof(*ap));
3195     memset(vp, 0, sizeof(*vp));
3196     vp->time_base.num= 1;
3197     for(j=0;j<nb_output_files;j++) {
3198         oc = output_files[j];
3199         for(i=0;i<oc->nb_streams;i++) {
3200             AVCodecContext *enc = oc->streams[i]->codec;
3201             switch(enc->codec_type) {
3202             case CODEC_TYPE_AUDIO:
3203                 if (enc->sample_rate > ap->sample_rate)
3204                     ap->sample_rate = enc->sample_rate;
3205                 if (enc->channels > ap->channels)
3206                     ap->channels = enc->channels;
3207                 has_audio = 1;
3208                 break;
3209             case CODEC_TYPE_VIDEO:
3210                 if (enc->width > vp->width)
3211                     vp->width = enc->width;
3212                 if (enc->height > vp->height)
3213                     vp->height = enc->height;
3214
3215                 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3216                     vp->time_base = enc->time_base;
3217                     vp->width += frame_leftBand + frame_rightBand;
3218                     vp->width -= (frame_padleft + frame_padright);
3219                     vp->height += frame_topBand + frame_bottomBand;
3220                     vp->height -= (frame_padtop + frame_padbottom);
3221                 }
3222                 has_video = 1;
3223                 break;
3224             default:
3225                 av_abort();
3226             }
3227         }
3228     }
3229
3230     if (has_video == 0 && has_audio == 0) {
3231         fprintf(stderr, "Output file must have at least one audio or video stream\n");
3232         exit(1);
3233     }
3234
3235     if (has_video) {
3236         AVInputFormat *fmt1;
3237 #warning FIXME: find a better interface
3238         if(!strncmp(video_device,"x11:",4)) {
3239             video_grab_format="x11grab";
3240         }
3241         fmt1 = av_find_input_format(video_grab_format);
3242         vp->device  = video_device;
3243         vp->channel = video_channel;
3244         vp->standard = video_standard;
3245         vp->pix_fmt = frame_pix_fmt;
3246         if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3247             fprintf(stderr, "Could not find video grab device\n");
3248             exit(1);
3249         }
3250         /* If not enough info to get the stream parameters, we decode the
3251            first frames to get it. */
3252         if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3253             fprintf(stderr, "Could not find video grab parameters\n");
3254             exit(1);
3255         }
3256         /* by now video grab has one stream */
3257         ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3258         ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3259         input_files[nb_input_files] = ic;
3260
3261         if (verbose >= 0)
3262             dump_format(ic, nb_input_files, "", 0);
3263
3264         nb_input_files++;
3265     }
3266     if (has_audio && audio_grab_format) {
3267         AVInputFormat *fmt1;
3268         fmt1 = av_find_input_format(audio_grab_format);
3269         ap->device = audio_device;
3270         if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3271             fprintf(stderr, "Could not find audio grab device\n");
3272             exit(1);
3273         }
3274         input_files[nb_input_files] = ic;
3275
3276         if (verbose >= 0)
3277             dump_format(ic, nb_input_files, "", 0);
3278
3279         nb_input_files++;
3280     }
3281 }
3282
3283 /* same option as mencoder */
3284 static void opt_pass(const char *pass_str)
3285 {
3286     int pass;
3287     pass = atoi(pass_str);
3288     if (pass != 1 && pass != 2) {
3289         fprintf(stderr, "pass number can be only 1 or 2\n");
3290         exit(1);
3291     }
3292     do_pass = pass;
3293 }
3294
3295 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3296 static int64_t getutime(void)
3297 {
3298   return av_gettime();
3299 }
3300 #else
3301 static int64_t getutime(void)
3302 {
3303     struct rusage rusage;
3304
3305     getrusage(RUSAGE_SELF, &rusage);
3306     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3307 }
3308 #endif
3309
3310 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3311 extern int ffm_nopts;
3312 #endif
3313
3314 static void show_formats(void)
3315 {
3316     AVInputFormat *ifmt;
3317     AVOutputFormat *ofmt;
3318     URLProtocol *up;
3319     AVCodec *p, *p2;
3320     const char **pp, *last_name;
3321
3322     printf("File formats:\n");
3323     last_name= "000";
3324     for(;;){
3325         int decode=0;
3326         int encode=0;
3327         const char *name=NULL;
3328         const char *long_name=NULL;
3329
3330         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3331             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3332                 strcmp(ofmt->name, last_name)>0){
3333                 name= ofmt->name;
3334                 long_name= ofmt->long_name;
3335                 encode=1;
3336             }
3337         }
3338         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3339             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3340                 strcmp(ifmt->name, last_name)>0){
3341                 name= ifmt->name;
3342                 long_name= ifmt->long_name;
3343                 encode=0;
3344             }
3345             if(name && strcmp(ifmt->name, name)==0)
3346                 decode=1;
3347         }
3348         if(name==NULL)
3349             break;
3350         last_name= name;
3351
3352         printf(
3353             " %s%s %-15s %s\n",
3354             decode ? "D":" ",
3355             encode ? "E":" ",
3356             name,
3357             long_name ? long_name:" ");
3358     }
3359     printf("\n");
3360
3361     printf("Codecs:\n");
3362     last_name= "000";
3363     for(;;){
3364         int decode=0;
3365         int encode=0;
3366         int cap=0;
3367         const char *type_str;
3368
3369         p2=NULL;
3370         for(p = first_avcodec; p != NULL; p = p->next) {
3371             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3372                 strcmp(p->name, last_name)>0){
3373                 p2= p;
3374                 decode= encode= cap=0;
3375             }
3376             if(p2 && strcmp(p->name, p2->name)==0){
3377                 if(p->decode) decode=1;
3378                 if(p->encode) encode=1;
3379                 cap |= p->capabilities;
3380             }
3381         }
3382         if(p2==NULL)
3383             break;
3384         last_name= p2->name;
3385
3386         switch(p2->type) {
3387         case CODEC_TYPE_VIDEO:
3388             type_str = "V";
3389             break;
3390         case CODEC_TYPE_AUDIO:
3391             type_str = "A";
3392             break;
3393         case CODEC_TYPE_SUBTITLE:
3394             type_str = "S";
3395             break;
3396         default:
3397             type_str = "?";
3398             break;
3399         }
3400         printf(
3401             " %s%s%s%s%s%s %s",
3402             decode ? "D": (/*p2->decoder ? "d":*/" "),
3403             encode ? "E":" ",
3404             type_str,
3405             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3406             cap & CODEC_CAP_DR1 ? "D":" ",
3407             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3408             p2->name);
3409        /* if(p2->decoder && decode==0)
3410             printf(" use %s for decoding", p2->decoder->name);*/
3411         printf("\n");
3412     }
3413     printf("\n");
3414
3415     printf("Supported file protocols:\n");
3416     for(up = first_protocol; up != NULL; up = up->next)
3417         printf(" %s:", up->name);
3418     printf("\n");
3419
3420     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3421     printf("Motion estimation methods:\n");
3422     pp = motion_str;
3423     while (*pp) {
3424         printf(" %s", *pp);
3425         if ((pp - motion_str + 1) == ME_ZERO)
3426             printf("(fastest)");
3427         else if ((pp - motion_str + 1) == ME_FULL)
3428             printf("(slowest)");
3429         else if ((pp - motion_str + 1) == ME_EPZS)
3430             printf("(default)");
3431         pp++;
3432     }
3433     printf("\n\n");
3434     printf(
3435 "Note, the names of encoders and decoders dont always match, so there are\n"
3436 "several cases where the above table shows encoder only or decoder only entries\n"
3437 "even though both encoding and decoding are supported for example, the h263\n"
3438 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3439 "worse\n");
3440     exit(1);
3441 }
3442
3443 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3444 {
3445     int i;
3446     const char *p = str;
3447     for(i = 0;; i++) {
3448         dest[i] = atoi(p);
3449         if(i == 63)
3450             break;
3451         p = strchr(p, ',');
3452         if(!p) {
3453             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3454             exit(1);
3455         }
3456         p++;
3457     }
3458 }
3459
3460 static void opt_inter_matrix(const char *arg)
3461 {
3462     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3463     parse_matrix_coeffs(inter_matrix, arg);
3464 }
3465
3466 static void opt_intra_matrix(const char *arg)
3467 {
3468     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469     parse_matrix_coeffs(intra_matrix, arg);
3470 }
3471
3472 static void opt_target(const char *arg)
3473 {
3474     int norm = -1;
3475     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3476
3477     if(!strncmp(arg, "pal-", 4)) {
3478         norm = 0;
3479         arg += 4;
3480     } else if(!strncmp(arg, "ntsc-", 5)) {
3481         norm = 1;
3482         arg += 5;
3483     } else if(!strncmp(arg, "film-", 5)) {
3484         norm = 2;
3485         arg += 5;
3486     } else {
3487         int fr;
3488         /* Calculate FR via float to avoid int overflow */
3489         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3490         if(fr == 25000) {
3491             norm = 0;
3492         } else if((fr == 29970) || (fr == 23976)) {
3493             norm = 1;
3494         } else {
3495             /* Try to determine PAL/NTSC by peeking in the input files */
3496             if(nb_input_files) {
3497                 int i, j;
3498                 for(j = 0; j < nb_input_files; j++) {
3499                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3500                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3501                         if(c->codec_type != CODEC_TYPE_VIDEO)
3502                             continue;
3503                         fr = c->time_base.den * 1000 / c->time_base.num;
3504                         if(fr == 25000) {
3505                             norm = 0;
3506                             break;
3507                         } else if((fr == 29970) || (fr == 23976)) {
3508                             norm = 1;
3509                             break;
3510                         }
3511                     }
3512                     if(norm >= 0)
3513                         break;
3514                 }
3515             }
3516         }
3517         if(verbose && norm >= 0)
3518             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3519     }
3520
3521     if(norm < 0) {
3522         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3523         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3524         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3525         exit(1);
3526     }
3527
3528     if(!strcmp(arg, "vcd")) {
3529
3530         opt_video_codec("mpeg1video");
3531         opt_audio_codec("mp2");
3532         opt_format("vcd");
3533
3534         opt_frame_size(norm ? "352x240" : "352x288");
3535         opt_frame_rate(frame_rates[norm]);
3536         opt_default("gop", norm ? "18" : "15");
3537
3538         opt_default("b", "1150000");
3539         opt_default("maxrate", "1150000");
3540         opt_default("minrate", "1150000");
3541         opt_default("bufsize", "327680"); // 40*1024*8;
3542
3543         audio_bit_rate = 224000;
3544         audio_sample_rate = 44100;
3545
3546         opt_default("packetsize", "2324");
3547         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3548
3549         /* We have to offset the PTS, so that it is consistent with the SCR.
3550            SCR starts at 36000, but the first two packs contain only padding
3551            and the first pack from the other stream, respectively, may also have
3552            been written before.
3553            So the real data starts at SCR 36000+3*1200. */
3554         mux_preload= (36000+3*1200) / 90000.0; //0.44
3555     } else if(!strcmp(arg, "svcd")) {
3556
3557         opt_video_codec("mpeg2video");
3558         opt_audio_codec("mp2");
3559         opt_format("svcd");
3560
3561         opt_frame_size(norm ? "480x480" : "480x576");
3562         opt_frame_rate(frame_rates[norm]);
3563         opt_default("gop", norm ? "18" : "15");
3564
3565         opt_default("b", "2040000");
3566         opt_default("maxrate", "2516000");
3567         opt_default("minrate", "0"); //1145000;
3568         opt_default("bufsize", "1835008"); //224*1024*8;
3569         opt_default("flags", "+SCAN_OFFSET");
3570
3571
3572         audio_bit_rate = 224000;
3573         audio_sample_rate = 44100;
3574
3575         opt_default("packetsize", "2324");
3576
3577     } else if(!strcmp(arg, "dvd")) {
3578
3579         opt_video_codec("mpeg2video");
3580         opt_audio_codec("ac3");
3581         opt_format("dvd");
3582
3583         opt_frame_size(norm ? "720x480" : "720x576");
3584         opt_frame_rate(frame_rates[norm]);
3585         opt_default("gop", norm ? "18" : "15");
3586
3587         opt_default("b", "6000000");
3588         opt_default("maxrate", "9000000");
3589         opt_default("minrate", "0"); //1500000;
3590         opt_default("bufsize", "1835008"); //224*1024*8;
3591
3592         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3593         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3594
3595         audio_bit_rate = 448000;
3596         audio_sample_rate = 48000;
3597
3598     } else if(!strncmp(arg, "dv", 2)) {
3599
3600         opt_format("dv");
3601
3602         opt_frame_size(norm ? "720x480" : "720x576");
3603         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3604                                              (norm ? "yuv411p" : "yuv420p"));
3605         opt_frame_rate(frame_rates[norm]);
3606
3607         audio_sample_rate = 48000;
3608         audio_channels = 2;
3609
3610     } else {
3611         fprintf(stderr, "Unknown target: %s\n", arg);
3612         exit(1);
3613     }
3614 }
3615
3616 static void opt_video_bsf(const char *arg)
3617 {
3618     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3619     AVBitStreamFilterContext **bsfp;
3620
3621     if(!bsfc){
3622         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3623         exit(1);
3624     }
3625
3626     bsfp= &video_bitstream_filters;
3627     while(*bsfp)
3628         bsfp= &(*bsfp)->next;
3629
3630     *bsfp= bsfc;
3631 }
3632
3633 //FIXME avoid audio - video code duplication
3634 static void opt_audio_bsf(const char *arg)
3635 {
3636     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3637     AVBitStreamFilterContext **bsfp;
3638
3639     if(!bsfc){
3640         fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3641         exit(1);
3642     }
3643
3644     bsfp= &audio_bitstream_filters;
3645     while(*bsfp)
3646         bsfp= &(*bsfp)->next;
3647
3648     *bsfp= bsfc;
3649 }
3650
3651 static void show_version(void)
3652 {
3653     /* TODO: add function interface to avutil and avformat */
3654     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3655            "libavutil   %d\n"
3656            "libavcodec  %d\n"
3657            "libavformat %d\n",
3658            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3659     exit(1);
3660 }
3661
3662 static int opt_default(const char *opt, const char *arg){
3663     AVOption *o= av_set_string(avctx_opts, opt, arg);
3664     if(!o)
3665         o = av_set_string(avformat_opts, opt, arg);
3666     if(!o)
3667         return -1;
3668
3669 //    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));
3670
3671     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3672     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3673     opt_names[opt_name_count++]= o->name;
3674
3675 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3676     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3677     if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3678         ffm_nopts = 1;
3679 #endif
3680
3681     if(avctx_opts->debug)
3682         av_log_set_level(AV_LOG_DEBUG);
3683     return 0;
3684 }
3685
3686 const OptionDef options[] = {
3687     /* main options */
3688     { "L", 0, {(void*)show_license}, "show license" },
3689     { "h", 0, {(void*)show_help}, "show help" },
3690     { "version", 0, {(void*)show_version}, "show version" },
3691     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3692     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3693     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3694     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3695     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3696     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3697     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3698     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3699     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3700     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3701     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3702     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3703     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3704     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3705     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3706     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3707     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3708       "add timings for benchmarking" },
3709     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3710       "dump each input packet" },
3711     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3712       "when dumping packets, also dump the payload" },
3713     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3714     { "loop_input", OPT_BOOL | OPT_EXPER