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