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