only store command line parameters in contexts with matching codec_type
[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 "dsputil.h"
28 #include "opt.h"
29 #include "fifo.h"
30
31 #ifdef __MINGW32__
32 #include <conio.h>
33 #else
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <sys/ioctl.h>
37 #include <sys/time.h>
38 #include <termios.h>
39 #include <sys/resource.h>
40 #endif
41 #ifdef CONFIG_OS2
42 #include <sys/types.h>
43 #include <sys/select.h>
44 #include <stdlib.h>
45 #endif
46 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
47 #include <time.h>
48
49 #include "version.h"
50 #include "cmdutils.h"
51
52 #undef NDEBUG
53 #include <assert.h>
54
55 #if !defined(INFINITY) && defined(HUGE_VAL)
56 #define INFINITY HUGE_VAL
57 #endif
58
59 /* select an input stream for an output stream */
60 typedef struct AVStreamMap {
61     int file_index;
62     int stream_index;
63     int sync_file_index;
64     int sync_stream_index;
65 } AVStreamMap;
66
67 /** select an input file for an output file */
68 typedef struct AVMetaDataMap {
69     int out_file;
70     int in_file;
71 } AVMetaDataMap;
72
73 extern const OptionDef options[];
74
75 static void show_help(void);
76 static void show_license(void);
77 static int opt_default(const char *opt, const char *arg);
78
79 #define MAX_FILES 20
80
81 static AVFormatContext *input_files[MAX_FILES];
82 static int64_t input_files_ts_offset[MAX_FILES];
83 static int nb_input_files = 0;
84
85 static AVFormatContext *output_files[MAX_FILES];
86 static int nb_output_files = 0;
87
88 static AVStreamMap stream_maps[MAX_FILES];
89 static int nb_stream_maps;
90
91 static AVMetaDataMap meta_data_maps[MAX_FILES];
92 static int nb_meta_data_maps;
93
94 static AVInputFormat *file_iformat;
95 static AVOutputFormat *file_oformat;
96 static int frame_width  = 0;
97 static int frame_height = 0;
98 static float frame_aspect_ratio = 0;
99 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100 static int frame_padtop  = 0;
101 static int frame_padbottom = 0;
102 static int frame_padleft  = 0;
103 static int frame_padright = 0;
104 static int padcolor[3] = {16,128,128}; /* default to black */
105 static int frame_topBand  = 0;
106 static int frame_bottomBand = 0;
107 static int frame_leftBand  = 0;
108 static int frame_rightBand = 0;
109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static int frame_rate = 25;
111 static int frame_rate_base = 1;
112 static float video_qscale = 0;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
120 #endif
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int strict = 0;
131 static int top_field_first = -1;
132 static int me_threshold = 0;
133 static int intra_dc_precision = 8;
134 static int loop_input = 0;
135 static int loop_output = AVFMT_NOOUTPUTLOOP;
136 static int qp_hist = 0;
137
138 static int intra_only = 0;
139 static int audio_sample_rate = 44100;
140 #define QSCALE_NONE -99999
141 static float audio_qscale = QSCALE_NONE;
142 static int audio_disable = 0;
143 static int audio_channels = 1;
144 static int audio_codec_id = CODEC_ID_NONE;
145 static int audio_codec_tag = 0;
146 static char *audio_language = NULL;
147
148 static int subtitle_codec_id = CODEC_ID_NONE;
149 static char *subtitle_language = NULL;
150
151 static float mux_preload= 0.5;
152 static float mux_max_delay= 0.7;
153
154 static int64_t recording_time = 0;
155 static int64_t start_time = 0;
156 static int64_t rec_timestamp = 0;
157 static int64_t input_ts_offset = 0;
158 static int file_overwrite = 0;
159 static char *str_title = NULL;
160 static char *str_author = NULL;
161 static char *str_copyright = NULL;
162 static char *str_comment = NULL;
163 static char *str_album = NULL;
164 static int do_benchmark = 0;
165 static int do_hex_dump = 0;
166 static int do_pkt_dump = 0;
167 static int do_psnr = 0;
168 static int do_vstats = 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
180 static int rate_emu = 0;
181
182 static int  video_channel = 0;
183 static char *video_standard = "ntsc";
184
185 static int audio_volume = 256;
186
187 static int using_stdin = 0;
188 static int using_vhook = 0;
189 static int verbose = 1;
190 static int thread_count= 1;
191 static int q_pressed = 0;
192 static int64_t video_size = 0;
193 static int64_t audio_size = 0;
194 static int64_t extra_size = 0;
195 static int nb_frames_dup = 0;
196 static int nb_frames_drop = 0;
197 static int input_sync;
198 static int limit_filesize = 0; //
199
200 static int pgmyuv_compatibility_hack=0;
201 static int dts_delta_threshold = 10;
202
203 static int sws_flags = SWS_BICUBIC;
204
205 const char **opt_names=NULL;
206 int opt_name_count=0;
207 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
208 AVFormatContext *avformat_opts;
209
210 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
211 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
212 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
213
214 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
215
216 struct AVInputStream;
217
218 typedef struct AVOutputStream {
219     int file_index;          /* file index */
220     int index;               /* stream index in the output file */
221     int source_index;        /* AVInputStream index */
222     AVStream *st;            /* stream in the output file */
223     int encoding_needed;     /* true if encoding needed for this stream */
224     int frame_number;
225     /* input pts and corresponding output pts
226        for A/V sync */
227     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
228     struct AVInputStream *sync_ist; /* input stream to sync against */
229     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
230     /* video only */
231     int video_resample;
232     AVFrame pict_tmp;      /* temporary image for resampling */
233     struct SwsContext *img_resample_ctx; /* for image resampling */
234     int resample_height;
235
236     int video_crop;
237     int topBand;             /* cropping area sizes */
238     int leftBand;
239
240     int video_pad;
241     int padtop;              /* padding area sizes */
242     int padbottom;
243     int padleft;
244     int padright;
245
246     /* audio only */
247     int audio_resample;
248     ReSampleContext *resample; /* for audio resampling */
249     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
250     FILE *logfile;
251 } AVOutputStream;
252
253 typedef struct AVInputStream {
254     int file_index;
255     int index;
256     AVStream *st;
257     int discard;             /* true if stream data should be discarded */
258     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
259     int64_t sample_index;      /* current sample */
260
261     int64_t       start;     /* time when read started */
262     unsigned long frame;     /* current frame */
263     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
264                                 is not defined */
265     int64_t       pts;       /* current pts */
266     int is_start;            /* is 1 at the start and after a discontinuity */
267 } AVInputStream;
268
269 typedef struct AVInputFile {
270     int eof_reached;      /* true if eof reached */
271     int ist_index;        /* index of first stream in ist_table */
272     int buffer_size;      /* current total buffer size */
273     int buffer_size_max;  /* buffer size at which we consider we can stop
274                              buffering */
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
606     if (picture != picture2)
607         *picture = *picture2;
608     *bufp = buf;
609 }
610
611 /* we begin to correct av delay at this threshold */
612 #define AV_DELAY_MAX 0.100
613
614 static void do_subtitle_out(AVFormatContext *s,
615                             AVOutputStream *ost,
616                             AVInputStream *ist,
617                             AVSubtitle *sub,
618                             int64_t pts)
619 {
620     static uint8_t *subtitle_out = NULL;
621     int subtitle_out_max_size = 65536;
622     int subtitle_out_size, nb, i;
623     AVCodecContext *enc;
624     AVPacket pkt;
625
626     if (pts == AV_NOPTS_VALUE) {
627         fprintf(stderr, "Subtitle packets must have a pts\n");
628         return;
629     }
630
631     enc = ost->st->codec;
632
633     if (!subtitle_out) {
634         subtitle_out = av_malloc(subtitle_out_max_size);
635     }
636
637     /* Note: DVB subtitle need one packet to draw them and one other
638        packet to clear them */
639     /* XXX: signal it in the codec context ? */
640     if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
641         nb = 2;
642     else
643         nb = 1;
644
645     for(i = 0; i < nb; i++) {
646         subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
647                                                     subtitle_out_max_size, sub);
648
649         av_init_packet(&pkt);
650         pkt.stream_index = ost->index;
651         pkt.data = subtitle_out;
652         pkt.size = subtitle_out_size;
653         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);
654         if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
655             /* XXX: the pts correction is handled here. Maybe handling
656                it in the codec would be better */
657             if (i == 0)
658                 pkt.pts += 90 * sub->start_display_time;
659             else
660                 pkt.pts += 90 * sub->end_display_time;
661         }
662         write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
663     }
664 }
665
666 static int bit_buffer_size= 1024*256;
667 static uint8_t *bit_buffer= NULL;
668
669 static void do_video_out(AVFormatContext *s,
670                          AVOutputStream *ost,
671                          AVInputStream *ist,
672                          AVFrame *in_picture,
673                          int *frame_size)
674 {
675     int nb_frames, i, ret;
676     AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
677     AVFrame picture_crop_temp, picture_pad_temp;
678     uint8_t *buf = NULL, *buf1 = NULL;
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             goto the_end;
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                 goto the_end;
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  the_end:
835     av_free(buf);
836     av_free(buf1);
837 }
838
839 static double psnr(double d){
840     if(d==0) return INFINITY;
841     return -10.0*log(d)/log(10.0);
842 }
843
844 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
845                            int frame_size)
846 {
847     static FILE *fvstats=NULL;
848     char filename[40];
849     time_t today2;
850     struct tm *today;
851     AVCodecContext *enc;
852     int frame_number;
853     int64_t ti;
854     double ti1, bitrate, avg_bitrate;
855
856     if (!fvstats) {
857         today2 = time(NULL);
858         today = localtime(&today2);
859         snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
860                                                today->tm_min,
861                                                today->tm_sec);
862         fvstats = fopen(filename,"w");
863         if (!fvstats) {
864             perror("fopen");
865             exit(1);
866         }
867     }
868
869     ti = INT64_MAX;
870     enc = ost->st->codec;
871     if (enc->codec_type == CODEC_TYPE_VIDEO) {
872         frame_number = ost->frame_number;
873         fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
874         if (enc->flags&CODEC_FLAG_PSNR)
875             fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
876
877         fprintf(fvstats,"f_size= %6d ", frame_size);
878         /* compute pts value */
879         ti1 = ost->sync_opts * av_q2d(enc->time_base);
880         if (ti1 < 0.01)
881             ti1 = 0.01;
882
883         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
884         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
885         fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
886             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
887         fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
888     }
889 }
890
891 static void print_report(AVFormatContext **output_files,
892                          AVOutputStream **ost_table, int nb_ostreams,
893                          int is_last_report)
894 {
895     char buf[1024];
896     AVOutputStream *ost;
897     AVFormatContext *oc, *os;
898     int64_t total_size;
899     AVCodecContext *enc;
900     int frame_number, vid, i;
901     double bitrate, ti1, pts;
902     static int64_t last_time = -1;
903     static int qp_histogram[52];
904
905     if (!is_last_report) {
906         int64_t cur_time;
907         /* display the report every 0.5 seconds */
908         cur_time = av_gettime();
909         if (last_time == -1) {
910             last_time = cur_time;
911             return;
912         }
913         if ((cur_time - last_time) < 500000)
914             return;
915         last_time = cur_time;
916     }
917
918
919     oc = output_files[0];
920
921     total_size = url_ftell(&oc->pb);
922
923     buf[0] = '\0';
924     ti1 = 1e10;
925     vid = 0;
926     for(i=0;i<nb_ostreams;i++) {
927         ost = ost_table[i];
928         os = output_files[ost->file_index];
929         enc = ost->st->codec;
930         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
931             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
932                     enc->coded_frame->quality/(float)FF_QP2LAMBDA);
933         }
934         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
935             frame_number = ost->frame_number;
936             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
937                     frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
938             if(is_last_report)
939                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
940             if(qp_hist && enc->coded_frame){
941                 int j;
942                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
943                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
944                     qp_histogram[qp]++;
945                 for(j=0; j<32; j++)
946                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
947             }
948             if (enc->flags&CODEC_FLAG_PSNR){
949                 int j;
950                 double error, error_sum=0;
951                 double scale, scale_sum=0;
952                 char type[3]= {'Y','U','V'};
953                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
954                 for(j=0; j<3; j++){
955                     if(is_last_report){
956                         error= enc->error[j];
957                         scale= enc->width*enc->height*255.0*255.0*frame_number;
958                     }else{
959                         error= enc->coded_frame->error[j];
960                         scale= enc->width*enc->height*255.0*255.0;
961                     }
962                     if(j) scale/=4;
963                     error_sum += error;
964                     scale_sum += scale;
965                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
966                 }
967                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
968             }
969             vid = 1;
970         }
971         /* compute min output value */
972         pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
973         if ((pts < ti1) && (pts > 0))
974             ti1 = pts;
975     }
976     if (ti1 < 0.01)
977         ti1 = 0.01;
978
979     if (verbose || is_last_report) {
980         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
981
982         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
983             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
984             (double)total_size / 1024, ti1, bitrate);
985
986         if (verbose > 1)
987           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
988                   nb_frames_dup, nb_frames_drop);
989
990         if (verbose >= 0)
991             fprintf(stderr, "%s    \r", buf);
992
993         fflush(stderr);
994     }
995
996     if (is_last_report && verbose >= 0){
997         int64_t raw= audio_size + video_size + extra_size;
998         fprintf(stderr, "\n");
999         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1000                 video_size/1024.0,
1001                 audio_size/1024.0,
1002                 extra_size/1024.0,
1003                 100.0*(total_size - raw)/raw
1004         );
1005     }
1006 }
1007
1008 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1009 static int output_packet(AVInputStream *ist, int ist_index,
1010                          AVOutputStream **ost_table, int nb_ostreams,
1011                          const AVPacket *pkt)
1012 {
1013     AVFormatContext *os;
1014     AVOutputStream *ost;
1015     uint8_t *ptr;
1016     int len, ret, i;
1017     uint8_t *data_buf;
1018     int data_size, got_picture;
1019     AVFrame picture;
1020     void *buffer_to_free;
1021     static unsigned int samples_size= 0;
1022     static short *samples= NULL;
1023     AVSubtitle subtitle, *subtitle_to_free;
1024     int got_subtitle;
1025
1026     if(!pkt){
1027         ist->pts= ist->next_pts; // needed for last packet if vsync=0
1028     } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1029         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1030     } else {
1031 //        assert(ist->pts == ist->next_pts);
1032     }
1033
1034     if (pkt == NULL) {
1035         /* EOF handling */
1036         ptr = NULL;
1037         len = 0;
1038         goto handle_eof;
1039     }
1040
1041     len = pkt->size;
1042     ptr = pkt->data;
1043     while (len > 0) {
1044     handle_eof:
1045         /* decode the packet if needed */
1046         data_buf = NULL; /* fail safe */
1047         data_size = 0;
1048         subtitle_to_free = NULL;
1049         if (ist->decoding_needed) {
1050             switch(ist->st->codec->codec_type) {
1051             case CODEC_TYPE_AUDIO:{
1052                 if(pkt)
1053                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1054                 data_size= samples_size;
1055                     /* XXX: could avoid copy if PCM 16 bits with same
1056                        endianness as CPU */
1057                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1058                                            ptr, len);
1059                 if (ret < 0)
1060                     goto fail_decode;
1061                 ptr += ret;
1062                 len -= ret;
1063                 /* Some bug in mpeg audio decoder gives */
1064                 /* data_size < 0, it seems they are overflows */
1065                 if (data_size <= 0) {
1066                     /* no audio frame */
1067                     continue;
1068                 }
1069                 data_buf = (uint8_t *)samples;
1070                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1071                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1072                 break;}
1073             case CODEC_TYPE_VIDEO:
1074                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1075                     /* XXX: allocate picture correctly */
1076                     avcodec_get_frame_defaults(&picture);
1077
1078                     ret = avcodec_decode_video(ist->st->codec,
1079                                                &picture, &got_picture, ptr, len);
1080                     ist->st->quality= picture.quality;
1081                     if (ret < 0)
1082                         goto fail_decode;
1083                     if (!got_picture) {
1084                         /* no picture yet */
1085                         goto discard_packet;
1086                     }
1087                     if (ist->st->codec->time_base.num != 0) {
1088                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1089                                           ist->st->codec->time_base.num) /
1090                             ist->st->codec->time_base.den;
1091                     }
1092                     len = 0;
1093                     break;
1094             case CODEC_TYPE_SUBTITLE:
1095                 ret = avcodec_decode_subtitle(ist->st->codec,
1096                                               &subtitle, &got_subtitle, ptr, len);
1097                 if (ret < 0)
1098                     goto fail_decode;
1099                 if (!got_subtitle) {
1100                     goto discard_packet;
1101                 }
1102                 subtitle_to_free = &subtitle;
1103                 len = 0;
1104                 break;
1105             default:
1106                 goto fail_decode;
1107             }
1108         } else {
1109                 switch(ist->st->codec->codec_type) {
1110                 case CODEC_TYPE_AUDIO:
1111                     ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1112                         (ist->st->codec->sample_rate * ist->st->codec->channels);
1113                     break;
1114                 case CODEC_TYPE_VIDEO:
1115                     if (ist->st->codec->time_base.num != 0) {
1116                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1117                                           ist->st->codec->time_base.num) /
1118                             ist->st->codec->time_base.den;
1119                     }
1120                     break;
1121                 }
1122                 data_buf = ptr;
1123                 data_size = len;
1124                 ret = len;
1125                 len = 0;
1126             }
1127
1128             buffer_to_free = NULL;
1129             if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1130                 pre_process_video_frame(ist, (AVPicture *)&picture,
1131                                         &buffer_to_free);
1132             }
1133
1134             // preprocess audio (volume)
1135             if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1136                 if (audio_volume != 256) {
1137                     short *volp;
1138                     volp = samples;
1139                     for(i=0;i<(data_size / sizeof(short));i++) {
1140                         int v = ((*volp) * audio_volume + 128) >> 8;
1141                         if (v < -32768) v = -32768;
1142                         if (v >  32767) v = 32767;
1143                         *volp++ = v;
1144                     }
1145                 }
1146             }
1147
1148             /* frame rate emulation */
1149             if (ist->st->codec->rate_emu) {
1150                 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1151                 int64_t now = av_gettime() - ist->start;
1152                 if (pts > now)
1153                     usleep(pts - now);
1154
1155                 ist->frame++;
1156             }
1157
1158 #if 0
1159             /* mpeg PTS deordering : if it is a P or I frame, the PTS
1160                is the one of the next displayed one */
1161             /* XXX: add mpeg4 too ? */
1162             if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1163                 if (ist->st->codec->pict_type != B_TYPE) {
1164                     int64_t tmp;
1165                     tmp = ist->last_ip_pts;
1166                     ist->last_ip_pts  = ist->frac_pts.val;
1167                     ist->frac_pts.val = tmp;
1168                 }
1169             }
1170 #endif
1171             /* if output time reached then transcode raw format,
1172                encode packets and output them */
1173             if (start_time == 0 || ist->pts >= start_time)
1174                 for(i=0;i<nb_ostreams;i++) {
1175                     int frame_size;
1176
1177                     ost = ost_table[i];
1178                     if (ost->source_index == ist_index) {
1179                         os = output_files[ost->file_index];
1180
1181 #if 0
1182                         printf("%d: got pts=%0.3f %0.3f\n", i,
1183                                (double)pkt->pts / AV_TIME_BASE,
1184                                ((double)ist->pts / AV_TIME_BASE) -
1185                                ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1186 #endif
1187                         /* set the input output pts pairs */
1188                         //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1189
1190                         if (ost->encoding_needed) {
1191                             switch(ost->st->codec->codec_type) {
1192                             case CODEC_TYPE_AUDIO:
1193                                 do_audio_out(os, ost, ist, data_buf, data_size);
1194                                 break;
1195                             case CODEC_TYPE_VIDEO:
1196                                     do_video_out(os, ost, ist, &picture, &frame_size);
1197                                     video_size += frame_size;
1198                                     if (do_vstats && frame_size)
1199                                         do_video_stats(os, ost, frame_size);
1200                                 break;
1201                             case CODEC_TYPE_SUBTITLE:
1202                                 do_subtitle_out(os, ost, ist, &subtitle,
1203                                                 pkt->pts);
1204                                 break;
1205                             default:
1206                                 av_abort();
1207                             }
1208                         } else {
1209                             AVFrame avframe; //FIXME/XXX remove this
1210                             AVPacket opkt;
1211                             av_init_packet(&opkt);
1212
1213                             /* no reencoding needed : output the packet directly */
1214                             /* force the input stream PTS */
1215
1216                             avcodec_get_frame_defaults(&avframe);
1217                             ost->st->codec->coded_frame= &avframe;
1218                             avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1219
1220                             if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1221                                 audio_size += data_size;
1222                             else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1223                                 video_size += data_size;
1224                                 ost->sync_opts++;
1225                             }
1226
1227                             opkt.stream_index= ost->index;
1228                             if(pkt->pts != AV_NOPTS_VALUE)
1229                                 opkt.pts= av_rescale_q(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);
1230                             else
1231                                 opkt.pts= AV_NOPTS_VALUE;
1232
1233                             {
1234                                 int64_t dts;
1235                                 if (pkt->dts == AV_NOPTS_VALUE)
1236                                     dts = ist->next_pts;
1237                                 else
1238                                     dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1239                                 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q,  ost->st->time_base);
1240                             }
1241                             opkt.flags= pkt->flags;
1242
1243                             //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1244                             if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1245                                 opkt.destruct= av_destruct_packet;
1246
1247                             write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1248                             ost->st->codec->frame_number++;
1249                             ost->frame_number++;
1250                             av_free_packet(&opkt);
1251                         }
1252                     }
1253                 }
1254             av_free(buffer_to_free);
1255             /* XXX: allocate the subtitles in the codec ? */
1256             if (subtitle_to_free) {
1257                 if (subtitle_to_free->rects != NULL) {
1258                     for (i = 0; i < subtitle_to_free->num_rects; i++) {
1259                         av_free(subtitle_to_free->rects[i].bitmap);
1260                         av_free(subtitle_to_free->rects[i].rgba_palette);
1261                     }
1262                     av_freep(&subtitle_to_free->rects);
1263                 }
1264                 subtitle_to_free->num_rects = 0;
1265                 subtitle_to_free = NULL;
1266             }
1267         }
1268  discard_packet:
1269     if (pkt == NULL) {
1270         /* EOF handling */
1271
1272         for(i=0;i<nb_ostreams;i++) {
1273             ost = ost_table[i];
1274             if (ost->source_index == ist_index) {
1275                 AVCodecContext *enc= ost->st->codec;
1276                 os = output_files[ost->file_index];
1277
1278                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1279                     continue;
1280                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1281                     continue;
1282
1283                 if (ost->encoding_needed) {
1284                     for(;;) {
1285                         AVPacket pkt;
1286                         int fifo_bytes;
1287                         av_init_packet(&pkt);
1288                         pkt.stream_index= ost->index;
1289
1290                         switch(ost->st->codec->codec_type) {
1291                         case CODEC_TYPE_AUDIO:
1292                             fifo_bytes = av_fifo_size(&ost->fifo);
1293                             ret = 0;
1294                             /* encode any samples remaining in fifo */
1295                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1296                                 int fs_tmp = enc->frame_size;
1297                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1298                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1299                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1300                                 }
1301                                 enc->frame_size = fs_tmp;
1302                             }
1303                             if(ret <= 0) {
1304                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1305                             }
1306                             audio_size += ret;
1307                             pkt.flags |= PKT_FLAG_KEY;
1308                             break;
1309                         case CODEC_TYPE_VIDEO:
1310                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1311                             video_size += ret;
1312                             if(enc->coded_frame && enc->coded_frame->key_frame)
1313                                 pkt.flags |= PKT_FLAG_KEY;
1314                             if (ost->logfile && enc->stats_out) {
1315                                 fprintf(ost->logfile, "%s", enc->stats_out);
1316                             }
1317                             break;
1318                         default:
1319                             ret=-1;
1320                         }
1321
1322                         if(ret<=0)
1323                             break;
1324                         pkt.data= bit_buffer;
1325                         pkt.size= ret;
1326                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1327                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1328                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1329                     }
1330                 }
1331             }
1332         }
1333     }
1334
1335     return 0;
1336  fail_decode:
1337     return -1;
1338 }
1339
1340
1341 /*
1342  * The following code is the main loop of the file converter
1343  */
1344 static int av_encode(AVFormatContext **output_files,
1345                      int nb_output_files,
1346                      AVFormatContext **input_files,
1347                      int nb_input_files,
1348                      AVStreamMap *stream_maps, int nb_stream_maps)
1349 {
1350     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1351     AVFormatContext *is, *os;
1352     AVCodecContext *codec, *icodec;
1353     AVOutputStream *ost, **ost_table = NULL;
1354     AVInputStream *ist, **ist_table = NULL;
1355     AVInputFile *file_table;
1356     AVFormatContext *stream_no_data;
1357     int key;
1358
1359     file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1360     if (!file_table)
1361         goto fail;
1362
1363     /* input stream init */
1364     j = 0;
1365     for(i=0;i<nb_input_files;i++) {
1366         is = input_files[i];
1367         file_table[i].ist_index = j;
1368         file_table[i].nb_streams = is->nb_streams;
1369         j += is->nb_streams;
1370     }
1371     nb_istreams = j;
1372
1373     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1374     if (!ist_table)
1375         goto fail;
1376
1377     for(i=0;i<nb_istreams;i++) {
1378         ist = av_mallocz(sizeof(AVInputStream));
1379         if (!ist)
1380             goto fail;
1381         ist_table[i] = ist;
1382     }
1383     j = 0;
1384     for(i=0;i<nb_input_files;i++) {
1385         is = input_files[i];
1386         for(k=0;k<is->nb_streams;k++) {
1387             ist = ist_table[j++];
1388             ist->st = is->streams[k];
1389             ist->file_index = i;
1390             ist->index = k;
1391             ist->discard = 1; /* the stream is discarded by default
1392                                  (changed later) */
1393
1394             if (ist->st->codec->rate_emu) {
1395                 ist->start = av_gettime();
1396                 ist->frame = 0;
1397             }
1398         }
1399     }
1400
1401     /* output stream init */
1402     nb_ostreams = 0;
1403     for(i=0;i<nb_output_files;i++) {
1404         os = output_files[i];
1405         if (!os->nb_streams) {
1406             fprintf(stderr, "Output file does not contain any stream\n");
1407             exit(1);
1408         }
1409         nb_ostreams += os->nb_streams;
1410     }
1411     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1412         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1413         exit(1);
1414     }
1415
1416     /* Sanity check the mapping args -- do the input files & streams exist? */
1417     for(i=0;i<nb_stream_maps;i++) {
1418         int fi = stream_maps[i].file_index;
1419         int si = stream_maps[i].stream_index;
1420
1421         if (fi < 0 || fi > nb_input_files - 1 ||
1422             si < 0 || si > file_table[fi].nb_streams - 1) {
1423             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1424             exit(1);
1425         }
1426         fi = stream_maps[i].sync_file_index;
1427         si = stream_maps[i].sync_stream_index;
1428         if (fi < 0 || fi > nb_input_files - 1 ||
1429             si < 0 || si > file_table[fi].nb_streams - 1) {
1430             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1431             exit(1);
1432         }
1433     }
1434
1435     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1436     if (!ost_table)
1437         goto fail;
1438     for(i=0;i<nb_ostreams;i++) {
1439         ost = av_mallocz(sizeof(AVOutputStream));
1440         if (!ost)
1441             goto fail;
1442         ost_table[i] = ost;
1443     }
1444
1445     n = 0;
1446     for(k=0;k<nb_output_files;k++) {
1447         os = output_files[k];
1448         for(i=0;i<os->nb_streams;i++) {
1449             int found;
1450             ost = ost_table[n++];
1451             ost->file_index = k;
1452             ost->index = i;
1453             ost->st = os->streams[i];
1454             if (nb_stream_maps > 0) {
1455                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1456                     stream_maps[n-1].stream_index;
1457
1458                 /* Sanity check that the stream types match */
1459                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1460                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1461                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1462                         ost->file_index, ost->index);
1463                     exit(1);
1464                 }
1465
1466             } else {
1467                 /* get corresponding input stream index : we select the first one with the right type */
1468                 found = 0;
1469                 for(j=0;j<nb_istreams;j++) {
1470                     ist = ist_table[j];
1471                     if (ist->discard &&
1472                         ist->st->codec->codec_type == ost->st->codec->codec_type) {
1473                         ost->source_index = j;
1474                         found = 1;
1475                         break;
1476                     }
1477                 }
1478
1479                 if (!found) {
1480                     /* try again and reuse existing stream */
1481                     for(j=0;j<nb_istreams;j++) {
1482                         ist = ist_table[j];
1483                         if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1484                             ost->source_index = j;
1485                             found = 1;
1486                         }
1487                     }
1488                     if (!found) {
1489                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1490                                 ost->file_index, ost->index);
1491                         exit(1);
1492                     }
1493                 }
1494             }
1495             ist = ist_table[ost->source_index];
1496             ist->discard = 0;
1497             ost->sync_ist = (nb_stream_maps > 0) ?
1498                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1499                          stream_maps[n-1].sync_stream_index] : ist;
1500         }
1501     }
1502
1503     /* for each output stream, we compute the right encoding parameters */
1504     for(i=0;i<nb_ostreams;i++) {
1505         ost = ost_table[i];
1506         ist = ist_table[ost->source_index];
1507
1508         codec = ost->st->codec;
1509         icodec = ist->st->codec;
1510
1511         if (ost->st->stream_copy) {
1512             /* if stream_copy is selected, no need to decode or encode */
1513             codec->codec_id = icodec->codec_id;
1514             codec->codec_type = icodec->codec_type;
1515             if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1516             codec->bit_rate = icodec->bit_rate;
1517             codec->extradata= icodec->extradata;
1518             codec->extradata_size= icodec->extradata_size;
1519             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1520                 codec->time_base = icodec->time_base;
1521             else
1522                 codec->time_base = ist->st->time_base;
1523             switch(codec->codec_type) {
1524             case CODEC_TYPE_AUDIO:
1525                 codec->sample_rate = icodec->sample_rate;
1526                 codec->channels = icodec->channels;
1527                 codec->frame_size = icodec->frame_size;
1528                 codec->block_align= icodec->block_align;
1529                 break;
1530             case CODEC_TYPE_VIDEO:
1531                 if(using_vhook) {
1532                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1533                     exit(1);
1534                 }
1535                 codec->pix_fmt = icodec->pix_fmt;
1536                 codec->width = icodec->width;
1537                 codec->height = icodec->height;
1538                 codec->has_b_frames = icodec->has_b_frames;
1539                 break;
1540             case CODEC_TYPE_SUBTITLE:
1541                 break;
1542             default:
1543                 av_abort();
1544             }
1545         } else {
1546             switch(codec->codec_type) {
1547             case CODEC_TYPE_AUDIO:
1548                 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1549                     goto fail;
1550
1551                 if (codec->channels == icodec->channels &&
1552                     codec->sample_rate == icodec->sample_rate) {
1553                     ost->audio_resample = 0;
1554                 } else {
1555                     if (codec->channels != icodec->channels &&
1556                         (icodec->codec_id == CODEC_ID_AC3 ||
1557                          icodec->codec_id == CODEC_ID_DTS)) {
1558                         /* Special case for 5:1 AC3 and DTS input */
1559                         /* and mono or stereo output      */
1560                         /* Request specific number of channels */
1561                         icodec->channels = codec->channels;
1562                         if (codec->sample_rate == icodec->sample_rate)
1563                             ost->audio_resample = 0;
1564                         else {
1565                             ost->audio_resample = 1;
1566                         }
1567                     } else {
1568                         ost->audio_resample = 1;
1569                     }
1570                 }
1571                 if(audio_sync_method>1)
1572                     ost->audio_resample = 1;
1573
1574                 if(ost->audio_resample){
1575                     ost->resample = audio_resample_init(codec->channels, icodec->channels,
1576                                                     codec->sample_rate, icodec->sample_rate);
1577                     if(!ost->resample){
1578                         printf("Can't resample.  Aborting.\n");
1579                         av_abort();
1580                     }
1581                 }
1582                 ist->decoding_needed = 1;
1583                 ost->encoding_needed = 1;
1584                 break;
1585             case CODEC_TYPE_VIDEO:
1586                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1587                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1588                 ost->video_resample = ((codec->width != icodec->width -
1589                                 (frame_leftBand + frame_rightBand) +
1590                                 (frame_padleft + frame_padright)) ||
1591                         (codec->height != icodec->height -
1592                                 (frame_topBand  + frame_bottomBand) +
1593                                 (frame_padtop + frame_padbottom)) ||
1594                         (codec->pix_fmt != icodec->pix_fmt));
1595                 if (ost->video_crop) {
1596                     ost->topBand = frame_topBand;
1597                     ost->leftBand = frame_leftBand;
1598                 }
1599                 if (ost->video_pad) {
1600                     ost->padtop = frame_padtop;
1601                     ost->padleft = frame_padleft;
1602                     ost->padbottom = frame_padbottom;
1603                     ost->padright = frame_padright;
1604                     if (!ost->video_resample) {
1605                         avcodec_get_frame_defaults(&ost->pict_tmp);
1606                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1607                                          codec->width, codec->height ) )
1608                             goto fail;
1609                     }
1610                 }
1611                 if (ost->video_resample) {
1612                     avcodec_get_frame_defaults(&ost->pict_tmp);
1613                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1614                                          codec->width, codec->height ) )
1615                         exit(1);
1616
1617                     ost->img_resample_ctx = sws_getContext(
1618                             icodec->width - (frame_leftBand + frame_rightBand),
1619                             icodec->height - (frame_topBand + frame_bottomBand),
1620                             icodec->pix_fmt,
1621                             codec->width - (frame_padleft + frame_padright),
1622                             codec->height - (frame_padtop + frame_padbottom),
1623                             codec->pix_fmt,
1624                             sws_flags, NULL, NULL, NULL);
1625                     if (ost->img_resample_ctx == NULL) {
1626                         fprintf(stderr, "Cannot get resampling context\n");
1627                         exit(1);
1628                     }
1629                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1630                 }
1631                 ost->encoding_needed = 1;
1632                 ist->decoding_needed = 1;
1633                 break;
1634             case CODEC_TYPE_SUBTITLE:
1635                 ost->encoding_needed = 1;
1636                 ist->decoding_needed = 1;
1637                 break;
1638             default:
1639                 av_abort();
1640                 break;
1641             }
1642             /* two pass mode */
1643             if (ost->encoding_needed &&
1644                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1645                 char logfilename[1024];
1646                 FILE *f;
1647                 int size;
1648                 char *logbuffer;
1649
1650                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1651                          pass_logfilename ?
1652                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1653                 if (codec->flags & CODEC_FLAG_PASS1) {
1654                     f = fopen(logfilename, "w");
1655                     if (!f) {
1656                         perror(logfilename);
1657                         exit(1);
1658                     }
1659                     ost->logfile = f;
1660                 } else {
1661                     /* read the log file */
1662                     f = fopen(logfilename, "r");
1663                     if (!f) {
1664                         perror(logfilename);
1665                         exit(1);
1666                     }
1667                     fseek(f, 0, SEEK_END);
1668                     size = ftell(f);
1669                     fseek(f, 0, SEEK_SET);
1670                     logbuffer = av_malloc(size + 1);
1671                     if (!logbuffer) {
1672                         fprintf(stderr, "Could not allocate log buffer\n");
1673                         exit(1);
1674                     }
1675                     size = fread(logbuffer, 1, size, f);
1676                     fclose(f);
1677                     logbuffer[size] = '\0';
1678                     codec->stats_in = logbuffer;
1679                 }
1680             }
1681         }
1682         if(codec->codec_type == CODEC_TYPE_VIDEO){
1683             int size= codec->width * codec->height;
1684             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1685         }
1686     }
1687
1688     if (!bit_buffer)
1689         bit_buffer = av_malloc(bit_buffer_size);
1690     if (!bit_buffer)
1691         goto fail;
1692
1693     /* dump the file output parameters - cannot be done before in case
1694        of stream copy */
1695     for(i=0;i<nb_output_files;i++) {
1696         dump_format(output_files[i], i, output_files[i]->filename, 1);
1697     }
1698
1699     /* dump the stream mapping */
1700     if (verbose >= 0) {
1701         fprintf(stderr, "Stream mapping:\n");
1702         for(i=0;i<nb_ostreams;i++) {
1703             ost = ost_table[i];
1704             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1705                     ist_table[ost->source_index]->file_index,
1706                     ist_table[ost->source_index]->index,
1707                     ost->file_index,
1708                     ost->index);
1709             if (ost->sync_ist != ist_table[ost->source_index])
1710                 fprintf(stderr, " [sync #%d.%d]",
1711                         ost->sync_ist->file_index,
1712                         ost->sync_ist->index);
1713             fprintf(stderr, "\n");
1714         }
1715     }
1716
1717     /* open each encoder */
1718     for(i=0;i<nb_ostreams;i++) {
1719         ost = ost_table[i];
1720         if (ost->encoding_needed) {
1721             AVCodec *codec;
1722             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1723             if (!codec) {
1724                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1725                         ost->file_index, ost->index);
1726                 exit(1);
1727             }
1728             if (avcodec_open(ost->st->codec, codec) < 0) {
1729                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1730                         ost->file_index, ost->index);
1731                 exit(1);
1732             }
1733             extra_size += ost->st->codec->extradata_size;
1734         }
1735     }
1736
1737     /* open each decoder */
1738     for(i=0;i<nb_istreams;i++) {
1739         ist = ist_table[i];
1740         if (ist->decoding_needed) {
1741             AVCodec *codec;
1742             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1743             if (!codec) {
1744                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1745                         ist->st->codec->codec_id, ist->file_index, ist->index);
1746                 exit(1);
1747             }
1748             if (avcodec_open(ist->st->codec, codec) < 0) {
1749                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1750                         ist->file_index, ist->index);
1751                 exit(1);
1752             }
1753             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1754             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1755         }
1756     }
1757
1758     /* init pts */
1759     for(i=0;i<nb_istreams;i++) {
1760         ist = ist_table[i];
1761         is = input_files[ist->file_index];
1762         ist->pts = 0;
1763         ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1764         if(ist->st->start_time == AV_NOPTS_VALUE)
1765             ist->next_pts=0;
1766         if(input_files_ts_offset[ist->file_index])
1767             ist->next_pts= AV_NOPTS_VALUE;
1768         ist->is_start = 1;
1769     }
1770
1771     /* compute buffer size max (should use a complete heuristic) */
1772     for(i=0;i<nb_input_files;i++) {
1773         file_table[i].buffer_size_max = 2048;
1774     }
1775
1776     /* set meta data information from input file if required */
1777     for (i=0;i<nb_meta_data_maps;i++) {
1778         AVFormatContext *out_file;
1779         AVFormatContext *in_file;
1780
1781         int out_file_index = meta_data_maps[i].out_file;
1782         int in_file_index = meta_data_maps[i].in_file;
1783         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1784             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1785             ret = AVERROR(EINVAL);
1786             goto fail;
1787         }
1788         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1789             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1790             ret = AVERROR(EINVAL);
1791             goto fail;
1792         }
1793
1794         out_file = output_files[out_file_index];
1795         in_file = input_files[in_file_index];
1796
1797         strcpy(out_file->title, in_file->title);
1798         strcpy(out_file->author, in_file->author);
1799         strcpy(out_file->copyright, in_file->copyright);
1800         strcpy(out_file->comment, in_file->comment);
1801         strcpy(out_file->album, in_file->album);
1802         out_file->year = in_file->year;
1803         out_file->track = in_file->track;
1804         strcpy(out_file->genre, in_file->genre);
1805     }
1806
1807     /* open files and write file headers */
1808     for(i=0;i<nb_output_files;i++) {
1809         os = output_files[i];
1810         if (av_write_header(os) < 0) {
1811             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1812             ret = AVERROR(EINVAL);
1813             goto fail;
1814         }
1815     }
1816
1817     if ( !using_stdin && verbose >= 0) {
1818         fprintf(stderr, "Press [q] to stop encoding\n");
1819         url_set_interrupt_cb(decode_interrupt_cb);
1820     }
1821     term_init();
1822
1823     stream_no_data = 0;
1824     key = -1;
1825
1826     for(; received_sigterm == 0;) {
1827         int file_index, ist_index;
1828         AVPacket pkt;
1829         double ipts_min;
1830         double opts_min;
1831
1832     redo:
1833         ipts_min= 1e100;
1834         opts_min= 1e100;
1835         /* if 'q' pressed, exits */
1836         if (!using_stdin) {
1837             if (q_pressed)
1838                 break;
1839             /* read_key() returns 0 on EOF */
1840             key = read_key();
1841             if (key == 'q')
1842                 break;
1843         }
1844
1845         /* select the stream that we must read now by looking at the
1846            smallest output pts */
1847         file_index = -1;
1848         for(i=0;i<nb_ostreams;i++) {
1849             double ipts, opts;
1850             ost = ost_table[i];
1851             os = output_files[ost->file_index];
1852             ist = ist_table[ost->source_index];
1853             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1854                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1855             else
1856                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1857             ipts = (double)ist->pts;
1858             if (!file_table[ist->file_index].eof_reached){
1859                 if(ipts < ipts_min) {
1860                     ipts_min = ipts;
1861                     if(input_sync ) file_index = ist->file_index;
1862                 }
1863                 if(opts < opts_min) {
1864                     opts_min = opts;
1865                     if(!input_sync) file_index = ist->file_index;
1866                 }
1867             }
1868             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1869                 file_index= -1;
1870                 break;
1871             }
1872         }
1873         /* if none, if is finished */
1874         if (file_index < 0) {
1875             break;
1876         }
1877
1878         /* finish if recording time exhausted */
1879         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1880             break;
1881
1882         /* finish if limit size exhausted */
1883         if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1884             break;
1885
1886         /* read a frame from it and output it in the fifo */
1887         is = input_files[file_index];
1888         if (av_read_frame(is, &pkt) < 0) {
1889             file_table[file_index].eof_reached = 1;
1890             if (opt_shortest) break; else continue; //
1891         }
1892
1893         if (!pkt.size) {
1894             stream_no_data = is;
1895         } else {
1896             stream_no_data = 0;
1897         }
1898         if (do_pkt_dump) {
1899             av_pkt_dump(stdout, &pkt, do_hex_dump);
1900         }
1901         /* the following test is needed in case new streams appear
1902            dynamically in stream : we ignore them */
1903         if (pkt.stream_index >= file_table[file_index].nb_streams)
1904             goto discard_packet;
1905         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1906         ist = ist_table[ist_index];
1907         if (ist->discard)
1908             goto discard_packet;
1909
1910 //        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);
1911         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1912             int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1913             if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1914                 input_files_ts_offset[ist->file_index]-= delta;
1915                 if (verbose > 2)
1916                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1917                 for(i=0; i<file_table[file_index].nb_streams; i++){
1918                     int index= file_table[file_index].ist_index + i;
1919                     ist_table[index]->next_pts += delta;
1920                     ist_table[index]->is_start=1;
1921                 }
1922             }
1923         }
1924
1925         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1926         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1927
1928             if (verbose >= 0)
1929                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1930                         ist->file_index, ist->index);
1931
1932             av_free_packet(&pkt);
1933             goto redo;
1934         }
1935
1936     discard_packet:
1937         av_free_packet(&pkt);
1938
1939         /* dump report by using the output first video and audio streams */
1940         print_report(output_files, ost_table, nb_ostreams, 0);
1941     }
1942
1943     /* at the end of stream, we must flush the decoder buffers */
1944     for(i=0;i<nb_istreams;i++) {
1945         ist = ist_table[i];
1946         if (ist->decoding_needed) {
1947             output_packet(ist, i, ost_table, nb_ostreams, NULL);
1948         }
1949     }
1950
1951     term_exit();
1952
1953     /* write the trailer if needed and close file */
1954     for(i=0;i<nb_output_files;i++) {
1955         os = output_files[i];
1956         av_write_trailer(os);
1957     }
1958
1959     /* dump report by using the first video and audio streams */
1960     print_report(output_files, ost_table, nb_ostreams, 1);
1961
1962     /* close each encoder */
1963     for(i=0;i<nb_ostreams;i++) {
1964         ost = ost_table[i];
1965         if (ost->encoding_needed) {
1966             av_freep(&ost->st->codec->stats_in);
1967             avcodec_close(ost->st->codec);
1968         }
1969     }
1970
1971     /* close each decoder */
1972     for(i=0;i<nb_istreams;i++) {
1973         ist = ist_table[i];
1974         if (ist->decoding_needed) {
1975             avcodec_close(ist->st->codec);
1976         }
1977     }
1978
1979     /* finished ! */
1980
1981     ret = 0;
1982  fail1:
1983     av_freep(&bit_buffer);
1984     av_free(file_table);
1985
1986     if (ist_table) {
1987         for(i=0;i<nb_istreams;i++) {
1988             ist = ist_table[i];
1989             av_free(ist);
1990         }
1991         av_free(ist_table);
1992     }
1993     if (ost_table) {
1994         for(i=0;i<nb_ostreams;i++) {
1995             ost = ost_table[i];
1996             if (ost) {
1997                 if (ost->logfile) {
1998                     fclose(ost->logfile);
1999                     ost->logfile = NULL;
2000                 }
2001                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2002                                              initialized but set to zero */
2003                 av_free(ost->pict_tmp.data[0]);
2004                 if (ost->video_resample)
2005                     sws_freeContext(ost->img_resample_ctx);
2006                 if (ost->audio_resample)
2007                     audio_resample_close(ost->resample);
2008                 av_free(ost);
2009             }
2010         }
2011         av_free(ost_table);
2012     }
2013     return ret;
2014  fail:
2015     ret = AVERROR(ENOMEM);
2016     goto fail1;
2017 }
2018
2019 #if 0
2020 int file_read(const char *filename)
2021 {
2022     URLContext *h;
2023     unsigned char buffer[1024];
2024     int len, i;
2025
2026     if (url_open(&h, filename, O_RDONLY) < 0) {
2027         printf("could not open '%s'\n", filename);
2028         return -1;
2029     }
2030     for(;;) {
2031         len = url_read(h, buffer, sizeof(buffer));
2032         if (len <= 0)
2033             break;
2034         for(i=0;i<len;i++) putchar(buffer[i]);
2035     }
2036     url_close(h);
2037     return 0;
2038 }
2039 #endif
2040
2041 static void opt_format(const char *arg)
2042 {
2043     /* compatibility stuff for pgmyuv */
2044     if (!strcmp(arg, "pgmyuv")) {
2045         pgmyuv_compatibility_hack=1;
2046 //        opt_image_format(arg);
2047         arg = "image2";
2048     }
2049
2050     file_iformat = av_find_input_format(arg);
2051     file_oformat = guess_format(arg, NULL, NULL);
2052     if (!file_iformat && !file_oformat) {
2053         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2054         exit(1);
2055     }
2056 }
2057
2058 static void opt_video_rc_eq(char *arg)
2059 {
2060     video_rc_eq = arg;
2061 }
2062
2063 static void opt_video_rc_override_string(char *arg)
2064 {
2065     video_rc_override_string = arg;
2066 }
2067
2068 static void opt_me_threshold(const char *arg)
2069 {
2070     me_threshold = atoi(arg);
2071 }
2072
2073 static void opt_verbose(const char *arg)
2074 {
2075     verbose = atoi(arg);
2076     av_log_level = atoi(arg);
2077 }
2078
2079 static void opt_frame_rate(const char *arg)
2080 {
2081     if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2082         fprintf(stderr, "Incorrect frame rate\n");
2083         exit(1);
2084     }
2085 }
2086
2087 static void opt_frame_crop_top(const char *arg)
2088 {
2089     frame_topBand = atoi(arg);
2090     if (frame_topBand < 0) {
2091         fprintf(stderr, "Incorrect top crop size\n");
2092         exit(1);
2093     }
2094     if ((frame_topBand % 2) != 0) {
2095         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2096         exit(1);
2097     }
2098     if ((frame_topBand) >= frame_height){
2099         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2100         exit(1);
2101     }
2102     frame_height -= frame_topBand;
2103 }
2104
2105 static void opt_frame_crop_bottom(const char *arg)
2106 {
2107     frame_bottomBand = atoi(arg);
2108     if (frame_bottomBand < 0) {
2109         fprintf(stderr, "Incorrect bottom crop size\n");
2110         exit(1);
2111     }
2112     if ((frame_bottomBand % 2) != 0) {
2113         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2114         exit(1);
2115     }
2116     if ((frame_bottomBand) >= frame_height){
2117         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2118         exit(1);
2119     }
2120     frame_height -= frame_bottomBand;
2121 }
2122
2123 static void opt_frame_crop_left(const char *arg)
2124 {
2125     frame_leftBand = atoi(arg);
2126     if (frame_leftBand < 0) {
2127         fprintf(stderr, "Incorrect left crop size\n");
2128         exit(1);
2129     }
2130     if ((frame_leftBand % 2) != 0) {
2131         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2132         exit(1);
2133     }
2134     if ((frame_leftBand) >= frame_width){
2135         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2136         exit(1);
2137     }
2138     frame_width -= frame_leftBand;
2139 }
2140
2141 static void opt_frame_crop_right(const char *arg)
2142 {
2143     frame_rightBand = atoi(arg);
2144     if (frame_rightBand < 0) {
2145         fprintf(stderr, "Incorrect right crop size\n");
2146         exit(1);
2147     }
2148     if ((frame_rightBand % 2) != 0) {
2149         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2150         exit(1);
2151     }
2152     if ((frame_rightBand) >= frame_width){
2153         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2154         exit(1);
2155     }
2156     frame_width -= frame_rightBand;
2157 }
2158
2159 static void opt_frame_size(const char *arg)
2160 {
2161     if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2162         fprintf(stderr, "Incorrect frame size\n");
2163         exit(1);
2164     }
2165     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2166         fprintf(stderr, "Frame size must be a multiple of 2\n");
2167         exit(1);
2168     }
2169 }
2170
2171
2172 #define SCALEBITS 10
2173 #define ONE_HALF  (1 << (SCALEBITS - 1))
2174 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2175
2176 #define RGB_TO_Y(r, g, b) \
2177 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2178   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2179
2180 #define RGB_TO_U(r1, g1, b1, shift)\
2181 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2182      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2183
2184 #define RGB_TO_V(r1, g1, b1, shift)\
2185 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2186    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2187
2188 static void opt_pad_color(const char *arg) {
2189     /* Input is expected to be six hex digits similar to
2190        how colors are expressed in html tags (but without the #) */
2191     int rgb = strtol(arg, NULL, 16);
2192     int r,g,b;
2193
2194     r = (rgb >> 16);
2195     g = ((rgb >> 8) & 255);
2196     b = (rgb & 255);
2197
2198     padcolor[0] = RGB_TO_Y(r,g,b);
2199     padcolor[1] = RGB_TO_U(r,g,b,0);
2200     padcolor[2] = RGB_TO_V(r,g,b,0);
2201 }
2202
2203 static void opt_frame_pad_top(const char *arg)
2204 {
2205     frame_padtop = atoi(arg);
2206     if (frame_padtop < 0) {
2207         fprintf(stderr, "Incorrect top pad size\n");
2208         exit(1);
2209     }
2210     if ((frame_padtop % 2) != 0) {
2211         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2212         exit(1);
2213     }
2214 }
2215
2216 static void opt_frame_pad_bottom(const char *arg)
2217 {
2218     frame_padbottom = atoi(arg);
2219     if (frame_padbottom < 0) {
2220         fprintf(stderr, "Incorrect bottom pad size\n");
2221         exit(1);
2222     }
2223     if ((frame_padbottom % 2) != 0) {
2224         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2225         exit(1);
2226     }
2227 }
2228
2229
2230 static void opt_frame_pad_left(const char *arg)
2231 {
2232     frame_padleft = atoi(arg);
2233     if (frame_padleft < 0) {
2234         fprintf(stderr, "Incorrect left pad size\n");
2235         exit(1);
2236     }
2237     if ((frame_padleft % 2) != 0) {
2238         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2239         exit(1);
2240     }
2241 }
2242
2243
2244 static void opt_frame_pad_right(const char *arg)
2245 {
2246     frame_padright = atoi(arg);
2247     if (frame_padright < 0) {
2248         fprintf(stderr, "Incorrect right pad size\n");
2249         exit(1);
2250     }
2251     if ((frame_padright % 2) != 0) {
2252         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2253         exit(1);
2254     }
2255 }
2256
2257
2258 static void opt_frame_pix_fmt(const char *arg)
2259 {
2260     frame_pix_fmt = avcodec_get_pix_fmt(arg);
2261 }
2262
2263 static void opt_frame_aspect_ratio(const char *arg)
2264 {
2265     int x = 0, y = 0;
2266     double ar = 0;
2267     const char *p;
2268
2269     p = strchr(arg, ':');
2270     if (p) {
2271         x = strtol(arg, (char **)&arg, 10);
2272         if (arg == p)
2273             y = strtol(arg+1, (char **)&arg, 10);
2274         if (x > 0 && y > 0)
2275             ar = (double)x / (double)y;
2276     } else
2277         ar = strtod(arg, (char **)&arg);
2278
2279     if (!ar) {
2280         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2281         exit(1);
2282     }
2283     frame_aspect_ratio = ar;
2284 }
2285
2286 static void opt_qscale(const char *arg)
2287 {
2288     video_qscale = atof(arg);
2289     if (video_qscale <= 0 ||
2290         video_qscale > 255) {
2291         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2292         exit(1);
2293     }
2294 }
2295
2296 static void opt_qdiff(const char *arg)
2297 {
2298     video_qdiff = atoi(arg);
2299     if (video_qdiff < 0 ||
2300         video_qdiff > 31) {
2301         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2302         exit(1);
2303     }
2304 }
2305
2306 static void opt_strict(const char *arg)
2307 {
2308     strict= atoi(arg);
2309 }
2310
2311 static void opt_top_field_first(const char *arg)
2312 {
2313     top_field_first= atoi(arg);
2314 }
2315
2316 static void opt_thread_count(const char *arg)
2317 {
2318     thread_count= atoi(arg);
2319 #if !defined(HAVE_THREADS)
2320     if (verbose >= 0)
2321         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2322 #endif
2323 }
2324
2325 static void opt_audio_rate(const char *arg)
2326 {
2327     audio_sample_rate = atoi(arg);
2328 }
2329
2330 static void opt_audio_channels(const char *arg)
2331 {
2332     audio_channels = atoi(arg);
2333 }
2334
2335 static void opt_video_channel(const char *arg)
2336 {
2337     video_channel = strtol(arg, NULL, 0);
2338 }
2339
2340 static void opt_video_standard(const char *arg)
2341 {
2342     video_standard = av_strdup(arg);
2343 }
2344
2345 static void opt_codec(int *pstream_copy, int *pcodec_id,
2346                       int codec_type, const char *arg)
2347 {
2348     AVCodec *p;
2349
2350     if (!strcmp(arg, "copy")) {
2351         *pstream_copy = 1;
2352     } else {
2353         p = first_avcodec;
2354         while (p) {
2355             if (!strcmp(p->name, arg) && p->type == codec_type)
2356                 break;
2357             p = p->next;
2358         }
2359         if (p == NULL) {
2360             fprintf(stderr, "Unknown codec '%s'\n", arg);
2361             exit(1);
2362         } else {
2363             *pcodec_id = p->id;
2364         }
2365     }
2366 }
2367
2368 static void opt_audio_codec(const char *arg)
2369 {
2370     opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2371 }
2372
2373 static void opt_audio_tag(const char *arg)
2374 {
2375     char *tail;
2376     audio_codec_tag= strtol(arg, &tail, 0);
2377
2378     if(!tail || *tail)
2379         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2380 }
2381
2382 static void opt_video_tag(const char *arg)
2383 {
2384     char *tail;
2385     video_codec_tag= strtol(arg, &tail, 0);
2386
2387     if(!tail || *tail)
2388         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2389 }
2390
2391 static void add_frame_hooker(const char *arg)
2392 {
2393     int argc = 0;
2394     char *argv[64];
2395     int i;
2396     char *args = av_strdup(arg);
2397
2398     using_vhook = 1;
2399
2400     argv[0] = strtok(args, " ");
2401     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2402     }
2403
2404     i = frame_hook_add(argc, argv);
2405
2406     if (i != 0) {
2407         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2408         exit(1);
2409     }
2410 }
2411
2412 const char *motion_str[] = {
2413     "zero",
2414     "full",
2415     "log",
2416     "phods",
2417     "epzs",
2418     "x1",
2419     "hex",
2420     "umh",
2421     "iter",
2422     NULL,
2423 };
2424
2425 static void opt_motion_estimation(const char *arg)
2426 {
2427     const char **p;
2428     p = motion_str;
2429     for(;;) {
2430         if (!*p) {
2431             fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2432             exit(1);
2433         }
2434         if (!strcmp(*p, arg))
2435             break;
2436         p++;
2437     }
2438     me_method = (p - motion_str) + 1;
2439 }
2440
2441 static void opt_video_codec(const char *arg)
2442 {
2443     opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2444 }
2445
2446 static void opt_subtitle_codec(const char *arg)
2447 {
2448     opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2449 }
2450
2451 static void opt_map(const char *arg)
2452 {
2453     AVStreamMap *m;
2454     const char *p;
2455
2456     p = arg;
2457     m = &stream_maps[nb_stream_maps++];
2458
2459     m->file_index = strtol(arg, (char **)&p, 0);
2460     if (*p)
2461         p++;
2462
2463     m->stream_index = strtol(p, (char **)&p, 0);
2464     if (*p) {
2465         p++;
2466         m->sync_file_index = strtol(p, (char **)&p, 0);
2467         if (*p)
2468             p++;
2469         m->sync_stream_index = strtol(p, (char **)&p, 0);
2470     } else {
2471         m->sync_file_index = m->file_index;
2472         m->sync_stream_index = m->stream_index;
2473     }
2474 }
2475
2476 static void opt_map_meta_data(const char *arg)
2477 {
2478     AVMetaDataMap *m;
2479     const char *p;
2480
2481     p = arg;
2482     m = &meta_data_maps[nb_meta_data_maps++];
2483
2484     m->out_file = strtol(arg, (char **)&p, 0);
2485     if (*p)
2486         p++;
2487
2488     m->in_file = strtol(p, (char **)&p, 0);
2489 }
2490
2491 static void opt_recording_time(const char *arg)
2492 {
2493     recording_time = parse_date(arg, 1);
2494 }
2495
2496 static void opt_start_time(const char *arg)
2497 {
2498     start_time = parse_date(arg, 1);
2499 }
2500
2501 static void opt_rec_timestamp(const char *arg)
2502 {
2503     rec_timestamp = parse_date(arg, 0) / 1000000;
2504 }
2505
2506 static void opt_input_ts_offset(const char *arg)
2507 {
2508     input_ts_offset = parse_date(arg, 1);
2509 }
2510
2511 static void opt_input_file(const char *filename)
2512 {
2513     AVFormatContext *ic;
2514     AVFormatParameters params, *ap = &params;
2515     int err, i, ret, rfps, rfps_base;
2516     int64_t timestamp;
2517
2518     if (!strcmp(filename, "-"))
2519         filename = "pipe:";
2520
2521     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2522                    !strcmp( filename, "/dev/stdin" );
2523
2524     /* get default parameters from command line */
2525     ic = av_alloc_format_context();
2526
2527     memset(ap, 0, sizeof(*ap));
2528     ap->prealloced_context = 1;
2529     ap->sample_rate = audio_sample_rate;
2530     ap->channels = audio_channels;
2531     ap->time_base.den = frame_rate;
2532     ap->time_base.num = frame_rate_base;
2533     ap->width = frame_width + frame_padleft + frame_padright;
2534     ap->height = frame_height + frame_padtop + frame_padbottom;
2535     ap->pix_fmt = frame_pix_fmt;
2536     ap->channel = video_channel;
2537     ap->standard = video_standard;
2538     ap->video_codec_id = video_codec_id;
2539     ap->audio_codec_id = audio_codec_id;
2540     if(pgmyuv_compatibility_hack)
2541         ap->video_codec_id= CODEC_ID_PGMYUV;
2542
2543     for(i=0; i<opt_name_count; i++){
2544         const AVOption *opt;
2545         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2546         if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2547             av_set_double(ic, opt_names[i], d);
2548     }
2549     /* open the input file with generic libav function */
2550     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2551     if (err < 0) {
2552         print_error(filename, err);
2553         exit(1);
2554     }
2555
2556     ic->loop_input = loop_input;
2557
2558     /* If not enough info to get the stream parameters, we decode the
2559        first frames to get it. (used in mpeg case for example) */
2560     ret = av_find_stream_info(ic);
2561     if (ret < 0 && verbose >= 0) {
2562         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2563         exit(1);
2564     }
2565
2566     timestamp = start_time;
2567     /* add the stream start time */
2568     if (ic->start_time != AV_NOPTS_VALUE)
2569         timestamp += ic->start_time;
2570
2571     /* if seeking requested, we execute it */
2572     if (start_time != 0) {
2573         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2574         if (ret < 0) {
2575             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2576                     filename, (double)timestamp / AV_TIME_BASE);
2577         }
2578         /* reset seek info */
2579         start_time = 0;
2580     }
2581
2582     /* update the current parameters so that they match the one of the input stream */
2583     for(i=0;i<ic->nb_streams;i++) {
2584         int j;
2585         AVCodecContext *enc = ic->streams[i]->codec;
2586 #if defined(HAVE_THREADS)
2587         if(thread_count>1)
2588             avcodec_thread_init(enc, thread_count);
2589 #endif
2590         enc->thread_count= thread_count;
2591         switch(enc->codec_type) {
2592         case CODEC_TYPE_AUDIO:
2593             for(j=0; j<opt_name_count; j++){
2594                 const AVOption *opt;
2595                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2596                 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2597                     av_set_double(enc, opt_names[j], d);
2598             }
2599             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2600             audio_channels = enc->channels;
2601             audio_sample_rate = enc->sample_rate;
2602             if(audio_disable)
2603                 ic->streams[i]->discard= AVDISCARD_ALL;
2604             break;
2605         case CODEC_TYPE_VIDEO:
2606             for(j=0; j<opt_name_count; j++){
2607                 const AVOption *opt;
2608                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2609                 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2610                     av_set_double(enc, opt_names[j], d);
2611             }
2612             frame_height = enc->height;
2613             frame_width = enc->width;
2614             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2615             frame_pix_fmt = enc->pix_fmt;
2616             rfps      = ic->streams[i]->r_frame_rate.num;
2617             rfps_base = ic->streams[i]->r_frame_rate.den;
2618             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2619             if(me_threshold)
2620                 enc->debug |= FF_DEBUG_MV;
2621
2622             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2623
2624                 if (verbose >= 0)
2625                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2626                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2627
2628                     (float)rfps / rfps_base, rfps, rfps_base);
2629             }
2630             /* update the current frame rate to match the stream frame rate */
2631             frame_rate      = rfps;
2632             frame_rate_base = rfps_base;
2633
2634             enc->rate_emu = rate_emu;
2635             if(video_disable)
2636                 ic->streams[i]->discard= AVDISCARD_ALL;
2637             else if(video_discard)
2638                 ic->streams[i]->discard= video_discard;
2639             break;
2640         case CODEC_TYPE_DATA:
2641             break;
2642         case CODEC_TYPE_SUBTITLE:
2643             break;
2644         case CODEC_TYPE_UNKNOWN:
2645             break;
2646         default:
2647             av_abort();
2648         }
2649     }
2650
2651     input_files[nb_input_files] = ic;
2652     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2653     /* dump the file content */
2654     if (verbose >= 0)
2655         dump_format(ic, nb_input_files, filename, 0);
2656
2657     nb_input_files++;
2658     file_iformat = NULL;
2659     file_oformat = NULL;
2660
2661     video_channel = 0;
2662
2663     rate_emu = 0;
2664 }
2665
2666 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2667 {
2668     int has_video, has_audio, i, j;
2669     AVFormatContext *ic;
2670
2671     has_video = 0;
2672     has_audio = 0;
2673     for(j=0;j<nb_input_files;j++) {
2674         ic = input_files[j];
2675         for(i=0;i<ic->nb_streams;i++) {
2676             AVCodecContext *enc = ic->streams[i]->codec;
2677             switch(enc->codec_type) {
2678             case CODEC_TYPE_AUDIO:
2679                 has_audio = 1;
2680                 break;
2681             case CODEC_TYPE_VIDEO:
2682                 has_video = 1;
2683                 break;
2684             case CODEC_TYPE_DATA:
2685             case CODEC_TYPE_UNKNOWN:
2686             case CODEC_TYPE_SUBTITLE:
2687                 break;
2688             default:
2689                 av_abort();
2690             }
2691         }
2692     }
2693     *has_video_ptr = has_video;
2694     *has_audio_ptr = has_audio;
2695 }
2696
2697 static void new_video_stream(AVFormatContext *oc)
2698 {
2699     AVStream *st;
2700     AVCodecContext *video_enc;
2701     int codec_id;
2702
2703     st = av_new_stream(oc, oc->nb_streams);
2704     if (!st) {
2705         fprintf(stderr, "Could not alloc stream\n");
2706         exit(1);
2707     }
2708     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2709     video_bitstream_filters= NULL;
2710
2711 #if defined(HAVE_THREADS)
2712     if(thread_count>1)
2713         avcodec_thread_init(st->codec, thread_count);
2714 #endif
2715
2716     video_enc = st->codec;
2717
2718     if(video_codec_tag)
2719         video_enc->codec_tag= video_codec_tag;
2720
2721     if(   (video_global_header&1)
2722        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2723         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2724         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2725     }
2726     if(video_global_header&2){
2727         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2728         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2729     }
2730
2731     if (video_stream_copy) {
2732         st->stream_copy = 1;
2733         video_enc->codec_type = CODEC_TYPE_VIDEO;
2734     } else {
2735         char *p;
2736         int i;
2737         AVCodec *codec;
2738
2739         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2740         if (video_codec_id != CODEC_ID_NONE)
2741             codec_id = video_codec_id;
2742
2743         video_enc->codec_id = codec_id;
2744         codec = avcodec_find_encoder(codec_id);
2745
2746         for(i=0; i<opt_name_count; i++){
2747              const AVOption *opt;
2748              double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2749              if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2750                  av_set_double(video_enc, opt_names[i], d);
2751         }
2752
2753         video_enc->time_base.den = frame_rate;
2754         video_enc->time_base.num = frame_rate_base;
2755         if(codec && codec->supported_framerates){
2756             const AVRational *p= codec->supported_framerates;
2757             AVRational req= (AVRational){frame_rate, frame_rate_base};
2758             const AVRational *best=NULL;
2759             AVRational best_error= (AVRational){INT_MAX, 1};
2760             for(; p->den!=0; p++){
2761                 AVRational error= av_sub_q(req, *p);
2762                 if(error.num <0) error.num *= -1;
2763                 if(av_cmp_q(error, best_error) < 0){
2764                     best_error= error;
2765                     best= p;
2766                 }
2767             }
2768             video_enc->time_base.den= best->num;
2769             video_enc->time_base.num= best->den;
2770         }
2771
2772         video_enc->width = frame_width + frame_padright + frame_padleft;
2773         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2774         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2775         video_enc->pix_fmt = frame_pix_fmt;
2776
2777         if(codec && codec->pix_fmts){
2778             const enum PixelFormat *p= codec->pix_fmts;
2779             for(; *p!=-1; p++){
2780                 if(*p == video_enc->pix_fmt)
2781                     break;
2782             }
2783             if(*p == -1)
2784                 video_enc->pix_fmt = codec->pix_fmts[0];
2785         }
2786
2787         if (intra_only)
2788             video_enc->gop_size = 0;
2789         if (video_qscale || same_quality) {
2790             video_enc->flags |= CODEC_FLAG_QSCALE;
2791             video_enc->global_quality=
2792                 st->quality = FF_QP2LAMBDA * video_qscale;
2793         }
2794
2795         if(intra_matrix)
2796             video_enc->intra_matrix = intra_matrix;
2797         if(inter_matrix)
2798             video_enc->inter_matrix = inter_matrix;
2799
2800         video_enc->max_qdiff = video_qdiff;
2801         video_enc->rc_eq = video_rc_eq;
2802         video_enc->thread_count = thread_count;
2803         p= video_rc_override_string;
2804         for(i=0; p; i++){
2805             int start, end, q;
2806             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2807             if(e!=3){
2808                 fprintf(stderr, "error parsing rc_override\n");
2809                 exit(1);
2810             }
2811             video_enc->rc_override=
2812                 av_realloc(video_enc->rc_override,
2813                            sizeof(RcOverride)*(i+1));
2814             video_enc->rc_override[i].start_frame= start;
2815             video_enc->rc_override[i].end_frame  = end;
2816             if(q>0){
2817                 video_enc->rc_override[i].qscale= q;
2818                 video_enc->rc_override[i].quality_factor= 1.0;
2819             }
2820             else{
2821                 video_enc->rc_override[i].qscale= 0;
2822                 video_enc->rc_override[i].quality_factor= -q/100.0;
2823             }
2824             p= strchr(p, '/');
2825             if(p) p++;
2826         }
2827         video_enc->rc_override_count=i;
2828         if (!video_enc->rc_initial_buffer_occupancy)
2829             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2830         video_enc->me_threshold= me_threshold;
2831         video_enc->intra_dc_precision= intra_dc_precision - 8;
2832         video_enc->strict_std_compliance = strict;
2833
2834         if (do_psnr)
2835             video_enc->flags|= CODEC_FLAG_PSNR;
2836
2837         video_enc->me_method = me_method;
2838
2839         /* two pass mode */
2840         if (do_pass) {
2841             if (do_pass == 1) {
2842                 video_enc->flags |= CODEC_FLAG_PASS1;
2843             } else {
2844                 video_enc->flags |= CODEC_FLAG_PASS2;
2845             }
2846         }
2847     }
2848
2849     /* reset some key parameters */
2850     video_disable = 0;
2851     video_codec_id = CODEC_ID_NONE;
2852     video_stream_copy = 0;
2853 }
2854
2855 static void new_audio_stream(AVFormatContext *oc)
2856 {
2857     AVStream *st;
2858     AVCodecContext *audio_enc;
2859     int codec_id, i;
2860
2861     st = av_new_stream(oc, oc->nb_streams);
2862     if (!st) {
2863         fprintf(stderr, "Could not alloc stream\n");
2864         exit(1);
2865     }
2866
2867     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2868     audio_bitstream_filters= NULL;
2869
2870 #if defined(HAVE_THREADS)
2871     if(thread_count>1)
2872         avcodec_thread_init(st->codec, thread_count);
2873 #endif
2874
2875     audio_enc = st->codec;
2876     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2877     audio_enc->strict_std_compliance = strict;
2878
2879     if(audio_codec_tag)
2880         audio_enc->codec_tag= audio_codec_tag;
2881
2882     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2883         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2884         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2885     }
2886     if (audio_stream_copy) {
2887         st->stream_copy = 1;
2888         audio_enc->channels = audio_channels;
2889     } else {
2890         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2891
2892         for(i=0; i<opt_name_count; i++){
2893             const AVOption *opt;
2894             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2895             if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2896                 av_set_double(audio_enc, opt_names[i], d);
2897         }
2898
2899         if (audio_codec_id != CODEC_ID_NONE)
2900             codec_id = audio_codec_id;
2901         audio_enc->codec_id = codec_id;
2902
2903         if (audio_qscale > QSCALE_NONE) {
2904             audio_enc->flags |= CODEC_FLAG_QSCALE;
2905             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2906         }
2907         audio_enc->thread_count = thread_count;
2908         audio_enc->channels = audio_channels;
2909     }
2910     audio_enc->sample_rate = audio_sample_rate;
2911     audio_enc->time_base= (AVRational){1, audio_sample_rate};
2912     if (audio_language) {
2913         pstrcpy(st->language, sizeof(st->language), audio_language);
2914         av_free(audio_language);
2915         audio_language = NULL;
2916     }
2917
2918     /* reset some key parameters */
2919     audio_disable = 0;
2920     audio_codec_id = CODEC_ID_NONE;
2921     audio_stream_copy = 0;
2922 }
2923
2924 static void opt_new_subtitle_stream(void)
2925 {
2926     AVFormatContext *oc;
2927     AVStream *st;
2928     AVCodecContext *subtitle_enc;
2929     int i;
2930
2931     if (nb_output_files <= 0) {
2932         fprintf(stderr, "At least one output file must be specified\n");
2933         exit(1);
2934     }
2935     oc = output_files[nb_output_files - 1];
2936
2937     st = av_new_stream(oc, oc->nb_streams);
2938     if (!st) {
2939         fprintf(stderr, "Could not alloc stream\n");
2940         exit(1);
2941     }
2942
2943     subtitle_enc = st->codec;
2944     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2945     if (subtitle_stream_copy) {
2946         st->stream_copy = 1;
2947     } else {
2948         for(i=0; i<opt_name_count; i++){
2949              const AVOption *opt;
2950              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2951              if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2952                  av_set_double(subtitle_enc, opt_names[i], d);
2953         }
2954         subtitle_enc->codec_id = subtitle_codec_id;
2955     }
2956
2957     if (subtitle_language) {
2958         pstrcpy(st->language, sizeof(st->language), subtitle_language);
2959         av_free(subtitle_language);
2960         subtitle_language = NULL;
2961     }
2962
2963     subtitle_codec_id = CODEC_ID_NONE;
2964     subtitle_stream_copy = 0;
2965 }
2966
2967 static void opt_new_audio_stream(void)
2968 {
2969     AVFormatContext *oc;
2970     if (nb_output_files <= 0) {
2971         fprintf(stderr, "At least one output file must be specified\n");
2972         exit(1);
2973     }
2974     oc = output_files[nb_output_files - 1];
2975     new_audio_stream(oc);
2976 }
2977
2978 static void opt_new_video_stream(void)
2979 {
2980     AVFormatContext *oc;
2981     if (nb_output_files <= 0) {
2982         fprintf(stderr, "At least one output file must be specified\n");
2983         exit(1);
2984     }
2985     oc = output_files[nb_output_files - 1];
2986     new_video_stream(oc);
2987 }
2988
2989 static void opt_output_file(const char *filename)
2990 {
2991     AVFormatContext *oc;
2992     int use_video, use_audio, input_has_video, input_has_audio, i;
2993     AVFormatParameters params, *ap = &params;
2994
2995     if (!strcmp(filename, "-"))
2996         filename = "pipe:";
2997
2998     oc = av_alloc_format_context();
2999
3000     if (!file_oformat) {
3001         file_oformat = guess_format(NULL, filename, NULL);
3002         if (!file_oformat) {
3003             fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3004                     filename);
3005             exit(1);
3006         }
3007     }
3008
3009     oc->oformat = file_oformat;
3010     pstrcpy(oc->filename, sizeof(oc->filename), filename);
3011
3012     if (!strcmp(file_oformat->name, "ffm") &&
3013         strstart(filename, "http:", NULL)) {
3014         /* special case for files sent to ffserver: we get the stream
3015            parameters from ffserver */
3016         if (read_ffserver_streams(oc, filename) < 0) {
3017             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3018             exit(1);
3019         }
3020     } else {
3021         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3022         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3023
3024         /* disable if no corresponding type found and at least one
3025            input file */
3026         if (nb_input_files > 0) {
3027             check_audio_video_inputs(&input_has_video, &input_has_audio);
3028             if (!input_has_video)
3029                 use_video = 0;
3030             if (!input_has_audio)
3031                 use_audio = 0;
3032         }
3033
3034         /* manual disable */
3035         if (audio_disable) {
3036             use_audio = 0;
3037         }
3038         if (video_disable) {
3039             use_video = 0;
3040         }
3041
3042         if (use_video) {
3043             new_video_stream(oc);
3044         }
3045
3046         if (use_audio) {
3047             new_audio_stream(oc);
3048         }
3049
3050         oc->timestamp = rec_timestamp;
3051
3052         if (str_title)
3053             pstrcpy(oc->title, sizeof(oc->title), str_title);
3054         if (str_author)
3055             pstrcpy(oc->author, sizeof(oc->author), str_author);
3056         if (str_copyright)
3057             pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3058         if (str_comment)
3059             pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3060         if (str_album)
3061             pstrcpy(oc->album, sizeof(oc->album), str_album);
3062     }
3063
3064     output_files[nb_output_files++] = oc;
3065
3066     /* check filename in case of an image number is expected */
3067     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3068         if (!av_filename_number_test(oc->filename)) {
3069             print_error(oc->filename, AVERROR_NUMEXPECTED);
3070             exit(1);
3071         }
3072     }
3073
3074     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3075         /* test if it already exists to avoid loosing precious files */
3076         if (!file_overwrite &&
3077             (strchr(filename, ':') == NULL ||
3078              strstart(filename, "file:", NULL))) {
3079             if (url_exist(filename)) {
3080                 int c;
3081
3082                 if ( !using_stdin ) {
3083                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3084                     fflush(stderr);
3085                     c = getchar();
3086                     if (toupper(c) != 'Y') {
3087                         fprintf(stderr, "Not overwriting - exiting\n");
3088                         exit(1);
3089                     }
3090                                 }
3091                                 else {
3092                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3093                     exit(1);
3094                                 }
3095             }
3096         }
3097
3098         /* open the file */
3099         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3100             fprintf(stderr, "Could not open '%s'\n", filename);
3101             exit(1);
3102         }
3103     }
3104
3105     memset(ap, 0, sizeof(*ap));
3106     if (av_set_parameters(oc, ap) < 0) {
3107         fprintf(stderr, "%s: Invalid encoding parameters\n",
3108                 oc->filename);
3109         exit(1);
3110     }
3111
3112     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3113     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3114     oc->loop_output = loop_output;
3115
3116     for(i=0; i<opt_name_count; i++){
3117         const AVOption *opt;
3118         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3119         if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3120             av_set_double(oc, opt_names[i], d);
3121     }
3122
3123     /* reset some options */
3124     file_oformat = NULL;
3125     file_iformat = NULL;
3126 }
3127
3128 /* same option as mencoder */
3129 static void opt_pass(const char *pass_str)
3130 {
3131     int pass;
3132     pass = atoi(pass_str);
3133     if (pass != 1 && pass != 2) {
3134         fprintf(stderr, "pass number can be only 1 or 2\n");
3135         exit(1);
3136     }
3137     do_pass = pass;
3138 }
3139
3140 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3141 static int64_t getutime(void)
3142 {
3143   return av_gettime();
3144 }
3145 #else
3146 static int64_t getutime(void)
3147 {
3148     struct rusage rusage;
3149
3150     getrusage(RUSAGE_SELF, &rusage);
3151     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3152 }
3153 #endif
3154
3155 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3156 extern int ffm_nopts;
3157 #endif
3158
3159 static void show_formats(void)
3160 {
3161     AVInputFormat *ifmt;
3162     AVOutputFormat *ofmt;
3163     URLProtocol *up;
3164     AVCodec *p, *p2;
3165     const char **pp, *last_name;
3166
3167     printf("File formats:\n");
3168     last_name= "000";
3169     for(;;){
3170         int decode=0;
3171         int encode=0;
3172         const char *name=NULL;
3173         const char *long_name=NULL;
3174
3175         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3176             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3177                 strcmp(ofmt->name, last_name)>0){
3178                 name= ofmt->name;
3179                 long_name= ofmt->long_name;
3180                 encode=1;
3181             }
3182         }
3183         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3184             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3185                 strcmp(ifmt->name, last_name)>0){
3186                 name= ifmt->name;
3187                 long_name= ifmt->long_name;
3188                 encode=0;
3189             }
3190             if(name && strcmp(ifmt->name, name)==0)
3191                 decode=1;
3192         }
3193         if(name==NULL)
3194             break;
3195         last_name= name;
3196
3197         printf(
3198             " %s%s %-15s %s\n",
3199             decode ? "D":" ",
3200             encode ? "E":" ",
3201             name,
3202             long_name ? long_name:" ");
3203     }
3204     printf("\n");
3205
3206     printf("Codecs:\n");
3207     last_name= "000";
3208     for(;;){
3209         int decode=0;
3210         int encode=0;
3211         int cap=0;
3212         const char *type_str;
3213
3214         p2=NULL;
3215         for(p = first_avcodec; p != NULL; p = p->next) {
3216             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3217                 strcmp(p->name, last_name)>0){
3218                 p2= p;
3219                 decode= encode= cap=0;
3220             }
3221             if(p2 && strcmp(p->name, p2->name)==0){
3222                 if(p->decode) decode=1;
3223                 if(p->encode) encode=1;
3224                 cap |= p->capabilities;
3225             }
3226         }
3227         if(p2==NULL)
3228             break;
3229         last_name= p2->name;
3230
3231         switch(p2->type) {
3232         case CODEC_TYPE_VIDEO:
3233             type_str = "V";
3234             break;
3235         case CODEC_TYPE_AUDIO:
3236             type_str = "A";
3237             break;
3238         case CODEC_TYPE_SUBTITLE:
3239             type_str = "S";
3240             break;
3241         default:
3242             type_str = "?";
3243             break;
3244         }
3245         printf(
3246             " %s%s%s%s%s%s %s",
3247             decode ? "D": (/*p2->decoder ? "d":*/" "),
3248             encode ? "E":" ",
3249             type_str,
3250             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3251             cap & CODEC_CAP_DR1 ? "D":" ",
3252             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3253             p2->name);
3254        /* if(p2->decoder && decode==0)
3255             printf(" use %s for decoding", p2->decoder->name);*/
3256         printf("\n");
3257     }
3258     printf("\n");
3259
3260     printf("Supported file protocols:\n");
3261     for(up = first_protocol; up != NULL; up = up->next)
3262         printf(" %s:", up->name);
3263     printf("\n");
3264
3265     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3266     printf("Motion estimation methods:\n");
3267     pp = motion_str;
3268     while (*pp) {
3269         printf(" %s", *pp);
3270         if ((pp - motion_str + 1) == ME_ZERO)
3271             printf("(fastest)");
3272         else if ((pp - motion_str + 1) == ME_FULL)
3273             printf("(slowest)");
3274         else if ((pp - motion_str + 1) == ME_EPZS)
3275             printf("(default)");
3276         pp++;
3277     }
3278     printf("\n\n");
3279     printf(
3280 "Note, the names of encoders and decoders dont always match, so there are\n"
3281 "several cases where the above table shows encoder only or decoder only entries\n"
3282 "even though both encoding and decoding are supported for example, the h263\n"
3283 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3284 "worse\n");
3285     exit(1);
3286 }
3287
3288 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3289 {
3290     int i;
3291     const char *p = str;
3292     for(i = 0;; i++) {
3293         dest[i] = atoi(p);
3294         if(i == 63)
3295             break;
3296         p = strchr(p, ',');
3297         if(!p) {
3298             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3299             exit(1);
3300         }
3301         p++;
3302     }
3303 }
3304
3305 static void opt_inter_matrix(const char *arg)
3306 {
3307     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3308     parse_matrix_coeffs(inter_matrix, arg);
3309 }
3310
3311 static void opt_intra_matrix(const char *arg)
3312 {
3313     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3314     parse_matrix_coeffs(intra_matrix, arg);
3315 }
3316
3317 static void opt_target(const char *arg)
3318 {
3319     int norm = -1;
3320     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3321
3322     if(!strncmp(arg, "pal-", 4)) {
3323         norm = 0;
3324         arg += 4;
3325     } else if(!strncmp(arg, "ntsc-", 5)) {
3326         norm = 1;
3327         arg += 5;
3328     } else if(!strncmp(arg, "film-", 5)) {
3329         norm = 2;
3330         arg += 5;
3331     } else {
3332         int fr;
3333         /* Calculate FR via float to avoid int overflow */
3334         fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3335         if(fr == 25000) {
3336             norm = 0;
3337         } else if((fr == 29970) || (fr == 23976)) {
3338             norm = 1;
3339         } else {
3340             /* Try to determine PAL/NTSC by peeking in the input files */
3341             if(nb_input_files) {
3342                 int i, j;
3343                 for(j = 0; j < nb_input_files; j++) {
3344                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3345                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3346                         if(c->codec_type != CODEC_TYPE_VIDEO)
3347                             continue;
3348                         fr = c->time_base.den * 1000 / c->time_base.num;
3349                         if(fr == 25000) {
3350                             norm = 0;
3351                             break;
3352                         } else if((fr == 29970) || (fr == 23976)) {
3353                             norm = 1;
3354                             break;
3355                         }
3356                     }
3357                     if(norm >= 0)
3358                         break;
3359                 }
3360             }
3361         }
3362         if(verbose && norm >= 0)
3363             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3364     }
3365
3366     if(norm < 0) {
3367         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3368         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3369         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3370         exit(1);
3371     }
3372
3373     if(!strcmp(arg, "vcd")) {
3374
3375         opt_video_codec("mpeg1video");
3376         opt_audio_codec("mp2");
3377         opt_format("vcd");
3378
3379         opt_frame_size(norm ? "352x240" : "352x288");
3380         opt_frame_rate(frame_rates[norm]);
3381         opt_default("gop", norm ? "18" : "15");
3382
3383         opt_default("b", "1150000");
3384         opt_default("maxrate", "1150000");
3385         opt_default("minrate", "1150000");
3386         opt_default("bufsize", "327680"); // 40*1024*8;
3387
3388         opt_default("ab", "224000");
3389         audio_sample_rate = 44100;
3390         audio_channels = 2;
3391
3392         opt_default("packetsize", "2324");
3393         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3394
3395         /* We have to offset the PTS, so that it is consistent with the SCR.
3396            SCR starts at 36000, but the first two packs contain only padding
3397            and the first pack from the other stream, respectively, may also have
3398            been written before.
3399            So the real data starts at SCR 36000+3*1200. */
3400         mux_preload= (36000+3*1200) / 90000.0; //0.44
3401     } else if(!strcmp(arg, "svcd")) {
3402
3403         opt_video_codec("mpeg2video");
3404         opt_audio_codec("mp2");
3405         opt_format("svcd");
3406
3407         opt_frame_size(norm ? "480x480" : "480x576");
3408         opt_frame_rate(frame_rates[norm]);
3409         opt_default("gop", norm ? "18" : "15");
3410
3411         opt_default("b", "2040000");
3412         opt_default("maxrate", "2516000");
3413         opt_default("minrate", "0"); //1145000;
3414         opt_default("bufsize", "1835008"); //224*1024*8;
3415         opt_default("flags", "+SCAN_OFFSET");
3416
3417
3418         opt_default("ab", "224000");
3419         audio_sample_rate = 44100;
3420
3421         opt_default("packetsize", "2324");
3422
3423     } else if(!strcmp(arg, "dvd")) {
3424
3425         opt_video_codec("mpeg2video");
3426         opt_audio_codec("ac3");
3427         opt_format("dvd");
3428
3429         opt_frame_size(norm ? "720x480" : "720x576");
3430         opt_frame_rate(frame_rates[norm]);
3431         opt_default("gop", norm ? "18" : "15");
3432
3433         opt_default("b", "6000000");
3434         opt_default("maxrate", "9000000");
3435         opt_default("minrate", "0"); //1500000;
3436         opt_default("bufsize", "1835008"); //224*1024*8;
3437
3438         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3439         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3440
3441         opt_default("ab", "448000");
3442         audio_sample_rate = 48000;
3443
3444     } else if(!strncmp(arg, "dv", 2)) {
3445
3446         opt_format("dv");
3447
3448         opt_frame_size(norm ? "720x480" : "720x576");
3449         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3450                                              (norm ? "yuv411p" : "yuv420p"));
3451         opt_frame_rate(frame_rates[norm]);
3452
3453         audio_sample_rate = 48000;
3454         audio_channels = 2;
3455
3456     } else {
3457         fprintf(stderr, "Unknown target: %s\n", arg);
3458         exit(1);
3459     }
3460 }
3461
3462 static void opt_video_bsf(const char *arg)
3463 {
3464     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3465     AVBitStreamFilterContext **bsfp;
3466
3467     if(!bsfc){
3468         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3469         exit(1);
3470     }
3471
3472     bsfp= &video_bitstream_filters;
3473     while(*bsfp)
3474         bsfp= &(*bsfp)->next;
3475
3476     *bsfp= bsfc;
3477 }
3478
3479 //FIXME avoid audio - video code duplication
3480 static void opt_audio_bsf(const char *arg)
3481 {
3482     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3483     AVBitStreamFilterContext **bsfp;
3484
3485     if(!bsfc){
3486         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3487         exit(1);
3488     }
3489
3490     bsfp= &audio_bitstream_filters;
3491     while(*bsfp)
3492         bsfp= &(*bsfp)->next;
3493
3494     *bsfp= bsfc;
3495 }
3496
3497 static void show_version(void)
3498 {
3499     /* TODO: add function interface to avutil and avformat */
3500     fprintf(stderr, "ffmpeg      " FFMPEG_VERSION "\n"
3501            "libavutil   %d\n"
3502            "libavcodec  %d\n"
3503            "libavformat %d\n",
3504            LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3505     exit(1);
3506 }
3507
3508 static int opt_default(const char *opt, const char *arg){
3509     int type;
3510     const AVOption *o= NULL;
3511     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3512
3513     for(type=0; type<CODEC_TYPE_NB; type++){
3514         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3515         if(o2)
3516             o = av_set_string(avctx_opts[type], opt, arg);
3517     }
3518     if(!o)
3519         o = av_set_string(avformat_opts, opt, arg);
3520     if(!o){
3521         if(opt[0] == 'a')
3522             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3523         else if(opt[0] == 'v')
3524             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3525         else if(opt[0] == 's')
3526             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3527     }
3528     if(!o)
3529         return -1;
3530
3531 //    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));
3532
3533     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3534     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3535     opt_names[opt_name_count++]= o->name;
3536
3537 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3538     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3539     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3540         ffm_nopts = 1;
3541 #endif
3542
3543     if(avctx_opts[0]->debug)
3544         av_log_level = AV_LOG_DEBUG;
3545     return 0;
3546 }
3547
3548 const OptionDef options[] = {
3549     /* main options */
3550     { "L", 0, {(void*)show_license}, "show license" },
3551     { "h", 0, {(void*)show_help}, "show help" },
3552     { "version", 0, {(void*)show_version}, "show version" },
3553     { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3554     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3555     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3556     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3557     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3558     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3559     { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3560     { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3561     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3562     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3563     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3564     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3565     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3566     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3567     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3568     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3569     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3570       "add timings for benchmarking" },
3571     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3572       "dump each input packet" },
3573     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3574       "when dumping packets, also dump the payload" },
3575     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3576     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3577     { "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)", "" },
3578     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3579     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3580     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3581     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3582     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3583     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3584     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3585     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3586     { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3587
3588     /* video options */
3589     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3590     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3591     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3592     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3593     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3594     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3595     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3596     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3597     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3598     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3599     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3600     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3601     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3602     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3603     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3604     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3605     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3606     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3607     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3608     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3609     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3610     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3611     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3612     { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3613       "method" },
3614     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3615     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3616     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3617       "use same video quality as source (implies VBR)" },
3618     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3619     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3620     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3621       "deinterlace pictures" },
3622     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3623     { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to 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_context();
3769     avformat_opts = av_alloc_format_context();
3770
3771     if (argc <= 1)
3772         show_help();
3773     else
3774         show_banner();
3775
3776     /* parse options */
3777     parse_options(argc, argv, options);
3778
3779     /* file converter / grab */
3780     if (nb_output_files <= 0) {
3781         fprintf(stderr, "Must supply at least one output file\n");
3782         exit(1);
3783     }
3784
3785     if (nb_input_files == 0) {
3786         fprintf(stderr, "Must supply at least one input file\n");
3787         exit(1);
3788     }
3789
3790     ti = getutime();
3791     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3792               stream_maps, nb_stream_maps);
3793     ti = getutime() - ti;
3794     if (do_benchmark) {
3795         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3796     }
3797
3798     /* close files */
3799     for(i=0;i<nb_output_files;i++) {
3800         /* maybe av_close_output_file ??? */
3801         AVFormatContext *s = output_files[i];
3802         int j;
3803         if (!(s->oformat->flags & AVFMT_NOFILE))
3804             url_fclose(&s->pb);
3805         for(j=0;j<s->nb_streams;j++) {
3806             av_free(s->streams[j]->codec);
3807             av_free(s->streams[j]);
3808         }
3809         av_free(s);
3810     }
3811     for(i=0;i<nb_input_files;i++)
3812         av_close_input_file(input_files[i]);
3813
3814     av_free_static();
3815
3816     av_free(intra_matrix);
3817     av_free(inter_matrix);
3818     av_free(opt_names);
3819
3820 #ifdef CONFIG_POWERPC_PERF
3821     extern void powerpc_display_perf_report(void);
3822     powerpc_display_perf_report();
3823 #endif /* CONFIG_POWERPC_PERF */
3824
3825     if (received_sigterm) {
3826         fprintf(stderr,
3827             "Received signal %d: terminating.\n",
3828             (int) received_sigterm);
3829         exit (255);
3830     }
3831
3832     exit(0); /* not all OS-es handle main() return value */
3833     return 0;
3834 }