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