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