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