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