Make video hook infrastructure conditional on video hooks being enabled.
[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.flags= pkt->flags;
1241
1242                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1243                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1244                             opkt.destruct= av_destruct_packet;
1245
1246                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1247                         ost->st->codec->frame_number++;
1248                         ost->frame_number++;
1249                         av_free_packet(&opkt);
1250                     }
1251                 }
1252             }
1253         av_free(buffer_to_free);
1254         /* XXX: allocate the subtitles in the codec ? */
1255         if (subtitle_to_free) {
1256             if (subtitle_to_free->rects != NULL) {
1257                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1258                     av_free(subtitle_to_free->rects[i].bitmap);
1259                     av_free(subtitle_to_free->rects[i].rgba_palette);
1260                 }
1261                 av_freep(&subtitle_to_free->rects);
1262             }
1263             subtitle_to_free->num_rects = 0;
1264             subtitle_to_free = NULL;
1265         }
1266     }
1267  discard_packet:
1268     if (pkt == NULL) {
1269         /* EOF handling */
1270
1271         for(i=0;i<nb_ostreams;i++) {
1272             ost = ost_table[i];
1273             if (ost->source_index == ist_index) {
1274                 AVCodecContext *enc= ost->st->codec;
1275                 os = output_files[ost->file_index];
1276
1277                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1278                     continue;
1279                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1280                     continue;
1281
1282                 if (ost->encoding_needed) {
1283                     for(;;) {
1284                         AVPacket pkt;
1285                         int fifo_bytes;
1286                         av_init_packet(&pkt);
1287                         pkt.stream_index= ost->index;
1288
1289                         switch(ost->st->codec->codec_type) {
1290                         case CODEC_TYPE_AUDIO:
1291                             fifo_bytes = av_fifo_size(&ost->fifo);
1292                             ret = 0;
1293                             /* encode any samples remaining in fifo */
1294                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1295                                 int fs_tmp = enc->frame_size;
1296                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1297                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1298                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1299                                 }
1300                                 enc->frame_size = fs_tmp;
1301                             }
1302                             if(ret <= 0) {
1303                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1304                             }
1305                             audio_size += ret;
1306                             pkt.flags |= PKT_FLAG_KEY;
1307                             break;
1308                         case CODEC_TYPE_VIDEO:
1309                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1310                             video_size += ret;
1311                             if(enc->coded_frame && enc->coded_frame->key_frame)
1312                                 pkt.flags |= PKT_FLAG_KEY;
1313                             if (ost->logfile && enc->stats_out) {
1314                                 fprintf(ost->logfile, "%s", enc->stats_out);
1315                             }
1316                             break;
1317                         default:
1318                             ret=-1;
1319                         }
1320
1321                         if(ret<=0)
1322                             break;
1323                         pkt.data= bit_buffer;
1324                         pkt.size= ret;
1325                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1326                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1327                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1328                     }
1329                 }
1330             }
1331         }
1332     }
1333
1334     return 0;
1335  fail_decode:
1336     return -1;
1337 }
1338
1339
1340 /*
1341  * The following code is the main loop of the file converter
1342  */
1343 static int av_encode(AVFormatContext **output_files,
1344                      int nb_output_files,
1345                      AVFormatContext **input_files,
1346                      int nb_input_files,
1347                      AVStreamMap *stream_maps, int nb_stream_maps)
1348 {
1349     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1350     AVFormatContext *is, *os;
1351     AVCodecContext *codec, *icodec;
1352     AVOutputStream *ost, **ost_table = NULL;
1353     AVInputStream *ist, **ist_table = NULL;
1354     AVInputFile *file_table;
1355     int key;
1356
1357     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1358     if (!file_table)
1359         goto fail;
1360
1361     /* input stream init */
1362     j = 0;
1363     for(i=0;i<nb_input_files;i++) {
1364         is = input_files[i];
1365         file_table[i].ist_index = j;
1366         file_table[i].nb_streams = is->nb_streams;
1367         j += is->nb_streams;
1368     }
1369     nb_istreams = j;
1370
1371     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1372     if (!ist_table)
1373         goto fail;
1374
1375     for(i=0;i<nb_istreams;i++) {
1376         ist = av_mallocz(sizeof(AVInputStream));
1377         if (!ist)
1378             goto fail;
1379         ist_table[i] = ist;
1380     }
1381     j = 0;
1382     for(i=0;i<nb_input_files;i++) {
1383         is = input_files[i];
1384         for(k=0;k<is->nb_streams;k++) {
1385             ist = ist_table[j++];
1386             ist->st = is->streams[k];
1387             ist->file_index = i;
1388             ist->index = k;
1389             ist->discard = 1; /* the stream is discarded by default
1390                                  (changed later) */
1391
1392             if (ist->st->codec->rate_emu) {
1393                 ist->start = av_gettime();
1394                 ist->frame = 0;
1395             }
1396         }
1397     }
1398
1399     /* output stream init */
1400     nb_ostreams = 0;
1401     for(i=0;i<nb_output_files;i++) {
1402         os = output_files[i];
1403         if (!os->nb_streams) {
1404             fprintf(stderr, "Output file does not contain any stream\n");
1405             exit(1);
1406         }
1407         nb_ostreams += os->nb_streams;
1408     }
1409     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1410         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1411         exit(1);
1412     }
1413
1414     /* Sanity check the mapping args -- do the input files & streams exist? */
1415     for(i=0;i<nb_stream_maps;i++) {
1416         int fi = stream_maps[i].file_index;
1417         int si = stream_maps[i].stream_index;
1418
1419         if (fi < 0 || fi > nb_input_files - 1 ||
1420             si < 0 || si > file_table[fi].nb_streams - 1) {
1421             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1422             exit(1);
1423         }
1424         fi = stream_maps[i].sync_file_index;
1425         si = stream_maps[i].sync_stream_index;
1426         if (fi < 0 || fi > nb_input_files - 1 ||
1427             si < 0 || si > file_table[fi].nb_streams - 1) {
1428             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1429             exit(1);
1430         }
1431     }
1432
1433     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1434     if (!ost_table)
1435         goto fail;
1436     for(i=0;i<nb_ostreams;i++) {
1437         ost = av_mallocz(sizeof(AVOutputStream));
1438         if (!ost)
1439             goto fail;
1440         ost_table[i] = ost;
1441     }
1442
1443     n = 0;
1444     for(k=0;k<nb_output_files;k++) {
1445         os = output_files[k];
1446         for(i=0;i<os->nb_streams;i++) {
1447             int found;
1448             ost = ost_table[n++];
1449             ost->file_index = k;
1450             ost->index = i;
1451             ost->st = os->streams[i];
1452             if (nb_stream_maps > 0) {
1453                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1454                     stream_maps[n-1].stream_index;
1455
1456                 /* Sanity check that the stream types match */
1457                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1458                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1459                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1460                         ost->file_index, ost->index);
1461                     exit(1);
1462                 }
1463
1464             } else {
1465                 /* get corresponding input stream index : we select the first one with the right type */
1466                 found = 0;
1467                 for(j=0;j<nb_istreams;j++) {
1468                     ist = ist_table[j];
1469                     if (ist->discard &&
1470                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1471                         ost->source_index = j;
1472                         found = 1;
1473                         break;
1474                     }
1475                 }
1476
1477                 if (!found) {
1478                     /* try again and reuse existing stream */
1479                     for(j=0;j<nb_istreams;j++) {
1480                         ist = ist_table[j];
1481                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1482                             ost->source_index = j;
1483                             found = 1;
1484                         }
1485                     }
1486                     if (!found) {
1487                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1488                                 ost->file_index, ost->index);
1489                         exit(1);
1490                     }
1491                 }
1492             }
1493             ist = ist_table[ost->source_index];
1494             ist->discard = 0;
1495             ost->sync_ist = (nb_stream_maps > 0) ?
1496                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1497                          stream_maps[n-1].sync_stream_index] : ist;
1498         }
1499     }
1500
1501     /* for each output stream, we compute the right encoding parameters */
1502     for(i=0;i<nb_ostreams;i++) {
1503         ost = ost_table[i];
1504         ist = ist_table[ost->source_index];
1505
1506         codec = ost->st->codec;
1507         icodec = ist->st->codec;
1508
1509         if (ost->st->stream_copy) {
1510             /* if stream_copy is selected, no need to decode or encode */
1511             codec->codec_id = icodec->codec_id;
1512             codec->codec_type = icodec->codec_type;
1513             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1514             codec->bit_rate = icodec->bit_rate;
1515             codec->extradata= icodec->extradata;
1516             codec->extradata_size= icodec->extradata_size;
1517             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1518                 codec->time_base = icodec->time_base;
1519             else
1520                 codec->time_base = ist->st->time_base;
1521             switch(codec->codec_type) {
1522             case CODEC_TYPE_AUDIO:
1523                 codec->sample_rate = icodec->sample_rate;
1524                 codec->channels = icodec->channels;
1525                 codec->frame_size = icodec->frame_size;
1526                 codec->block_align= icodec->block_align;
1527                 break;
1528             case CODEC_TYPE_VIDEO:
1529                 if(using_vhook) {
1530                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1531                     exit(1);
1532                 }
1533                 codec->pix_fmt = icodec->pix_fmt;
1534                 codec->width = icodec->width;
1535                 codec->height = icodec->height;
1536                 codec->has_b_frames = icodec->has_b_frames;
1537                 break;
1538             case CODEC_TYPE_SUBTITLE:
1539                 break;
1540             default:
1541                 abort();
1542             }
1543         } else {
1544             switch(codec->codec_type) {
1545             case CODEC_TYPE_AUDIO:
1546                 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1547                     goto fail;
1548
1549                 if (codec->channels == icodec->channels &&
1550                     codec->sample_rate == icodec->sample_rate) {
1551                     ost->audio_resample = 0;
1552                 } else {
1553                     if (codec->channels != icodec->channels &&
1554                         (icodec->codec_id == CODEC_ID_AC3 ||
1555                          icodec->codec_id == CODEC_ID_DTS)) {
1556                         /* Special case for 5:1 AC3 and DTS input */
1557                         /* and mono or stereo output      */
1558                         /* Request specific number of channels */
1559                         icodec->channels = codec->channels;
1560                         if (codec->sample_rate == icodec->sample_rate)
1561                             ost->audio_resample = 0;
1562                         else {
1563                             ost->audio_resample = 1;
1564                         }
1565                     } else {
1566                         ost->audio_resample = 1;
1567                     }
1568                 }
1569                 if(audio_sync_method>1)
1570                     ost->audio_resample = 1;
1571
1572                 if(ost->audio_resample){
1573                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1574                                                     codec->sample_rate, icodec->sample_rate);
1575                     if(!ost->resample){
1576                         printf("Can't resample.  Aborting.\n");
1577                         abort();
1578                     }
1579                 }
1580                 ist->decoding_needed = 1;
1581                 ost->encoding_needed = 1;
1582                 break;
1583             case CODEC_TYPE_VIDEO:
1584                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1585                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1586                 ost->video_resample = ((codec->width != icodec->width -
1587                                 (frame_leftBand + frame_rightBand) +
1588                                 (frame_padleft + frame_padright)) ||
1589                         (codec->height != icodec->height -
1590                                 (frame_topBand  + frame_bottomBand) +
1591                                 (frame_padtop + frame_padbottom)) ||
1592                         (codec->pix_fmt != icodec->pix_fmt));
1593                 if (ost->video_crop) {
1594                     ost->topBand = frame_topBand;
1595                     ost->leftBand = frame_leftBand;
1596                 }
1597                 if (ost->video_pad) {
1598                     ost->padtop = frame_padtop;
1599                     ost->padleft = frame_padleft;
1600                     ost->padbottom = frame_padbottom;
1601                     ost->padright = frame_padright;
1602                     if (!ost->video_resample) {
1603                         avcodec_get_frame_defaults(&ost->pict_tmp);
1604                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1605                                          codec->width, codec->height ) )
1606                             goto fail;
1607                     }
1608                 }
1609                 if (ost->video_resample) {
1610                     avcodec_get_frame_defaults(&ost->pict_tmp);
1611                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1612                                          codec->width, codec->height ) ) {
1613                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1614                         exit(1);
1615                     }
1616                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1617                     ost->img_resample_ctx = sws_getContext(
1618                             icodec->width - (frame_leftBand + frame_rightBand),
1619                             icodec->height - (frame_topBand + frame_bottomBand),
1620                             icodec->pix_fmt,
1621                             codec->width - (frame_padleft + frame_padright),
1622                             codec->height - (frame_padtop + frame_padbottom),
1623                             codec->pix_fmt,
1624                             sws_flags, NULL, NULL, NULL);
1625                     if (ost->img_resample_ctx == NULL) {
1626                         fprintf(stderr, "Cannot get resampling context\n");
1627                         exit(1);
1628                     }
1629                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1630                 }
1631                 ost->encoding_needed = 1;
1632                 ist->decoding_needed = 1;
1633                 break;
1634             case CODEC_TYPE_SUBTITLE:
1635                 ost->encoding_needed = 1;
1636                 ist->decoding_needed = 1;
1637                 break;
1638             default:
1639                 abort();
1640                 break;
1641             }
1642             /* two pass mode */
1643             if (ost->encoding_needed &&
1644                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1645                 char logfilename[1024];
1646                 FILE *f;
1647                 int size;
1648                 char *logbuffer;
1649
1650                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1651                          pass_logfilename ?
1652                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1653                 if (codec->flags & CODEC_FLAG_PASS1) {
1654                     f = fopen(logfilename, "w");
1655                     if (!f) {
1656                         perror(logfilename);
1657                         exit(1);
1658                     }
1659                     ost->logfile = f;
1660                 } else {
1661                     /* read the log file */
1662                     f = fopen(logfilename, "r");
1663                     if (!f) {
1664                         perror(logfilename);
1665                         exit(1);
1666                     }
1667                     fseek(f, 0, SEEK_END);
1668                     size = ftell(f);
1669                     fseek(f, 0, SEEK_SET);
1670                     logbuffer = av_malloc(size + 1);
1671                     if (!logbuffer) {
1672                         fprintf(stderr, "Could not allocate log buffer\n");
1673                         exit(1);
1674                     }
1675                     size = fread(logbuffer, 1, size, f);
1676                     fclose(f);
1677                     logbuffer[size] = '\0';
1678                     codec->stats_in = logbuffer;
1679                 }
1680             }
1681         }
1682         if(codec->codec_type == CODEC_TYPE_VIDEO){
1683             int size= codec->width * codec->height;
1684             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1685         }
1686     }
1687
1688     if (!bit_buffer)
1689         bit_buffer = av_malloc(bit_buffer_size);
1690     if (!bit_buffer)
1691         goto fail;
1692
1693     /* dump the file output parameters - cannot be done before in case
1694        of stream copy */
1695     for(i=0;i<nb_output_files;i++) {
1696         dump_format(output_files[i], i, output_files[i]->filename, 1);
1697     }
1698
1699     /* dump the stream mapping */
1700     if (verbose >= 0) {
1701         fprintf(stderr, "Stream mapping:\n");
1702         for(i=0;i<nb_ostreams;i++) {
1703             ost = ost_table[i];
1704             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1705                     ist_table[ost->source_index]->file_index,
1706                     ist_table[ost->source_index]->index,
1707                     ost->file_index,
1708                     ost->index);
1709             if (ost->sync_ist != ist_table[ost->source_index])
1710                 fprintf(stderr, " [sync #%d.%d]",
1711                         ost->sync_ist->file_index,
1712                         ost->sync_ist->index);
1713             fprintf(stderr, "\n");
1714         }
1715     }
1716
1717     /* open each encoder */
1718     for(i=0;i<nb_ostreams;i++) {
1719         ost = ost_table[i];
1720         if (ost->encoding_needed) {
1721             AVCodec *codec;
1722             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1723             if (!codec) {
1724                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1725                         ost->file_index, ost->index);
1726                 exit(1);
1727             }
1728             if (avcodec_open(ost->st->codec, codec) < 0) {
1729                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1730                         ost->file_index, ost->index);
1731                 exit(1);
1732             }
1733             extra_size += ost->st->codec->extradata_size;
1734         }
1735     }
1736
1737     /* open each decoder */
1738     for(i=0;i<nb_istreams;i++) {
1739         ist = ist_table[i];
1740         if (ist->decoding_needed) {
1741             AVCodec *codec;
1742             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1743             if (!codec) {
1744                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1745                         ist->st->codec->codec_id, ist->file_index, ist->index);
1746                 exit(1);
1747             }
1748             if (avcodec_open(ist->st->codec, codec) < 0) {
1749                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1750                         ist->file_index, ist->index);
1751                 exit(1);
1752             }
1753             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1754             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1755         }
1756     }
1757
1758     /* init pts */
1759     for(i=0;i<nb_istreams;i++) {
1760         ist = ist_table[i];
1761         is = input_files[ist->file_index];
1762         ist->pts = 0;
1763         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1764         if(ist->st->start_time == AV_NOPTS_VALUE)
1765             ist->next_pts=0;
1766         if(input_files_ts_offset[ist->file_index])
1767             ist->next_pts= AV_NOPTS_VALUE;
1768         ist->is_start = 1;
1769     }
1770
1771     /* set meta data information from input file if required */
1772     for (i=0;i<nb_meta_data_maps;i++) {
1773         AVFormatContext *out_file;
1774         AVFormatContext *in_file;
1775
1776         int out_file_index = meta_data_maps[i].out_file;
1777         int in_file_index = meta_data_maps[i].in_file;
1778         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1779             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1780             ret = AVERROR(EINVAL);
1781             goto fail;
1782         }
1783         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1784             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1785             ret = AVERROR(EINVAL);
1786             goto fail;
1787         }
1788
1789         out_file = output_files[out_file_index];
1790         in_file = input_files[in_file_index];
1791
1792         strcpy(out_file->title, in_file->title);
1793         strcpy(out_file->author, in_file->author);
1794         strcpy(out_file->copyright, in_file->copyright);
1795         strcpy(out_file->comment, in_file->comment);
1796         strcpy(out_file->album, in_file->album);
1797         out_file->year = in_file->year;
1798         out_file->track = in_file->track;
1799         strcpy(out_file->genre, in_file->genre);
1800     }
1801
1802     /* open files and write file headers */
1803     for(i=0;i<nb_output_files;i++) {
1804         os = output_files[i];
1805         if (av_write_header(os) < 0) {
1806             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1807             ret = AVERROR(EINVAL);
1808             goto fail;
1809         }
1810     }
1811
1812     if ( !using_stdin && verbose >= 0) {
1813         fprintf(stderr, "Press [q] to stop encoding\n");
1814         url_set_interrupt_cb(decode_interrupt_cb);
1815     }
1816     term_init();
1817
1818     key = -1;
1819     timer_start = av_gettime();
1820
1821     for(; received_sigterm == 0;) {
1822         int file_index, ist_index;
1823         AVPacket pkt;
1824         double ipts_min;
1825         double opts_min;
1826
1827     redo:
1828         ipts_min= 1e100;
1829         opts_min= 1e100;
1830         /* if 'q' pressed, exits */
1831         if (!using_stdin) {
1832             if (q_pressed)
1833                 break;
1834             /* read_key() returns 0 on EOF */
1835             key = read_key();
1836             if (key == 'q')
1837                 break;
1838         }
1839
1840         /* select the stream that we must read now by looking at the
1841            smallest output pts */
1842         file_index = -1;
1843         for(i=0;i<nb_ostreams;i++) {
1844             double ipts, opts;
1845             ost = ost_table[i];
1846             os = output_files[ost->file_index];
1847             ist = ist_table[ost->source_index];
1848             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1849                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1850             else
1851                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1852             ipts = (double)ist->pts;
1853             if (!file_table[ist->file_index].eof_reached){
1854                 if(ipts < ipts_min) {
1855                     ipts_min = ipts;
1856                     if(input_sync ) file_index = ist->file_index;
1857                 }
1858                 if(opts < opts_min) {
1859                     opts_min = opts;
1860                     if(!input_sync) file_index = ist->file_index;
1861                 }
1862             }
1863             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1864                 file_index= -1;
1865                 break;
1866             }
1867         }
1868         /* if none, if is finished */
1869         if (file_index < 0) {
1870             break;
1871         }
1872
1873         /* finish if recording time exhausted */
1874         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1875             break;
1876
1877         /* finish if limit size exhausted */
1878         if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1879             break;
1880
1881         /* read a frame from it and output it in the fifo */
1882         is = input_files[file_index];
1883         if (av_read_frame(is, &pkt) < 0) {
1884             file_table[file_index].eof_reached = 1;
1885             if (opt_shortest)
1886                 break;
1887             else
1888                 continue;
1889         }
1890
1891         if (do_pkt_dump) {
1892             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1893         }
1894         /* the following test is needed in case new streams appear
1895            dynamically in stream : we ignore them */
1896         if (pkt.stream_index >= file_table[file_index].nb_streams)
1897             goto discard_packet;
1898         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1899         ist = ist_table[ist_index];
1900         if (ist->discard)
1901             goto discard_packet;
1902
1903 //        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);
1904         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1905             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1906             if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1907                 input_files_ts_offset[ist->file_index]-= delta;
1908                 if (verbose > 2)
1909                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1910                 for(i=0; i<file_table[file_index].nb_streams; i++){
1911                     int index= file_table[file_index].ist_index + i;
1912                     ist_table[index]->next_pts += delta;
1913                     ist_table[index]->is_start=1;
1914                 }
1915             }
1916         }
1917
1918         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1919         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1920
1921             if (verbose >= 0)
1922                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1923                         ist->file_index, ist->index);
1924
1925             av_free_packet(&pkt);
1926             goto redo;
1927         }
1928
1929     discard_packet:
1930         av_free_packet(&pkt);
1931
1932         /* dump report by using the output first video and audio streams */
1933         print_report(output_files, ost_table, nb_ostreams, 0);
1934     }
1935
1936     /* at the end of stream, we must flush the decoder buffers */
1937     for(i=0;i<nb_istreams;i++) {
1938         ist = ist_table[i];
1939         if (ist->decoding_needed) {
1940             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1941         }
1942     }
1943
1944     term_exit();
1945
1946     /* write the trailer if needed and close file */
1947     for(i=0;i<nb_output_files;i++) {
1948         os = output_files[i];
1949         av_write_trailer(os);
1950     }
1951
1952     /* dump report by using the first video and audio streams */
1953     print_report(output_files, ost_table, nb_ostreams, 1);
1954
1955     /* close each encoder */
1956     for(i=0;i<nb_ostreams;i++) {
1957         ost = ost_table[i];
1958         if (ost->encoding_needed) {
1959             av_freep(&ost->st->codec->stats_in);
1960             avcodec_close(ost->st->codec);
1961         }
1962     }
1963
1964     /* close each decoder */
1965     for(i=0;i<nb_istreams;i++) {
1966         ist = ist_table[i];
1967         if (ist->decoding_needed) {
1968             avcodec_close(ist->st->codec);
1969         }
1970     }
1971
1972     /* finished ! */
1973
1974     ret = 0;
1975  fail1:
1976     av_freep(&bit_buffer);
1977     av_free(file_table);
1978
1979     if (ist_table) {
1980         for(i=0;i<nb_istreams;i++) {
1981             ist = ist_table[i];
1982             av_free(ist);
1983         }
1984         av_free(ist_table);
1985     }
1986     if (ost_table) {
1987         for(i=0;i<nb_ostreams;i++) {
1988             ost = ost_table[i];
1989             if (ost) {
1990                 if (ost->logfile) {
1991                     fclose(ost->logfile);
1992                     ost->logfile = NULL;
1993                 }
1994                 av_fifo_free(&ost->fifo); /* works even if fifo is not
1995                                              initialized but set to zero */
1996                 av_free(ost->pict_tmp.data[0]);
1997                 if (ost->video_resample)
1998                     sws_freeContext(ost->img_resample_ctx);
1999                 if (ost->audio_resample)
2000                     audio_resample_close(ost->resample);
2001                 av_free(ost);
2002             }
2003         }
2004         av_free(ost_table);
2005     }
2006     return ret;
2007  fail:
2008     ret = AVERROR(ENOMEM);
2009     goto fail1;
2010 }
2011
2012 #if 0
2013 int file_read(const char *filename)
2014 {
2015     URLContext *h;
2016     unsigned char buffer[1024];
2017     int len, i;
2018
2019     if (url_open(&h, filename, O_RDONLY) < 0) {
2020         printf("could not open '%s'\n", filename);
2021         return -1;
2022     }
2023     for(;;) {
2024         len = url_read(h, buffer, sizeof(buffer));
2025         if (len <= 0)
2026             break;
2027         for(i=0;i<len;i++) putchar(buffer[i]);
2028     }
2029     url_close(h);
2030     return 0;
2031 }
2032 #endif
2033
2034 static void opt_format(const char *arg)
2035 {
2036     /* compatibility stuff for pgmyuv */
2037     if (!strcmp(arg, "pgmyuv")) {
2038         pgmyuv_compatibility_hack=1;
2039 //        opt_image_format(arg);
2040         arg = "image2";
2041         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2042     }
2043
2044     file_iformat = av_find_input_format(arg);
2045     file_oformat = guess_format(arg, NULL, NULL);
2046     if (!file_iformat && !file_oformat) {
2047         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2048         exit(1);
2049     }
2050 }
2051
2052 static void opt_video_rc_eq(char *arg)
2053 {
2054     video_rc_eq = arg;
2055 }
2056
2057 static void opt_video_rc_override_string(char *arg)
2058 {
2059     video_rc_override_string = arg;
2060 }
2061
2062 static void opt_me_threshold(const char *arg)
2063 {
2064     me_threshold = atoi(arg);
2065 }
2066
2067 static void opt_verbose(const char *arg)
2068 {
2069     verbose = atoi(arg);
2070     av_log_level = atoi(arg);
2071 }
2072
2073 static void opt_frame_rate(const char *arg)
2074 {
2075     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2076         fprintf(stderr, "Incorrect frame rate\n");
2077         exit(1);
2078     }
2079 }
2080
2081 static void opt_frame_crop_top(const char *arg)
2082 {
2083     frame_topBand = atoi(arg);
2084     if (frame_topBand < 0) {
2085         fprintf(stderr, "Incorrect top crop size\n");
2086         exit(1);
2087     }
2088     if ((frame_topBand % 2) != 0) {
2089         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2090         exit(1);
2091     }
2092     if ((frame_topBand) >= frame_height){
2093         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2094         exit(1);
2095     }
2096     frame_height -= frame_topBand;
2097 }
2098
2099 static void opt_frame_crop_bottom(const char *arg)
2100 {
2101     frame_bottomBand = atoi(arg);
2102     if (frame_bottomBand < 0) {
2103         fprintf(stderr, "Incorrect bottom crop size\n");
2104         exit(1);
2105     }
2106     if ((frame_bottomBand % 2) != 0) {
2107         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2108         exit(1);
2109     }
2110     if ((frame_bottomBand) >= frame_height){
2111         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2112         exit(1);
2113     }
2114     frame_height -= frame_bottomBand;
2115 }
2116
2117 static void opt_frame_crop_left(const char *arg)
2118 {
2119     frame_leftBand = atoi(arg);
2120     if (frame_leftBand < 0) {
2121         fprintf(stderr, "Incorrect left crop size\n");
2122         exit(1);
2123     }
2124     if ((frame_leftBand % 2) != 0) {
2125         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2126         exit(1);
2127     }
2128     if ((frame_leftBand) >= frame_width){
2129         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2130         exit(1);
2131     }
2132     frame_width -= frame_leftBand;
2133 }
2134
2135 static void opt_frame_crop_right(const char *arg)
2136 {
2137     frame_rightBand = atoi(arg);
2138     if (frame_rightBand < 0) {
2139         fprintf(stderr, "Incorrect right crop size\n");
2140         exit(1);
2141     }
2142     if ((frame_rightBand % 2) != 0) {
2143         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2144         exit(1);
2145     }
2146     if ((frame_rightBand) >= frame_width){
2147         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2148         exit(1);
2149     }
2150     frame_width -= frame_rightBand;
2151 }
2152
2153 static void opt_frame_size(const char *arg)
2154 {
2155     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2156         fprintf(stderr, "Incorrect frame size\n");
2157         exit(1);
2158     }
2159     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2160         fprintf(stderr, "Frame size must be a multiple of 2\n");
2161         exit(1);
2162     }
2163 }
2164
2165
2166 #define SCALEBITS 10
2167 #define ONE_HALF  (1 << (SCALEBITS - 1))
2168 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2169
2170 #define RGB_TO_Y(r, g, b) \
2171 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2172   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2173
2174 #define RGB_TO_U(r1, g1, b1, shift)\
2175 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2176      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2177
2178 #define RGB_TO_V(r1, g1, b1, shift)\
2179 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2180    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2181
2182 static void opt_pad_color(const char *arg) {
2183     /* Input is expected to be six hex digits similar to
2184        how colors are expressed in html tags (but without the #) */
2185     int rgb = strtol(arg, NULL, 16);
2186     int r,g,b;
2187
2188     r = (rgb >> 16);
2189     g = ((rgb >> 8) & 255);
2190     b = (rgb & 255);
2191
2192     padcolor[0] = RGB_TO_Y(r,g,b);
2193     padcolor[1] = RGB_TO_U(r,g,b,0);
2194     padcolor[2] = RGB_TO_V(r,g,b,0);
2195 }
2196
2197 static void opt_frame_pad_top(const char *arg)
2198 {
2199     frame_padtop = atoi(arg);
2200     if (frame_padtop < 0) {
2201         fprintf(stderr, "Incorrect top pad size\n");
2202         exit(1);
2203     }
2204     if ((frame_padtop % 2) != 0) {
2205         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2206         exit(1);
2207     }
2208 }
2209
2210 static void opt_frame_pad_bottom(const char *arg)
2211 {
2212     frame_padbottom = atoi(arg);
2213     if (frame_padbottom < 0) {
2214         fprintf(stderr, "Incorrect bottom pad size\n");
2215         exit(1);
2216     }
2217     if ((frame_padbottom % 2) != 0) {
2218         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2219         exit(1);
2220     }
2221 }
2222
2223
2224 static void opt_frame_pad_left(const char *arg)
2225 {
2226     frame_padleft = atoi(arg);
2227     if (frame_padleft < 0) {
2228         fprintf(stderr, "Incorrect left pad size\n");
2229         exit(1);
2230     }
2231     if ((frame_padleft % 2) != 0) {
2232         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2233         exit(1);
2234     }
2235 }
2236
2237
2238 static void opt_frame_pad_right(const char *arg)
2239 {
2240     frame_padright = atoi(arg);
2241     if (frame_padright < 0) {
2242         fprintf(stderr, "Incorrect right pad size\n");
2243         exit(1);
2244     }
2245     if ((frame_padright % 2) != 0) {
2246         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2247         exit(1);
2248     }
2249 }
2250
2251 void list_pix_fmts(void)
2252 {
2253     int i;
2254     char pix_fmt_str[128];
2255     for (i=-1; i < PIX_FMT_NB; i++) {
2256         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2257         fprintf(stdout, "%s\n", pix_fmt_str);
2258     }
2259 }
2260
2261 static void opt_frame_pix_fmt(const char *arg)
2262 {
2263     if (strcmp(arg, "list"))
2264         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2265     else {
2266         list_pix_fmts();
2267         exit(0);
2268     }
2269 }
2270
2271 static void opt_frame_aspect_ratio(const char *arg)
2272 {
2273     int x = 0, y = 0;
2274     double ar = 0;
2275     const char *p;
2276
2277     p = strchr(arg, ':');
2278     if (p) {
2279         x = strtol(arg, (char **)&arg, 10);
2280         if (arg == p)
2281             y = strtol(arg+1, (char **)&arg, 10);
2282         if (x > 0 && y > 0)
2283             ar = (double)x / (double)y;
2284     } else
2285         ar = strtod(arg, (char **)&arg);
2286
2287     if (!ar) {
2288         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2289         exit(1);
2290     }
2291     frame_aspect_ratio = ar;
2292 }
2293
2294 static void opt_qscale(const char *arg)
2295 {
2296     video_qscale = atof(arg);
2297     if (video_qscale <= 0 ||
2298         video_qscale > 255) {
2299         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2300         exit(1);
2301     }
2302 }
2303
2304 static void opt_qdiff(const char *arg)
2305 {
2306     video_qdiff = atoi(arg);
2307     if (video_qdiff < 0 ||
2308         video_qdiff > 31) {
2309         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2310         exit(1);
2311     }
2312 }
2313
2314 static void opt_strict(const char *arg)
2315 {
2316     strict= atoi(arg);
2317 }
2318
2319 static void opt_top_field_first(const char *arg)
2320 {
2321     top_field_first= atoi(arg);
2322 }
2323
2324 static void opt_thread_count(const char *arg)
2325 {
2326     thread_count= atoi(arg);
2327 #if !defined(HAVE_THREADS)
2328     if (verbose >= 0)
2329         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2330 #endif
2331 }
2332
2333 static void opt_audio_rate(const char *arg)
2334 {
2335     audio_sample_rate = atoi(arg);
2336 }
2337
2338 static void opt_audio_channels(const char *arg)
2339 {
2340     audio_channels = atoi(arg);
2341 }
2342
2343 static void opt_video_channel(const char *arg)
2344 {
2345     video_channel = strtol(arg, NULL, 0);
2346 }
2347
2348 static void opt_video_standard(const char *arg)
2349 {
2350     video_standard = av_strdup(arg);
2351 }
2352
2353 static void opt_codec(int *pstream_copy, int *pcodec_id,
2354                       int codec_type, const char *arg)
2355 {
2356     AVCodec *p;
2357
2358     if (!strcmp(arg, "copy")) {
2359         *pstream_copy = 1;
2360     } else {
2361         p = first_avcodec;
2362         while (p) {
2363             if (!strcmp(p->name, arg) && p->type == codec_type)
2364                 break;
2365             p = p->next;
2366         }
2367         if (p == NULL) {
2368             fprintf(stderr, "Unknown codec '%s'\n", arg);
2369             exit(1);
2370         } else {
2371             *pcodec_id = p->id;
2372         }
2373     }
2374 }
2375
2376 static void opt_audio_codec(const char *arg)
2377 {
2378     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2379 }
2380
2381 static void opt_audio_tag(const char *arg)
2382 {
2383     char *tail;
2384     audio_codec_tag= strtol(arg, &tail, 0);
2385
2386     if(!tail || *tail)
2387         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2388 }
2389
2390 static void opt_video_tag(const char *arg)
2391 {
2392     char *tail;
2393     video_codec_tag= strtol(arg, &tail, 0);
2394
2395     if(!tail || *tail)
2396         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2397 }
2398
2399 #ifdef CONFIG_VHOOK
2400 static void add_frame_hooker(const char *arg)
2401 {
2402     int argc = 0;
2403     char *argv[64];
2404     int i;
2405     char *args = av_strdup(arg);
2406
2407     using_vhook = 1;
2408
2409     argv[0] = strtok(args, " ");
2410     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2411     }
2412
2413     i = frame_hook_add(argc, argv);
2414
2415     if (i != 0) {
2416         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2417         exit(1);
2418     }
2419 }
2420 #endif
2421
2422 static void opt_video_codec(const char *arg)
2423 {
2424     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2425 }
2426
2427 static void opt_subtitle_codec(const char *arg)
2428 {
2429     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2430 }
2431
2432 static void opt_map(const char *arg)
2433 {
2434     AVStreamMap *m;
2435     const char *p;
2436
2437     p = arg;
2438     m = &stream_maps[nb_stream_maps++];
2439
2440     m->file_index = strtol(arg, (char **)&p, 0);
2441     if (*p)
2442         p++;
2443
2444     m->stream_index = strtol(p, (char **)&p, 0);
2445     if (*p) {
2446         p++;
2447         m->sync_file_index = strtol(p, (char **)&p, 0);
2448         if (*p)
2449             p++;
2450         m->sync_stream_index = strtol(p, (char **)&p, 0);
2451     } else {
2452         m->sync_file_index = m->file_index;
2453         m->sync_stream_index = m->stream_index;
2454     }
2455 }
2456
2457 static void opt_map_meta_data(const char *arg)
2458 {
2459     AVMetaDataMap *m;
2460     const char *p;
2461
2462     p = arg;
2463     m = &meta_data_maps[nb_meta_data_maps++];
2464
2465     m->out_file = strtol(arg, (char **)&p, 0);
2466     if (*p)
2467         p++;
2468
2469     m->in_file = strtol(p, (char **)&p, 0);
2470 }
2471
2472 static void opt_recording_time(const char *arg)
2473 {
2474     recording_time = parse_date(arg, 1);
2475 }
2476
2477 static void opt_start_time(const char *arg)
2478 {
2479     start_time = parse_date(arg, 1);
2480 }
2481
2482 static void opt_rec_timestamp(const char *arg)
2483 {
2484     rec_timestamp = parse_date(arg, 0) / 1000000;
2485 }
2486
2487 static void opt_input_ts_offset(const char *arg)
2488 {
2489     input_ts_offset = parse_date(arg, 1);
2490 }
2491
2492 static void opt_input_file(const char *filename)
2493 {
2494     AVFormatContext *ic;
2495     AVFormatParameters params, *ap = &params;
2496     int err, i, ret, rfps, rfps_base;
2497     int64_t timestamp;
2498
2499     if (!strcmp(filename, "-"))
2500         filename = "pipe:";
2501
2502     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2503                    !strcmp( filename, "/dev/stdin" );
2504
2505     /* get default parameters from command line */
2506     ic = av_alloc_format_context();
2507
2508     memset(ap, 0, sizeof(*ap));
2509     ap->prealloced_context = 1;
2510     ap->sample_rate = audio_sample_rate;
2511     ap->channels = audio_channels;
2512     ap->time_base.den = frame_rate.num;
2513     ap->time_base.num = frame_rate.den;
2514     ap->width = frame_width + frame_padleft + frame_padright;
2515     ap->height = frame_height + frame_padtop + frame_padbottom;
2516     ap->pix_fmt = frame_pix_fmt;
2517     ap->channel = video_channel;
2518     ap->standard = video_standard;
2519     ap->video_codec_id = video_codec_id;
2520     ap->audio_codec_id = audio_codec_id;
2521     if(pgmyuv_compatibility_hack)
2522         ap->video_codec_id= CODEC_ID_PGMYUV;
2523
2524     for(i=0; i<opt_name_count; i++){
2525         const AVOption *opt;
2526         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2527         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2528             av_set_double(ic, opt_names[i], d);
2529     }
2530     /* open the input file with generic libav function */
2531     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2532     if (err < 0) {
2533         print_error(filename, err);
2534         exit(1);
2535     }
2536
2537     ic->loop_input = loop_input;
2538
2539     /* If not enough info to get the stream parameters, we decode the
2540        first frames to get it. (used in mpeg case for example) */
2541     ret = av_find_stream_info(ic);
2542     if (ret < 0 && verbose >= 0) {
2543         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2544         exit(1);
2545     }
2546
2547     timestamp = start_time;
2548     /* add the stream start time */
2549     if (ic->start_time != AV_NOPTS_VALUE)
2550         timestamp += ic->start_time;
2551
2552     /* if seeking requested, we execute it */
2553     if (start_time != 0) {
2554         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2555         if (ret < 0) {
2556             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2557                     filename, (double)timestamp / AV_TIME_BASE);
2558         }
2559         /* reset seek info */
2560         start_time = 0;
2561     }
2562
2563     /* update the current parameters so that they match the one of the input stream */
2564     for(i=0;i<ic->nb_streams;i++) {
2565         int j;
2566         AVCodecContext *enc = ic->streams[i]->codec;
2567         if(thread_count>1)
2568             avcodec_thread_init(enc, thread_count);
2569         enc->thread_count= thread_count;
2570         switch(enc->codec_type) {
2571         case CODEC_TYPE_AUDIO:
2572             for(j=0; j<opt_name_count; j++){
2573                 const AVOption *opt;
2574                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2575                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2576                     av_set_double(enc, opt_names[j], d);
2577             }
2578             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2579             audio_channels = enc->channels;
2580             audio_sample_rate = enc->sample_rate;
2581             if(audio_disable)
2582                 ic->streams[i]->discard= AVDISCARD_ALL;
2583             break;
2584         case CODEC_TYPE_VIDEO:
2585             for(j=0; j<opt_name_count; j++){
2586                 const AVOption *opt;
2587                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2588                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2589                     av_set_double(enc, opt_names[j], d);
2590             }
2591             frame_height = enc->height;
2592             frame_width = enc->width;
2593             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2594             frame_pix_fmt = enc->pix_fmt;
2595             rfps      = ic->streams[i]->r_frame_rate.num;
2596             rfps_base = ic->streams[i]->r_frame_rate.den;
2597             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2598             if(me_threshold)
2599                 enc->debug |= FF_DEBUG_MV;
2600
2601             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2602
2603                 if (verbose >= 0)
2604                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2605                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2606
2607                     (float)rfps / rfps_base, rfps, rfps_base);
2608             }
2609             /* update the current frame rate to match the stream frame rate */
2610             frame_rate.num = rfps;
2611             frame_rate.den = rfps_base;
2612
2613             enc->rate_emu = rate_emu;
2614             if(video_disable)
2615                 ic->streams[i]->discard= AVDISCARD_ALL;
2616             else if(video_discard)
2617                 ic->streams[i]->discard= video_discard;
2618             break;
2619         case CODEC_TYPE_DATA:
2620             break;
2621         case CODEC_TYPE_SUBTITLE:
2622             break;
2623         case CODEC_TYPE_UNKNOWN:
2624             break;
2625         default:
2626             abort();
2627         }
2628     }
2629
2630     input_files[nb_input_files] = ic;
2631     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2632     /* dump the file content */
2633     if (verbose >= 0)
2634         dump_format(ic, nb_input_files, filename, 0);
2635
2636     nb_input_files++;
2637     file_iformat = NULL;
2638     file_oformat = NULL;
2639
2640     video_channel = 0;
2641
2642     rate_emu = 0;
2643 }
2644
2645 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2646 {
2647     int has_video, has_audio, i, j;
2648     AVFormatContext *ic;
2649
2650     has_video = 0;
2651     has_audio = 0;
2652     for(j=0;j<nb_input_files;j++) {
2653         ic = input_files[j];
2654         for(i=0;i<ic->nb_streams;i++) {
2655             AVCodecContext *enc = ic->streams[i]->codec;
2656             switch(enc->codec_type) {
2657             case CODEC_TYPE_AUDIO:
2658                 has_audio = 1;
2659                 break;
2660             case CODEC_TYPE_VIDEO:
2661                 has_video = 1;
2662                 break;
2663             case CODEC_TYPE_DATA:
2664             case CODEC_TYPE_UNKNOWN:
2665             case CODEC_TYPE_SUBTITLE:
2666                 break;
2667             default:
2668                 abort();
2669             }
2670         }
2671     }
2672     *has_video_ptr = has_video;
2673     *has_audio_ptr = has_audio;
2674 }
2675
2676 static void new_video_stream(AVFormatContext *oc)
2677 {
2678     AVStream *st;
2679     AVCodecContext *video_enc;
2680     int codec_id;
2681
2682     st = av_new_stream(oc, oc->nb_streams);
2683     if (!st) {
2684         fprintf(stderr, "Could not alloc stream\n");
2685         exit(1);
2686     }
2687     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2688     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2689     video_bitstream_filters= NULL;
2690
2691     if(thread_count>1)
2692         avcodec_thread_init(st->codec, thread_count);
2693
2694     video_enc = st->codec;
2695
2696     if(video_codec_tag)
2697         video_enc->codec_tag= video_codec_tag;
2698
2699     if(   (video_global_header&1)
2700        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2701         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2702         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2703     }
2704     if(video_global_header&2){
2705         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2706         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2707     }
2708
2709     if (video_stream_copy) {
2710         st->stream_copy = 1;
2711         video_enc->codec_type = CODEC_TYPE_VIDEO;
2712     } else {
2713         char *p;
2714         int i;
2715         AVCodec *codec;
2716
2717         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2718         if (video_codec_id != CODEC_ID_NONE)
2719             codec_id = video_codec_id;
2720
2721         video_enc->codec_id = codec_id;
2722         codec = avcodec_find_encoder(codec_id);
2723
2724         for(i=0; i<opt_name_count; i++){
2725              const AVOption *opt;
2726              double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2727              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2728                  av_set_double(video_enc, opt_names[i], d);
2729         }
2730
2731         video_enc->time_base.den = frame_rate.num;
2732         video_enc->time_base.num = frame_rate.den;
2733         if(codec && codec->supported_framerates){
2734             const AVRational *p= codec->supported_framerates;
2735             AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2736             const AVRational *best=NULL;
2737             AVRational best_error= (AVRational){INT_MAX, 1};
2738             for(; p->den!=0; p++){
2739                 AVRational error= av_sub_q(req, *p);
2740                 if(error.num <0) error.num *= -1;
2741                 if(av_cmp_q(error, best_error) < 0){
2742                     best_error= error;
2743                     best= p;
2744                 }
2745             }
2746             video_enc->time_base.den= best->num;
2747             video_enc->time_base.num= best->den;
2748         }
2749
2750         video_enc->width = frame_width + frame_padright + frame_padleft;
2751         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2752         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2753         video_enc->pix_fmt = frame_pix_fmt;
2754
2755         if(codec && codec->pix_fmts){
2756             const enum PixelFormat *p= codec->pix_fmts;
2757             for(; *p!=-1; p++){
2758                 if(*p == video_enc->pix_fmt)
2759                     break;
2760             }
2761             if(*p == -1)
2762                 video_enc->pix_fmt = codec->pix_fmts[0];
2763         }
2764
2765         if (intra_only)
2766             video_enc->gop_size = 0;
2767         if (video_qscale || same_quality) {
2768             video_enc->flags |= CODEC_FLAG_QSCALE;
2769             video_enc->global_quality=
2770                 st->quality = FF_QP2LAMBDA * video_qscale;
2771         }
2772
2773         if(intra_matrix)
2774             video_enc->intra_matrix = intra_matrix;
2775         if(inter_matrix)
2776             video_enc->inter_matrix = inter_matrix;
2777
2778         video_enc->max_qdiff = video_qdiff;
2779         video_enc->rc_eq = video_rc_eq;
2780         video_enc->thread_count = thread_count;
2781         p= video_rc_override_string;
2782         for(i=0; p; i++){
2783             int start, end, q;
2784             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2785             if(e!=3){
2786                 fprintf(stderr, "error parsing rc_override\n");
2787                 exit(1);
2788             }
2789             video_enc->rc_override=
2790                 av_realloc(video_enc->rc_override,
2791                            sizeof(RcOverride)*(i+1));
2792             video_enc->rc_override[i].start_frame= start;
2793             video_enc->rc_override[i].end_frame  = end;
2794             if(q>0){
2795                 video_enc->rc_override[i].qscale= q;
2796                 video_enc->rc_override[i].quality_factor= 1.0;
2797             }
2798             else{
2799                 video_enc->rc_override[i].qscale= 0;
2800                 video_enc->rc_override[i].quality_factor= -q/100.0;
2801             }
2802             p= strchr(p, '/');
2803             if(p) p++;
2804         }
2805         video_enc->rc_override_count=i;
2806         if (!video_enc->rc_initial_buffer_occupancy)
2807             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2808         video_enc->me_threshold= me_threshold;
2809         video_enc->intra_dc_precision= intra_dc_precision - 8;
2810         video_enc->strict_std_compliance = strict;
2811
2812         if (do_psnr)
2813             video_enc->flags|= CODEC_FLAG_PSNR;
2814
2815         /* two pass mode */
2816         if (do_pass) {
2817             if (do_pass == 1) {
2818                 video_enc->flags |= CODEC_FLAG_PASS1;
2819             } else {
2820                 video_enc->flags |= CODEC_FLAG_PASS2;
2821             }
2822         }
2823     }
2824
2825     /* reset some key parameters */
2826     video_disable = 0;
2827     video_codec_id = CODEC_ID_NONE;
2828     video_stream_copy = 0;
2829 }
2830
2831 static void new_audio_stream(AVFormatContext *oc)
2832 {
2833     AVStream *st;
2834     AVCodecContext *audio_enc;
2835     int codec_id, i;
2836
2837     st = av_new_stream(oc, oc->nb_streams);
2838     if (!st) {
2839         fprintf(stderr, "Could not alloc stream\n");
2840         exit(1);
2841     }
2842     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2843
2844     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2845     audio_bitstream_filters= NULL;
2846
2847     if(thread_count>1)
2848         avcodec_thread_init(st->codec, thread_count);
2849
2850     audio_enc = st->codec;
2851     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2852     audio_enc->strict_std_compliance = strict;
2853
2854     if(audio_codec_tag)
2855         audio_enc->codec_tag= audio_codec_tag;
2856
2857     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2858         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2859         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2860     }
2861     if (audio_stream_copy) {
2862         st->stream_copy = 1;
2863         audio_enc->channels = audio_channels;
2864     } else {
2865         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2866
2867         for(i=0; i<opt_name_count; i++){
2868             const AVOption *opt;
2869             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2870             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2871                 av_set_double(audio_enc, opt_names[i], d);
2872         }
2873
2874         if (audio_codec_id != CODEC_ID_NONE)
2875             codec_id = audio_codec_id;
2876         audio_enc->codec_id = codec_id;
2877
2878         if (audio_qscale > QSCALE_NONE) {
2879             audio_enc->flags |= CODEC_FLAG_QSCALE;
2880             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2881         }
2882         audio_enc->thread_count = thread_count;
2883         audio_enc->channels = audio_channels;
2884     }
2885     audio_enc->sample_rate = audio_sample_rate;
2886     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2887     if (audio_language) {
2888         av_strlcpy(st->language, audio_language, sizeof(st->language));
2889         av_free(audio_language);
2890         audio_language = NULL;
2891     }
2892
2893     /* reset some key parameters */
2894     audio_disable = 0;
2895     audio_codec_id = CODEC_ID_NONE;
2896     audio_stream_copy = 0;
2897 }
2898
2899 static void opt_new_subtitle_stream(void)
2900 {
2901     AVFormatContext *oc;
2902     AVStream *st;
2903     AVCodecContext *subtitle_enc;
2904     int i;
2905
2906     if (nb_output_files <= 0) {
2907         fprintf(stderr, "At least one output file must be specified\n");
2908         exit(1);
2909     }
2910     oc = output_files[nb_output_files - 1];
2911
2912     st = av_new_stream(oc, oc->nb_streams);
2913     if (!st) {
2914         fprintf(stderr, "Could not alloc stream\n");
2915         exit(1);
2916     }
2917     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2918
2919     subtitle_enc = st->codec;
2920     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2921     if (subtitle_stream_copy) {
2922         st->stream_copy = 1;
2923     } else {
2924         for(i=0; i<opt_name_count; i++){
2925              const AVOption *opt;
2926              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2927              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2928                  av_set_double(subtitle_enc, opt_names[i], d);
2929         }
2930         subtitle_enc->codec_id = subtitle_codec_id;
2931     }
2932
2933     if (subtitle_language) {
2934         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2935         av_free(subtitle_language);
2936         subtitle_language = NULL;
2937     }
2938
2939     subtitle_codec_id = CODEC_ID_NONE;
2940     subtitle_stream_copy = 0;
2941 }
2942
2943 static void opt_new_audio_stream(void)
2944 {
2945     AVFormatContext *oc;
2946     if (nb_output_files <= 0) {
2947         fprintf(stderr, "At least one output file must be specified\n");
2948         exit(1);
2949     }
2950     oc = output_files[nb_output_files - 1];
2951     new_audio_stream(oc);
2952 }
2953
2954 static void opt_new_video_stream(void)
2955 {
2956     AVFormatContext *oc;
2957     if (nb_output_files <= 0) {
2958         fprintf(stderr, "At least one output file must be specified\n");
2959         exit(1);
2960     }
2961     oc = output_files[nb_output_files - 1];
2962     new_video_stream(oc);
2963 }
2964
2965 static void opt_output_file(const char *filename)
2966 {
2967     AVFormatContext *oc;
2968     int use_video, use_audio, input_has_video, input_has_audio, i;
2969     AVFormatParameters params, *ap = &params;
2970
2971     if (!strcmp(filename, "-"))
2972         filename = "pipe:";
2973
2974     oc = av_alloc_format_context();
2975
2976     if (!file_oformat) {
2977         file_oformat = guess_format(NULL, filename, NULL);
2978         if (!file_oformat) {
2979             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
2980                     filename);
2981             exit(1);
2982         }
2983     }
2984
2985     oc->oformat = file_oformat;
2986     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
2987
2988     if (!strcmp(file_oformat->name, "ffm") &&
2989         av_strstart(filename, "http:", NULL)) {
2990         /* special case for files sent to ffserver: we get the stream
2991            parameters from ffserver */
2992         if (read_ffserver_streams(oc, filename) < 0) {
2993             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2994             exit(1);
2995         }
2996     } else {
2997         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
2998         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
2999
3000         /* disable if no corresponding type found and at least one
3001            input file */
3002         if (nb_input_files > 0) {
3003             check_audio_video_inputs(&input_has_video, &input_has_audio);
3004             if (!input_has_video)
3005                 use_video = 0;
3006             if (!input_has_audio)
3007                 use_audio = 0;
3008         }
3009
3010         /* manual disable */
3011         if (audio_disable) {
3012             use_audio = 0;
3013         }
3014         if (video_disable) {
3015             use_video = 0;
3016         }
3017
3018         if (use_video) {
3019             new_video_stream(oc);
3020         }
3021
3022         if (use_audio) {
3023             new_audio_stream(oc);
3024         }
3025
3026         oc->timestamp = rec_timestamp;
3027
3028         if (str_title)
3029             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3030         if (str_author)
3031             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3032         if (str_copyright)
3033             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3034         if (str_comment)
3035             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3036         if (str_album)
3037             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3038     }
3039
3040     output_files[nb_output_files++] = oc;
3041
3042     /* check filename in case of an image number is expected */
3043     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3044         if (!av_filename_number_test(oc->filename)) {
3045             print_error(oc->filename, AVERROR_NUMEXPECTED);
3046             exit(1);
3047         }
3048     }
3049
3050     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3051         /* test if it already exists to avoid loosing precious files */
3052         if (!file_overwrite &&
3053             (strchr(filename, ':') == NULL ||
3054              av_strstart(filename, "file:", NULL))) {
3055             if (url_exist(filename)) {
3056                 int c;
3057
3058                 if ( !using_stdin ) {
3059                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3060                     fflush(stderr);
3061                     c = getchar();
3062                     if (toupper(c) != 'Y') {
3063                         fprintf(stderr, "Not overwriting - exiting\n");
3064                         exit(1);
3065                     }
3066                                 }
3067                                 else {
3068                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3069                     exit(1);
3070                                 }
3071             }
3072         }
3073
3074         /* open the file */
3075         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3076             fprintf(stderr, "Could not open '%s'\n", filename);
3077             exit(1);
3078         }
3079     }
3080
3081     memset(ap, 0, sizeof(*ap));
3082     if (av_set_parameters(oc, ap) < 0) {
3083         fprintf(stderr, "%s: Invalid encoding parameters\n",
3084                 oc->filename);
3085         exit(1);
3086     }
3087
3088     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3089     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3090     oc->loop_output = loop_output;
3091
3092     for(i=0; i<opt_name_count; i++){
3093         const AVOption *opt;
3094         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3095         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3096             av_set_double(oc, opt_names[i], d);
3097     }
3098
3099     /* reset some options */
3100     file_oformat = NULL;
3101     file_iformat = NULL;
3102 }
3103
3104 /* same option as mencoder */
3105 static void opt_pass(const char *pass_str)
3106 {
3107     int pass;
3108     pass = atoi(pass_str);
3109     if (pass != 1 && pass != 2) {
3110         fprintf(stderr, "pass number can be only 1 or 2\n");
3111         exit(1);
3112     }
3113     do_pass = pass;
3114 }
3115
3116 static int64_t getutime(void)
3117 {
3118 #ifdef HAVE_GETRUSAGE
3119     struct rusage rusage;
3120
3121     getrusage(RUSAGE_SELF, &rusage);
3122     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3123 #elif defined(HAVE_GETPROCESSTIMES)
3124     HANDLE proc;
3125     FILETIME c, e, k, u;
3126     proc = GetCurrentProcess();
3127     GetProcessTimes(proc, &c, &e, &k, &u);
3128     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3129 #else
3130   return av_gettime();
3131 #endif
3132 }
3133
3134 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3135 extern int ffm_nopts;
3136 #endif
3137
3138 static void show_formats(void)
3139 {
3140     AVInputFormat *ifmt;
3141     AVOutputFormat *ofmt;
3142     URLProtocol *up;
3143     AVCodec *p, *p2;
3144     const char *last_name;
3145
3146     printf("File formats:\n");
3147     last_name= "000";
3148     for(;;){
3149         int decode=0;
3150         int encode=0;
3151         const char *name=NULL;
3152         const char *long_name=NULL;
3153
3154         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3155             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3156                 strcmp(ofmt->name, last_name)>0){
3157                 name= ofmt->name;
3158                 long_name= ofmt->long_name;
3159                 encode=1;
3160             }
3161         }
3162         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3163             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3164                 strcmp(ifmt->name, last_name)>0){
3165                 name= ifmt->name;
3166                 long_name= ifmt->long_name;
3167                 encode=0;
3168             }
3169             if(name && strcmp(ifmt->name, name)==0)
3170                 decode=1;
3171         }
3172         if(name==NULL)
3173             break;
3174         last_name= name;
3175
3176         printf(
3177             " %s%s %-15s %s\n",
3178             decode ? "D":" ",
3179             encode ? "E":" ",
3180             name,
3181             long_name ? long_name:" ");
3182     }
3183     printf("\n");
3184
3185     printf("Codecs:\n");
3186     last_name= "000";
3187     for(;;){
3188         int decode=0;
3189         int encode=0;
3190         int cap=0;
3191         const char *type_str;
3192
3193         p2=NULL;
3194         for(p = first_avcodec; p != NULL; p = p->next) {
3195             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3196                 strcmp(p->name, last_name)>0){
3197                 p2= p;
3198                 decode= encode= cap=0;
3199             }
3200             if(p2 && strcmp(p->name, p2->name)==0){
3201                 if(p->decode) decode=1;
3202                 if(p->encode) encode=1;
3203                 cap |= p->capabilities;
3204             }
3205         }
3206         if(p2==NULL)
3207             break;
3208         last_name= p2->name;
3209
3210         switch(p2->type) {
3211         case CODEC_TYPE_VIDEO:
3212             type_str = "V";
3213             break;
3214         case CODEC_TYPE_AUDIO:
3215             type_str = "A";
3216             break;
3217         case CODEC_TYPE_SUBTITLE:
3218             type_str = "S";
3219             break;
3220         default:
3221             type_str = "?";
3222             break;
3223         }
3224         printf(
3225             " %s%s%s%s%s%s %s",
3226             decode ? "D": (/*p2->decoder ? "d":*/" "),
3227             encode ? "E":" ",
3228             type_str,
3229             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3230             cap & CODEC_CAP_DR1 ? "D":" ",
3231             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3232             p2->name);
3233        /* if(p2->decoder && decode==0)
3234             printf(" use %s for decoding", p2->decoder->name);*/
3235         printf("\n");
3236     }
3237     printf("\n");
3238
3239     printf("Supported file protocols:\n");
3240     for(up = first_protocol; up != NULL; up = up->next)
3241         printf(" %s:", up->name);
3242     printf("\n");
3243
3244     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3245     printf("\n");
3246     printf(
3247 "Note, the names of encoders and decoders do not always match, so there are\n"
3248 "several cases where the above table shows encoder only or decoder only entries\n"
3249 "even though both encoding and decoding are supported. For example, the h263\n"
3250 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3251 "worse.\n");
3252     exit(1);
3253 }
3254
3255 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3256 {
3257     int i;
3258     const char *p = str;
3259     for(i = 0;; i++) {
3260         dest[i] = atoi(p);
3261         if(i == 63)
3262             break;
3263         p = strchr(p, ',');
3264         if(!p) {
3265             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3266             exit(1);
3267         }
3268         p++;
3269     }
3270 }
3271
3272 static void opt_inter_matrix(const char *arg)
3273 {
3274     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3275     parse_matrix_coeffs(inter_matrix, arg);
3276 }
3277
3278 static void opt_intra_matrix(const char *arg)
3279 {
3280     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3281     parse_matrix_coeffs(intra_matrix, arg);
3282 }
3283
3284 static void opt_target(const char *arg)
3285 {
3286     int norm = -1;
3287     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3288
3289     if(!strncmp(arg, "pal-", 4)) {
3290         norm = 0;
3291         arg += 4;
3292     } else if(!strncmp(arg, "ntsc-", 5)) {
3293         norm = 1;
3294         arg += 5;
3295     } else if(!strncmp(arg, "film-", 5)) {
3296         norm = 2;
3297         arg += 5;
3298     } else {
3299         int fr;
3300         /* Calculate FR via float to avoid int overflow */
3301         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3302         if(fr == 25000) {
3303             norm = 0;
3304         } else if((fr == 29970) || (fr == 23976)) {
3305             norm = 1;
3306         } else {
3307             /* Try to determine PAL/NTSC by peeking in the input files */
3308             if(nb_input_files) {
3309                 int i, j;
3310                 for(j = 0; j < nb_input_files; j++) {
3311                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3312                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3313                         if(c->codec_type != CODEC_TYPE_VIDEO)
3314                             continue;
3315                         fr = c->time_base.den * 1000 / c->time_base.num;
3316                         if(fr == 25000) {
3317                             norm = 0;
3318                             break;
3319                         } else if((fr == 29970) || (fr == 23976)) {
3320                             norm = 1;
3321                             break;
3322                         }
3323                     }
3324                     if(norm >= 0)
3325                         break;
3326                 }
3327             }
3328         }
3329         if(verbose && norm >= 0)
3330             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3331     }
3332
3333     if(norm < 0) {
3334         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3335         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3336         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3337         exit(1);
3338     }
3339
3340     if(!strcmp(arg, "vcd")) {
3341
3342         opt_video_codec("mpeg1video");
3343         opt_audio_codec("mp2");
3344         opt_format("vcd");
3345
3346         opt_frame_size(norm ? "352x240" : "352x288");
3347         opt_frame_rate(frame_rates[norm]);
3348         opt_default("gop", norm ? "18" : "15");
3349
3350         opt_default("b", "1150000");
3351         opt_default("maxrate", "1150000");
3352         opt_default("minrate", "1150000");
3353         opt_default("bufsize", "327680"); // 40*1024*8;
3354
3355         opt_default("ab", "224000");
3356         audio_sample_rate = 44100;
3357         audio_channels = 2;
3358
3359         opt_default("packetsize", "2324");
3360         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3361
3362         /* We have to offset the PTS, so that it is consistent with the SCR.
3363            SCR starts at 36000, but the first two packs contain only padding
3364            and the first pack from the other stream, respectively, may also have
3365            been written before.
3366            So the real data starts at SCR 36000+3*1200. */
3367         mux_preload= (36000+3*1200) / 90000.0; //0.44
3368     } else if(!strcmp(arg, "svcd")) {
3369
3370         opt_video_codec("mpeg2video");
3371         opt_audio_codec("mp2");
3372         opt_format("svcd");
3373
3374         opt_frame_size(norm ? "480x480" : "480x576");
3375         opt_frame_rate(frame_rates[norm]);
3376         opt_default("gop", norm ? "18" : "15");
3377
3378         opt_default("b", "2040000");
3379         opt_default("maxrate", "2516000");
3380         opt_default("minrate", "0"); //1145000;
3381         opt_default("bufsize", "1835008"); //224*1024*8;
3382         opt_default("flags", "+SCAN_OFFSET");
3383
3384
3385         opt_default("ab", "224000");
3386         audio_sample_rate = 44100;
3387
3388         opt_default("packetsize", "2324");
3389
3390     } else if(!strcmp(arg, "dvd")) {
3391
3392         opt_video_codec("mpeg2video");
3393         opt_audio_codec("ac3");
3394         opt_format("dvd");
3395
3396         opt_frame_size(norm ? "720x480" : "720x576");
3397         opt_frame_rate(frame_rates[norm]);
3398         opt_default("gop", norm ? "18" : "15");
3399
3400         opt_default("b", "6000000");
3401         opt_default("maxrate", "9000000");
3402         opt_default("minrate", "0"); //1500000;
3403         opt_default("bufsize", "1835008"); //224*1024*8;
3404
3405         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3406         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3407
3408         opt_default("ab", "448000");
3409         audio_sample_rate = 48000;
3410
3411     } else if(!strncmp(arg, "dv", 2)) {
3412
3413         opt_format("dv");
3414
3415         opt_frame_size(norm ? "720x480" : "720x576");
3416         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3417                                              (norm ? "yuv411p" : "yuv420p"));
3418         opt_frame_rate(frame_rates[norm]);
3419
3420         audio_sample_rate = 48000;
3421         audio_channels = 2;
3422
3423     } else {
3424         fprintf(stderr, "Unknown target: %s\n", arg);
3425         exit(1);
3426     }
3427 }
3428
3429 static void opt_vstats_file (const char *arg)
3430 {
3431     av_free (vstats_filename);
3432     vstats_filename=av_strdup (arg);
3433 }
3434
3435 static void opt_vstats (void)
3436 {
3437     char filename[40];
3438     time_t today2 = time(NULL);
3439     struct tm *today = localtime(&today2);
3440
3441     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3442              today->tm_sec);
3443     opt_vstats_file(filename);
3444 }
3445
3446 static void opt_video_bsf(const char *arg)
3447 {
3448     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3449     AVBitStreamFilterContext **bsfp;
3450
3451     if(!bsfc){
3452         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3453         exit(1);
3454     }
3455
3456     bsfp= &video_bitstream_filters;
3457     while(*bsfp)
3458         bsfp= &(*bsfp)->next;
3459
3460     *bsfp= bsfc;
3461 }
3462
3463 //FIXME avoid audio - video code duplication
3464 static void opt_audio_bsf(const char *arg)
3465 {
3466     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3467     AVBitStreamFilterContext **bsfp;
3468
3469     if(!bsfc){
3470         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3471         exit(1);
3472     }
3473
3474     bsfp= &audio_bitstream_filters;
3475     while(*bsfp)
3476         bsfp= &(*bsfp)->next;
3477
3478     *bsfp= bsfc;
3479 }
3480
3481 static void show_version(void)
3482 {
3483     /* TODO: add function interface to avutil and avformat */
3484     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3485            "libavutil   %d\n"
3486            "libavcodec  %d\n"
3487            "libavformat %d\n",
3488            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3489     exit(1);
3490 }
3491
3492 static int opt_default(const char *opt, const char *arg){
3493     int type;
3494     const AVOption *o= NULL;
3495     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3496
3497     for(type=0; type<CODEC_TYPE_NB; type++){
3498         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3499         if(o2)
3500             o = av_set_string(avctx_opts[type], opt, arg);
3501     }
3502     if(!o)
3503         o = av_set_string(avformat_opts, opt, arg);
3504     if(!o)
3505         o = av_set_string(sws_opts, opt, arg);
3506     if(!o){
3507         if(opt[0] == 'a')
3508             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3509         else if(opt[0] == 'v')
3510             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3511         else if(opt[0] == 's')
3512             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3513     }
3514     if(!o)
3515         return -1;
3516
3517 //    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));
3518
3519     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3520     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3521     opt_names[opt_name_count++]= o->name;
3522
3523 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3524     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3525     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3526         ffm_nopts = 1;
3527 #endif
3528
3529     if(avctx_opts[0]->debug)
3530         av_log_level = AV_LOG_DEBUG;
3531     return 0;
3532 }
3533
3534 const OptionDef options[] = {
3535     /* main options */
3536     { "L", 0, {(void*)show_license}, "show license" },
3537     { "h", 0, {(void*)show_help}, "show help" },
3538     { "version", 0, {(void*)show_version}, "show version" },
3539     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3540     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3541     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3542     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3543     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3544     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3545     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3546     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3547     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3548     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3549     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3550     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3551     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3552     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3553     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3554     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3555     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3556       "add timings for benchmarking" },
3557     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3558       "dump each input packet" },
3559     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3560       "when dumping packets, also dump the payload" },
3561     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3562     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3563     { "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)", "" },
3564     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3565     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3566     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3567     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3568     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3569     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3570     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3571     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3572     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3573
3574     /* video options */
3575     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3576     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3577     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3578     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3579     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3580     { "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" },
3581     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3582     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3583     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3584     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3585     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3586     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3587     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3588     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3589     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3590     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3591     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3592     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3593     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3594     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3595     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3596     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3597     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3598     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3599     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3600     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3601       "use same video quality as source (implies VBR)" },
3602     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3603     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3604     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3605       "deinterlace pictures" },
3606     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3607     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3608     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3609 #ifdef CONFIG_VHOOK
3610     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3611 #endif
3612     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3613     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3614     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3615     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3616     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3617     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3618     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3619
3620     /* audio options */
3621     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3622     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3623     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3624     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3625     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3626     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3627     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3628     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3629     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3630     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3631
3632     /* subtitle options */
3633     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3634     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3635     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3636
3637     /* grab options */
3638     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3639     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3640     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3641
3642     /* muxer options */
3643     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3644     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3645
3646     { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3647     { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3648
3649     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3650     { NULL, },
3651 };
3652
3653 static void show_banner(void)
3654 {
3655     fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3656     fprintf(stderr, "  configuration: " FFMPEG_CONFIGURATION "\n");
3657     fprintf(stderr, "  libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3658     fprintf(stderr, "  libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3659     fprintf(stderr, "  libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3660     fprintf(stderr, "  built on " __DATE__ " " __TIME__);
3661 #ifdef __GNUC__
3662     fprintf(stderr, ", gcc: " __VERSION__ "\n");
3663 #else
3664     fprintf(stderr, ", using a non-gcc compiler\n");
3665 #endif
3666 }
3667
3668 static void show_license(void)
3669 {
3670     show_banner();
3671 #ifdef CONFIG_GPL
3672     printf(
3673     "FFmpeg is free software; you can redistribute it and/or modify\n"
3674     "it under the terms of the GNU General Public License as published by\n"
3675     "the Free Software Foundation; either version 2 of the License, or\n"
3676     "(at your option) any later version.\n"
3677     "\n"
3678     "FFmpeg is distributed in the hope that it will be useful,\n"
3679     "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3680     "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"