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