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