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