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