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