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