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