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