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