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