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