check av_interleaved_write_frame() return
[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_frame_crop_top(const char *arg)
2163 {
2164     frame_topBand = atoi(arg);
2165     if (frame_topBand < 0) {
2166         fprintf(stderr, "Incorrect top crop size\n");
2167         exit(1);
2168     }
2169     if ((frame_topBand % 2) != 0) {
2170         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2171         exit(1);
2172     }
2173     if ((frame_topBand) >= frame_height){
2174         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2175         exit(1);
2176     }
2177     frame_height -= frame_topBand;
2178 }
2179
2180 static void opt_frame_crop_bottom(const char *arg)
2181 {
2182     frame_bottomBand = atoi(arg);
2183     if (frame_bottomBand < 0) {
2184         fprintf(stderr, "Incorrect bottom crop size\n");
2185         exit(1);
2186     }
2187     if ((frame_bottomBand % 2) != 0) {
2188         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2189         exit(1);
2190     }
2191     if ((frame_bottomBand) >= frame_height){
2192         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2193         exit(1);
2194     }
2195     frame_height -= frame_bottomBand;
2196 }
2197
2198 static void opt_frame_crop_left(const char *arg)
2199 {
2200     frame_leftBand = atoi(arg);
2201     if (frame_leftBand < 0) {
2202         fprintf(stderr, "Incorrect left crop size\n");
2203         exit(1);
2204     }
2205     if ((frame_leftBand % 2) != 0) {
2206         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2207         exit(1);
2208     }
2209     if ((frame_leftBand) >= frame_width){
2210         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2211         exit(1);
2212     }
2213     frame_width -= frame_leftBand;
2214 }
2215
2216 static void opt_frame_crop_right(const char *arg)
2217 {
2218     frame_rightBand = atoi(arg);
2219     if (frame_rightBand < 0) {
2220         fprintf(stderr, "Incorrect right crop size\n");
2221         exit(1);
2222     }
2223     if ((frame_rightBand % 2) != 0) {
2224         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2225         exit(1);
2226     }
2227     if ((frame_rightBand) >= frame_width){
2228         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2229         exit(1);
2230     }
2231     frame_width -= frame_rightBand;
2232 }
2233
2234 static void opt_frame_size(const char *arg)
2235 {
2236     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2237         fprintf(stderr, "Incorrect frame size\n");
2238         exit(1);
2239     }
2240     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2241         fprintf(stderr, "Frame size must be a multiple of 2\n");
2242         exit(1);
2243     }
2244 }
2245
2246
2247 #define SCALEBITS 10
2248 #define ONE_HALF  (1 << (SCALEBITS - 1))
2249 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2250
2251 #define RGB_TO_Y(r, g, b) \
2252 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2253   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2254
2255 #define RGB_TO_U(r1, g1, b1, shift)\
2256 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2257      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2258
2259 #define RGB_TO_V(r1, g1, b1, shift)\
2260 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2261    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2262
2263 static void opt_pad_color(const char *arg) {
2264     /* Input is expected to be six hex digits similar to
2265        how colors are expressed in html tags (but without the #) */
2266     int rgb = strtol(arg, NULL, 16);
2267     int r,g,b;
2268
2269     r = (rgb >> 16);
2270     g = ((rgb >> 8) & 255);
2271     b = (rgb & 255);
2272
2273     padcolor[0] = RGB_TO_Y(r,g,b);
2274     padcolor[1] = RGB_TO_U(r,g,b,0);
2275     padcolor[2] = RGB_TO_V(r,g,b,0);
2276 }
2277
2278 static void opt_frame_pad_top(const char *arg)
2279 {
2280     frame_padtop = atoi(arg);
2281     if (frame_padtop < 0) {
2282         fprintf(stderr, "Incorrect top pad size\n");
2283         exit(1);
2284     }
2285     if ((frame_padtop % 2) != 0) {
2286         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2287         exit(1);
2288     }
2289 }
2290
2291 static void opt_frame_pad_bottom(const char *arg)
2292 {
2293     frame_padbottom = atoi(arg);
2294     if (frame_padbottom < 0) {
2295         fprintf(stderr, "Incorrect bottom pad size\n");
2296         exit(1);
2297     }
2298     if ((frame_padbottom % 2) != 0) {
2299         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2300         exit(1);
2301     }
2302 }
2303
2304
2305 static void opt_frame_pad_left(const char *arg)
2306 {
2307     frame_padleft = atoi(arg);
2308     if (frame_padleft < 0) {
2309         fprintf(stderr, "Incorrect left pad size\n");
2310         exit(1);
2311     }
2312     if ((frame_padleft % 2) != 0) {
2313         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2314         exit(1);
2315     }
2316 }
2317
2318
2319 static void opt_frame_pad_right(const char *arg)
2320 {
2321     frame_padright = atoi(arg);
2322     if (frame_padright < 0) {
2323         fprintf(stderr, "Incorrect right pad size\n");
2324         exit(1);
2325     }
2326     if ((frame_padright % 2) != 0) {
2327         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2328         exit(1);
2329     }
2330 }
2331
2332 void list_pix_fmts(void)
2333 {
2334     int i;
2335     char pix_fmt_str[128];
2336     for (i=-1; i < PIX_FMT_NB; i++) {
2337         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2338         fprintf(stdout, "%s\n", pix_fmt_str);
2339     }
2340 }
2341
2342 static void opt_frame_pix_fmt(const char *arg)
2343 {
2344     if (strcmp(arg, "list"))
2345         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2346     else {
2347         list_pix_fmts();
2348         exit(0);
2349     }
2350 }
2351
2352 static void opt_frame_aspect_ratio(const char *arg)
2353 {
2354     int x = 0, y = 0;
2355     double ar = 0;
2356     const char *p;
2357
2358     p = strchr(arg, ':');
2359     if (p) {
2360         x = strtol(arg, (char **)&arg, 10);
2361         if (arg == p)
2362             y = strtol(arg+1, (char **)&arg, 10);
2363         if (x > 0 && y > 0)
2364             ar = (double)x / (double)y;
2365     } else
2366         ar = strtod(arg, (char **)&arg);
2367
2368     if (!ar) {
2369         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2370         exit(1);
2371     }
2372     frame_aspect_ratio = ar;
2373 }
2374
2375 static void opt_qscale(const char *arg)
2376 {
2377     video_qscale = atof(arg);
2378     if (video_qscale <= 0 ||
2379         video_qscale > 255) {
2380         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2381         exit(1);
2382     }
2383 }
2384
2385 static void opt_qdiff(const char *arg)
2386 {
2387     video_qdiff = atoi(arg);
2388     if (video_qdiff < 0 ||
2389         video_qdiff > 31) {
2390         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2391         exit(1);
2392     }
2393 }
2394
2395 static void opt_strict(const char *arg)
2396 {
2397     strict= atoi(arg);
2398 }
2399
2400 static void opt_top_field_first(const char *arg)
2401 {
2402     top_field_first= atoi(arg);
2403 }
2404
2405 static void opt_thread_count(const char *arg)
2406 {
2407     thread_count= atoi(arg);
2408 #if !defined(HAVE_THREADS)
2409     if (verbose >= 0)
2410         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2411 #endif
2412 }
2413
2414 static void opt_audio_rate(const char *arg)
2415 {
2416     audio_sample_rate = atoi(arg);
2417 }
2418
2419 static void opt_audio_channels(const char *arg)
2420 {
2421     audio_channels = atoi(arg);
2422 }
2423
2424 static void opt_video_channel(const char *arg)
2425 {
2426     video_channel = strtol(arg, NULL, 0);
2427 }
2428
2429 static void opt_video_standard(const char *arg)
2430 {
2431     video_standard = av_strdup(arg);
2432 }
2433
2434 static void opt_codec(int *pstream_copy, char **pcodec_name,
2435                       int codec_type, const char *arg)
2436 {
2437     av_freep(pcodec_name);
2438     if (!strcmp(arg, "copy")) {
2439         *pstream_copy = 1;
2440     } else {
2441         *pcodec_name = av_strdup(arg);
2442     }
2443 }
2444
2445 static void opt_audio_codec(const char *arg)
2446 {
2447     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2448 }
2449
2450 static void opt_audio_tag(const char *arg)
2451 {
2452     char *tail;
2453     audio_codec_tag= strtol(arg, &tail, 0);
2454
2455     if(!tail || *tail)
2456         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2457 }
2458
2459 static void opt_video_tag(const char *arg)
2460 {
2461     char *tail;
2462     video_codec_tag= strtol(arg, &tail, 0);
2463
2464     if(!tail || *tail)
2465         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2466 }
2467
2468 #ifdef CONFIG_VHOOK
2469 static void add_frame_hooker(const char *arg)
2470 {
2471     int argc = 0;
2472     char *argv[64];
2473     int i;
2474     char *args = av_strdup(arg);
2475
2476     using_vhook = 1;
2477
2478     argv[0] = strtok(args, " ");
2479     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2480     }
2481
2482     i = frame_hook_add(argc, argv);
2483
2484     if (i != 0) {
2485         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2486         exit(1);
2487     }
2488 }
2489 #endif
2490
2491 static void opt_video_codec(const char *arg)
2492 {
2493     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2494 }
2495
2496 static void opt_subtitle_codec(const char *arg)
2497 {
2498     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2499 }
2500
2501 static void opt_map(const char *arg)
2502 {
2503     AVStreamMap *m;
2504     const char *p;
2505
2506     p = arg;
2507     m = &stream_maps[nb_stream_maps++];
2508
2509     m->file_index = strtol(arg, (char **)&p, 0);
2510     if (*p)
2511         p++;
2512
2513     m->stream_index = strtol(p, (char **)&p, 0);
2514     if (*p) {
2515         p++;
2516         m->sync_file_index = strtol(p, (char **)&p, 0);
2517         if (*p)
2518             p++;
2519         m->sync_stream_index = strtol(p, (char **)&p, 0);
2520     } else {
2521         m->sync_file_index = m->file_index;
2522         m->sync_stream_index = m->stream_index;
2523     }
2524 }
2525
2526 static void opt_map_meta_data(const char *arg)
2527 {
2528     AVMetaDataMap *m;
2529     const char *p;
2530
2531     p = arg;
2532     m = &meta_data_maps[nb_meta_data_maps++];
2533
2534     m->out_file = strtol(arg, (char **)&p, 0);
2535     if (*p)
2536         p++;
2537
2538     m->in_file = strtol(p, (char **)&p, 0);
2539 }
2540
2541 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2542 {
2543     int64_t us = parse_date(timestr, is_duration);
2544     if (us == INT64_MIN) {
2545         fprintf(stderr, "Invalid %s specification: %s\n",
2546                 is_duration ? "duration" : "date", timestr);
2547         exit(1);
2548     }
2549     return us;
2550 }
2551
2552 static void opt_recording_time(const char *arg)
2553 {
2554     recording_time = parse_time_or_die(arg, 1);
2555 }
2556
2557 static void opt_start_time(const char *arg)
2558 {
2559     start_time = parse_time_or_die(arg, 1);
2560 }
2561
2562 static void opt_rec_timestamp(const char *arg)
2563 {
2564     rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2565 }
2566
2567 static void opt_input_ts_offset(const char *arg)
2568 {
2569     input_ts_offset = parse_time_or_die(arg, 1);
2570 }
2571
2572 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2573 {
2574     char *codec_string = encoder ? "encoder" : "decoder";
2575     AVCodec *codec;
2576
2577     if(!name)
2578         return CODEC_ID_NONE;
2579     codec = encoder ?
2580         avcodec_find_encoder_by_name(name) :
2581         avcodec_find_decoder_by_name(name);
2582     if(!codec) {
2583         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2584         exit(1);
2585     }
2586     if(codec->type != type) {
2587         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2588         exit(1);
2589     }
2590     return codec->id;
2591 }
2592
2593 static void opt_input_file(const char *filename)
2594 {
2595     AVFormatContext *ic;
2596     AVFormatParameters params, *ap = &params;
2597     int err, i, ret, rfps, rfps_base;
2598     int64_t timestamp;
2599
2600     if (!strcmp(filename, "-"))
2601         filename = "pipe:";
2602
2603     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2604                    !strcmp( filename, "/dev/stdin" );
2605
2606     /* get default parameters from command line */
2607     ic = av_alloc_format_context();
2608
2609     memset(ap, 0, sizeof(*ap));
2610     ap->prealloced_context = 1;
2611     ap->sample_rate = audio_sample_rate;
2612     ap->channels = audio_channels;
2613     ap->time_base.den = frame_rate.num;
2614     ap->time_base.num = frame_rate.den;
2615     ap->width = frame_width + frame_padleft + frame_padright;
2616     ap->height = frame_height + frame_padtop + frame_padbottom;
2617     ap->pix_fmt = frame_pix_fmt;
2618     ap->channel = video_channel;
2619     ap->standard = video_standard;
2620     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2621     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2622     if(pgmyuv_compatibility_hack)
2623         ap->video_codec_id= CODEC_ID_PGMYUV;
2624
2625     for(i=0; i<opt_name_count; i++){
2626         const AVOption *opt;
2627         double d= av_get_double(avformat_opts, opt_names[i], &opt);
2628         if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2629             av_set_double(ic, opt_names[i], d);
2630     }
2631     /* open the input file with generic libav function */
2632     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2633     if (err < 0) {
2634         print_error(filename, err);
2635         exit(1);
2636     }
2637     if(opt_programid) {
2638         int i;
2639         for(i=0; i<ic->nb_programs; i++)
2640             if(ic->programs[i]->id != opt_programid)
2641                 ic->programs[i]->discard = AVDISCARD_ALL;
2642     }
2643
2644     ic->loop_input = loop_input;
2645
2646     /* If not enough info to get the stream parameters, we decode the
2647        first frames to get it. (used in mpeg case for example) */
2648     ret = av_find_stream_info(ic);
2649     if (ret < 0 && verbose >= 0) {
2650         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2651         exit(1);
2652     }
2653
2654     timestamp = start_time;
2655     /* add the stream start time */
2656     if (ic->start_time != AV_NOPTS_VALUE)
2657         timestamp += ic->start_time;
2658
2659     /* if seeking requested, we execute it */
2660     if (start_time != 0) {
2661         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2662         if (ret < 0) {
2663             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2664                     filename, (double)timestamp / AV_TIME_BASE);
2665         }
2666         /* reset seek info */
2667         start_time = 0;
2668     }
2669
2670     /* update the current parameters so that they match the one of the input stream */
2671     for(i=0;i<ic->nb_streams;i++) {
2672         int j;
2673         AVCodecContext *enc = ic->streams[i]->codec;
2674         if(thread_count>1)
2675             avcodec_thread_init(enc, thread_count);
2676         enc->thread_count= thread_count;
2677         switch(enc->codec_type) {
2678         case CODEC_TYPE_AUDIO:
2679             for(j=0; j<opt_name_count; j++){
2680                 const AVOption *opt;
2681                 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2682                 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2683                     av_set_double(enc, opt_names[j], d);
2684             }
2685             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2686             audio_channels = enc->channels;
2687             audio_sample_rate = enc->sample_rate;
2688             if(audio_disable)
2689                 ic->streams[i]->discard= AVDISCARD_ALL;
2690             break;
2691         case CODEC_TYPE_VIDEO:
2692             for(j=0; j<opt_name_count; j++){
2693                 const AVOption *opt;
2694                 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2695                 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2696                     av_set_double(enc, opt_names[j], d);
2697             }
2698             frame_height = enc->height;
2699             frame_width = enc->width;
2700             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2701             frame_pix_fmt = enc->pix_fmt;
2702             rfps      = ic->streams[i]->r_frame_rate.num;
2703             rfps_base = ic->streams[i]->r_frame_rate.den;
2704             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2705             if(me_threshold)
2706                 enc->debug |= FF_DEBUG_MV;
2707
2708             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2709
2710                 if (verbose >= 0)
2711                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2712                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2713
2714                     (float)rfps / rfps_base, rfps, rfps_base);
2715             }
2716             /* update the current frame rate to match the stream frame rate */
2717             frame_rate.num = rfps;
2718             frame_rate.den = rfps_base;
2719
2720             enc->rate_emu = rate_emu;
2721             if(video_disable)
2722                 ic->streams[i]->discard= AVDISCARD_ALL;
2723             else if(video_discard)
2724                 ic->streams[i]->discard= video_discard;
2725             break;
2726         case CODEC_TYPE_DATA:
2727             break;
2728         case CODEC_TYPE_SUBTITLE:
2729             if(subtitle_disable)
2730                 ic->streams[i]->discard = AVDISCARD_ALL;
2731             break;
2732         case CODEC_TYPE_UNKNOWN:
2733             break;
2734         default:
2735             abort();
2736         }
2737     }
2738
2739     input_files[nb_input_files] = ic;
2740     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2741     /* dump the file content */
2742     if (verbose >= 0)
2743         dump_format(ic, nb_input_files, filename, 0);
2744
2745     nb_input_files++;
2746     file_iformat = NULL;
2747     file_oformat = NULL;
2748
2749     video_channel = 0;
2750
2751     rate_emu = 0;
2752 }
2753
2754 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2755                                          int *has_subtitle_ptr)
2756 {
2757     int has_video, has_audio, has_subtitle, i, j;
2758     AVFormatContext *ic;
2759
2760     has_video = 0;
2761     has_audio = 0;
2762     has_subtitle = 0;
2763     for(j=0;j<nb_input_files;j++) {
2764         ic = input_files[j];
2765         for(i=0;i<ic->nb_streams;i++) {
2766             AVCodecContext *enc = ic->streams[i]->codec;
2767             switch(enc->codec_type) {
2768             case CODEC_TYPE_AUDIO:
2769                 has_audio = 1;
2770                 break;
2771             case CODEC_TYPE_VIDEO:
2772                 has_video = 1;
2773                 break;
2774             case CODEC_TYPE_SUBTITLE:
2775                 has_subtitle = 1;
2776                 break;
2777             case CODEC_TYPE_DATA:
2778             case CODEC_TYPE_UNKNOWN:
2779                 break;
2780             default:
2781                 abort();
2782             }
2783         }
2784     }
2785     *has_video_ptr = has_video;
2786     *has_audio_ptr = has_audio;
2787     *has_subtitle_ptr = has_subtitle;
2788 }
2789
2790 static void new_video_stream(AVFormatContext *oc)
2791 {
2792     AVStream *st;
2793     AVCodecContext *video_enc;
2794     int codec_id;
2795
2796     st = av_new_stream(oc, oc->nb_streams);
2797     if (!st) {
2798         fprintf(stderr, "Could not alloc stream\n");
2799         exit(1);
2800     }
2801     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2802     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2803     video_bitstream_filters= NULL;
2804
2805     if(thread_count>1)
2806         avcodec_thread_init(st->codec, thread_count);
2807
2808     video_enc = st->codec;
2809
2810     if(video_codec_tag)
2811         video_enc->codec_tag= video_codec_tag;
2812
2813     if(   (video_global_header&1)
2814        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2815         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2816         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2817     }
2818     if(video_global_header&2){
2819         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2820         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2821     }
2822
2823     if (video_stream_copy) {
2824         st->stream_copy = 1;
2825         video_enc->codec_type = CODEC_TYPE_VIDEO;
2826     } else {
2827         char *p;
2828         int i;
2829         AVCodec *codec;
2830
2831         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2832         if (video_codec_name)
2833             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2834
2835         video_enc->codec_id = codec_id;
2836         codec = avcodec_find_encoder(codec_id);
2837
2838         for(i=0; i<opt_name_count; i++){
2839              const AVOption *opt;
2840              double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2841              if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2842                  av_set_double(video_enc, opt_names[i], d);
2843         }
2844
2845         video_enc->time_base.den = frame_rate.num;
2846         video_enc->time_base.num = frame_rate.den;
2847         if(codec && codec->supported_framerates){
2848             const AVRational *p= codec->supported_framerates;
2849             AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2850             const AVRational *best=NULL;
2851             AVRational best_error= (AVRational){INT_MAX, 1};
2852             for(; p->den!=0; p++){
2853                 AVRational error= av_sub_q(req, *p);
2854                 if(error.num <0) error.num *= -1;
2855                 if(av_cmp_q(error, best_error) < 0){
2856                     best_error= error;
2857                     best= p;
2858                 }
2859             }
2860             video_enc->time_base.den= best->num;
2861             video_enc->time_base.num= best->den;
2862         }
2863
2864         video_enc->width = frame_width + frame_padright + frame_padleft;
2865         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2866         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2867         video_enc->pix_fmt = frame_pix_fmt;
2868
2869         if(codec && codec->pix_fmts){
2870             const enum PixelFormat *p= codec->pix_fmts;
2871             for(; *p!=-1; p++){
2872                 if(*p == video_enc->pix_fmt)
2873                     break;
2874             }
2875             if(*p == -1)
2876                 video_enc->pix_fmt = codec->pix_fmts[0];
2877         }
2878
2879         if (intra_only)
2880             video_enc->gop_size = 0;
2881         if (video_qscale || same_quality) {
2882             video_enc->flags |= CODEC_FLAG_QSCALE;
2883             video_enc->global_quality=
2884                 st->quality = FF_QP2LAMBDA * video_qscale;
2885         }
2886
2887         if(intra_matrix)
2888             video_enc->intra_matrix = intra_matrix;
2889         if(inter_matrix)
2890             video_enc->inter_matrix = inter_matrix;
2891
2892         video_enc->max_qdiff = video_qdiff;
2893         video_enc->rc_eq = video_rc_eq;
2894         video_enc->thread_count = thread_count;
2895         p= video_rc_override_string;
2896         for(i=0; p; i++){
2897             int start, end, q;
2898             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2899             if(e!=3){
2900                 fprintf(stderr, "error parsing rc_override\n");
2901                 exit(1);
2902             }
2903             video_enc->rc_override=
2904                 av_realloc(video_enc->rc_override,
2905                            sizeof(RcOverride)*(i+1));
2906             video_enc->rc_override[i].start_frame= start;
2907             video_enc->rc_override[i].end_frame  = end;
2908             if(q>0){
2909                 video_enc->rc_override[i].qscale= q;
2910                 video_enc->rc_override[i].quality_factor= 1.0;
2911             }
2912             else{
2913                 video_enc->rc_override[i].qscale= 0;
2914                 video_enc->rc_override[i].quality_factor= -q/100.0;
2915             }
2916             p= strchr(p, '/');
2917             if(p) p++;
2918         }
2919         video_enc->rc_override_count=i;
2920         if (!video_enc->rc_initial_buffer_occupancy)
2921             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2922         video_enc->me_threshold= me_threshold;
2923         video_enc->intra_dc_precision= intra_dc_precision - 8;
2924         video_enc->strict_std_compliance = strict;
2925
2926         if (do_psnr)
2927             video_enc->flags|= CODEC_FLAG_PSNR;
2928
2929         /* two pass mode */
2930         if (do_pass) {
2931             if (do_pass == 1) {
2932                 video_enc->flags |= CODEC_FLAG_PASS1;
2933             } else {
2934                 video_enc->flags |= CODEC_FLAG_PASS2;
2935             }
2936         }
2937     }
2938
2939     /* reset some key parameters */
2940     video_disable = 0;
2941     av_freep(&video_codec_name);
2942     video_stream_copy = 0;
2943 }
2944
2945 static void new_audio_stream(AVFormatContext *oc)
2946 {
2947     AVStream *st;
2948     AVCodecContext *audio_enc;
2949     int codec_id, i;
2950
2951     st = av_new_stream(oc, oc->nb_streams);
2952     if (!st) {
2953         fprintf(stderr, "Could not alloc stream\n");
2954         exit(1);
2955     }
2956     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2957
2958     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2959     audio_bitstream_filters= NULL;
2960
2961     if(thread_count>1)
2962         avcodec_thread_init(st->codec, thread_count);
2963
2964     audio_enc = st->codec;
2965     audio_enc->codec_type = CODEC_TYPE_AUDIO;
2966     audio_enc->strict_std_compliance = strict;
2967
2968     if(audio_codec_tag)
2969         audio_enc->codec_tag= audio_codec_tag;
2970
2971     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2972         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2973         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2974     }
2975     if (audio_stream_copy) {
2976         st->stream_copy = 1;
2977         audio_enc->channels = audio_channels;
2978     } else {
2979         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2980
2981         for(i=0; i<opt_name_count; i++){
2982             const AVOption *opt;
2983             double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2984             if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2985                 av_set_double(audio_enc, opt_names[i], d);
2986         }
2987
2988         if (audio_codec_name)
2989             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2990         audio_enc->codec_id = codec_id;
2991
2992         if (audio_qscale > QSCALE_NONE) {
2993             audio_enc->flags |= CODEC_FLAG_QSCALE;
2994             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2995         }
2996         audio_enc->thread_count = thread_count;
2997         audio_enc->channels = audio_channels;
2998     }
2999     audio_enc->sample_rate = audio_sample_rate;
3000     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3001     if (audio_language) {
3002         av_strlcpy(st->language, audio_language, sizeof(st->language));
3003         av_free(audio_language);
3004         audio_language = NULL;
3005     }
3006
3007     /* reset some key parameters */
3008     audio_disable = 0;
3009     av_freep(&audio_codec_name);
3010     audio_stream_copy = 0;
3011 }
3012
3013 static void new_subtitle_stream(AVFormatContext *oc)
3014 {
3015     AVStream *st;
3016     AVCodecContext *subtitle_enc;
3017     int i;
3018
3019     st = av_new_stream(oc, oc->nb_streams);
3020     if (!st) {
3021         fprintf(stderr, "Could not alloc stream\n");
3022         exit(1);
3023     }
3024     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3025
3026     subtitle_enc = st->codec;
3027     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3028     if (subtitle_stream_copy) {
3029         st->stream_copy = 1;
3030     } else {
3031         for(i=0; i<opt_name_count; i++){
3032              const AVOption *opt;
3033              double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
3034              if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3035                  av_set_double(subtitle_enc, opt_names[i], d);
3036         }
3037         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3038     }
3039
3040     if (subtitle_language) {
3041         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3042         av_free(subtitle_language);
3043         subtitle_language = NULL;
3044     }
3045
3046     subtitle_disable = 0;
3047     av_freep(&subtitle_codec_name);
3048     subtitle_stream_copy = 0;
3049 }
3050
3051 static void opt_new_audio_stream(void)
3052 {
3053     AVFormatContext *oc;
3054     if (nb_output_files <= 0) {
3055         fprintf(stderr, "At least one output file must be specified\n");
3056         exit(1);
3057     }
3058     oc = output_files[nb_output_files - 1];
3059     new_audio_stream(oc);
3060 }
3061
3062 static void opt_new_video_stream(void)
3063 {
3064     AVFormatContext *oc;
3065     if (nb_output_files <= 0) {
3066         fprintf(stderr, "At least one output file must be specified\n");
3067         exit(1);
3068     }
3069     oc = output_files[nb_output_files - 1];
3070     new_video_stream(oc);
3071 }
3072
3073 static void opt_new_subtitle_stream(void)
3074 {
3075     AVFormatContext *oc;
3076     if (nb_output_files <= 0) {
3077         fprintf(stderr, "At least one output file must be specified\n");
3078         exit(1);
3079     }
3080     oc = output_files[nb_output_files - 1];
3081     new_subtitle_stream(oc);
3082 }
3083
3084 static void opt_output_file(const char *filename)
3085 {
3086     AVFormatContext *oc;
3087     int use_video, use_audio, use_subtitle;
3088     int input_has_video, input_has_audio, input_has_subtitle, i;
3089     AVFormatParameters params, *ap = &params;
3090
3091     if (!strcmp(filename, "-"))
3092         filename = "pipe:";
3093
3094     oc = av_alloc_format_context();
3095
3096     if (!file_oformat) {
3097         file_oformat = guess_format(NULL, filename, NULL);
3098         if (!file_oformat) {
3099             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3100                     filename);
3101             exit(1);
3102         }
3103     }
3104
3105     oc->oformat = file_oformat;
3106     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3107
3108     if (!strcmp(file_oformat->name, "ffm") &&
3109         av_strstart(filename, "http:", NULL)) {
3110         /* special case for files sent to ffserver: we get the stream
3111            parameters from ffserver */
3112         if (read_ffserver_streams(oc, filename) < 0) {
3113             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3114             exit(1);
3115         }
3116     } else {
3117         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3118         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3119         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3120
3121         /* disable if no corresponding type found and at least one
3122            input file */
3123         if (nb_input_files > 0) {
3124             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3125                                          &input_has_subtitle);
3126             if (!input_has_video)
3127                 use_video = 0;
3128             if (!input_has_audio)
3129                 use_audio = 0;
3130             if (!input_has_subtitle)
3131                 use_subtitle = 0;
3132         }
3133
3134         /* manual disable */
3135         if (audio_disable) {
3136             use_audio = 0;
3137         }
3138         if (video_disable) {
3139             use_video = 0;
3140         }
3141         if (subtitle_disable) {
3142             use_subtitle = 0;
3143         }
3144
3145         if (use_video) {
3146             new_video_stream(oc);
3147         }
3148
3149         if (use_audio) {
3150             new_audio_stream(oc);
3151         }
3152
3153         if (use_subtitle) {
3154             new_subtitle_stream(oc);
3155         }
3156
3157         oc->timestamp = rec_timestamp;
3158
3159         if (str_title)
3160             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3161         if (str_author)
3162             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3163         if (str_copyright)
3164             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3165         if (str_comment)
3166             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3167         if (str_album)
3168             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3169     }
3170
3171     output_files[nb_output_files++] = oc;
3172
3173     /* check filename in case of an image number is expected */
3174     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3175         if (!av_filename_number_test(oc->filename)) {
3176             print_error(oc->filename, AVERROR_NUMEXPECTED);
3177             exit(1);
3178         }
3179     }
3180
3181     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3182         /* test if it already exists to avoid loosing precious files */
3183         if (!file_overwrite &&
3184             (strchr(filename, ':') == NULL ||
3185              av_strstart(filename, "file:", NULL))) {
3186             if (url_exist(filename)) {
3187                 int c;
3188
3189                 if ( !using_stdin ) {
3190                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3191                     fflush(stderr);
3192                     c = getchar();
3193                     if (toupper(c) != 'Y') {
3194                         fprintf(stderr, "Not overwriting - exiting\n");
3195                         exit(1);
3196                     }
3197                                 }
3198                                 else {
3199                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3200                     exit(1);
3201                                 }
3202             }
3203         }
3204
3205         /* open the file */
3206         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3207             fprintf(stderr, "Could not open '%s'\n", filename);
3208             exit(1);
3209         }
3210     }
3211
3212     memset(ap, 0, sizeof(*ap));
3213     if (av_set_parameters(oc, ap) < 0) {
3214         fprintf(stderr, "%s: Invalid encoding parameters\n",
3215                 oc->filename);
3216         exit(1);
3217     }
3218
3219     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3220     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3221     oc->loop_output = loop_output;
3222
3223     for(i=0; i<opt_name_count; i++){
3224         const AVOption *opt;
3225         double d = av_get_double(avformat_opts, opt_names[i], &opt);
3226         if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3227             av_set_double(oc, opt_names[i], d);
3228     }
3229
3230     /* reset some options */
3231     file_oformat = NULL;
3232     file_iformat = NULL;
3233 }
3234
3235 /* same option as mencoder */
3236 static void opt_pass(const char *pass_str)
3237 {
3238     int pass;
3239     pass = atoi(pass_str);
3240     if (pass != 1 && pass != 2) {
3241         fprintf(stderr, "pass number can be only 1 or 2\n");
3242         exit(1);
3243     }
3244     do_pass = pass;
3245 }
3246
3247 static int64_t getutime(void)
3248 {
3249 #ifdef HAVE_GETRUSAGE
3250     struct rusage rusage;
3251
3252     getrusage(RUSAGE_SELF, &rusage);
3253     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3254 #elif defined(HAVE_GETPROCESSTIMES)
3255     HANDLE proc;
3256     FILETIME c, e, k, u;
3257     proc = GetCurrentProcess();
3258     GetProcessTimes(proc, &c, &e, &k, &u);
3259     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3260 #else
3261     return av_gettime();
3262 #endif
3263 }
3264
3265 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3266 extern int ffm_nopts;
3267 #endif
3268
3269 static void opt_show_formats(void)
3270 {
3271     AVInputFormat *ifmt;
3272     AVOutputFormat *ofmt;
3273     URLProtocol *up;
3274     AVCodec *p, *p2;
3275     const char *last_name;
3276
3277     printf("File formats:\n");
3278     last_name= "000";
3279     for(;;){
3280         int decode=0;
3281         int encode=0;
3282         const char *name=NULL;
3283         const char *long_name=NULL;
3284
3285         for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3286             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3287                 strcmp(ofmt->name, last_name)>0){
3288                 name= ofmt->name;
3289                 long_name= ofmt->long_name;
3290                 encode=1;
3291             }
3292         }
3293         for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3294             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3295                 strcmp(ifmt->name, last_name)>0){
3296                 name= ifmt->name;
3297                 long_name= ifmt->long_name;
3298                 encode=0;
3299             }
3300             if(name && strcmp(ifmt->name, name)==0)
3301                 decode=1;
3302         }
3303         if(name==NULL)
3304             break;
3305         last_name= name;
3306
3307         printf(
3308             " %s%s %-15s %s\n",
3309             decode ? "D":" ",
3310             encode ? "E":" ",
3311             name,
3312             long_name ? long_name:" ");
3313     }
3314     printf("\n");
3315
3316     printf("Codecs:\n");
3317     last_name= "000";
3318     for(;;){
3319         int decode=0;
3320         int encode=0;
3321         int cap=0;
3322         const char *type_str;
3323
3324         p2=NULL;
3325         for(p = first_avcodec; p != NULL; p = p->next) {
3326             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3327                 strcmp(p->name, last_name)>0){
3328                 p2= p;
3329                 decode= encode= cap=0;
3330             }
3331             if(p2 && strcmp(p->name, p2->name)==0){
3332                 if(p->decode) decode=1;
3333                 if(p->encode) encode=1;
3334                 cap |= p->capabilities;
3335             }
3336         }
3337         if(p2==NULL)
3338             break;
3339         last_name= p2->name;
3340
3341         switch(p2->type) {
3342         case CODEC_TYPE_VIDEO:
3343             type_str = "V";
3344             break;
3345         case CODEC_TYPE_AUDIO:
3346             type_str = "A";
3347             break;
3348         case CODEC_TYPE_SUBTITLE:
3349             type_str = "S";
3350             break;
3351         default:
3352             type_str = "?";
3353             break;
3354         }
3355         printf(
3356             " %s%s%s%s%s%s %s",
3357             decode ? "D": (/*p2->decoder ? "d":*/" "),
3358             encode ? "E":" ",
3359             type_str,
3360             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3361             cap & CODEC_CAP_DR1 ? "D":" ",
3362             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3363             p2->name);
3364        /* if(p2->decoder && decode==0)
3365             printf(" use %s for decoding", p2->decoder->name);*/
3366         printf("\n");
3367     }
3368     printf("\n");
3369
3370     printf("Supported file protocols:\n");
3371     for(up = first_protocol; up != NULL; up = up->next)
3372         printf(" %s:", up->name);
3373     printf("\n");
3374
3375     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3376     printf("\n");
3377     printf(
3378 "Note, the names of encoders and decoders do not always match, so there are\n"
3379 "several cases where the above table shows encoder only or decoder only entries\n"
3380 "even though both encoding and decoding are supported. For example, the h263\n"
3381 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3382 "worse.\n");
3383     exit(0);
3384 }
3385
3386 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3387 {
3388     int i;
3389     const char *p = str;
3390     for(i = 0;; i++) {
3391         dest[i] = atoi(p);
3392         if(i == 63)
3393             break;
3394         p = strchr(p, ',');
3395         if(!p) {
3396             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3397             exit(1);
3398         }
3399         p++;
3400     }
3401 }
3402
3403 static void opt_inter_matrix(const char *arg)
3404 {
3405     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3406     parse_matrix_coeffs(inter_matrix, arg);
3407 }
3408
3409 static void opt_intra_matrix(const char *arg)
3410 {
3411     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3412     parse_matrix_coeffs(intra_matrix, arg);
3413 }
3414
3415 static void opt_show_help(void)
3416 {
3417     show_help();
3418     exit(0);
3419 }
3420
3421 static void opt_target(const char *arg)
3422 {
3423     int norm = -1;
3424     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3425
3426     if(!strncmp(arg, "pal-", 4)) {
3427         norm = 0;
3428         arg += 4;
3429     } else if(!strncmp(arg, "ntsc-", 5)) {
3430         norm = 1;
3431         arg += 5;
3432     } else if(!strncmp(arg, "film-", 5)) {
3433         norm = 2;
3434         arg += 5;
3435     } else {
3436         int fr;
3437         /* Calculate FR via float to avoid int overflow */
3438         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3439         if(fr == 25000) {
3440             norm = 0;
3441         } else if((fr == 29970) || (fr == 23976)) {
3442             norm = 1;
3443         } else {
3444             /* Try to determine PAL/NTSC by peeking in the input files */
3445             if(nb_input_files) {
3446                 int i, j;
3447                 for(j = 0; j < nb_input_files; j++) {
3448                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3449                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3450                         if(c->codec_type != CODEC_TYPE_VIDEO)
3451                             continue;
3452                         fr = c->time_base.den * 1000 / c->time_base.num;
3453                         if(fr == 25000) {
3454                             norm = 0;
3455                             break;
3456                         } else if((fr == 29970) || (fr == 23976)) {
3457                             norm = 1;
3458                             break;
3459                         }
3460                     }
3461                     if(norm >= 0)
3462                         break;
3463                 }
3464             }
3465         }
3466         if(verbose && norm >= 0)
3467             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3468     }
3469
3470     if(norm < 0) {
3471         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3472         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3473         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3474         exit(1);
3475     }
3476
3477     if(!strcmp(arg, "vcd")) {
3478
3479         opt_video_codec("mpeg1video");
3480         opt_audio_codec("mp2");
3481         opt_format("vcd");
3482
3483         opt_frame_size(norm ? "352x240" : "352x288");
3484         opt_frame_rate(frame_rates[norm]);
3485         opt_default("gop", norm ? "18" : "15");
3486
3487         opt_default("b", "1150000");
3488         opt_default("maxrate", "1150000");
3489         opt_default("minrate", "1150000");
3490         opt_default("bufsize", "327680"); // 40*1024*8;
3491
3492         opt_default("ab", "224000");
3493         audio_sample_rate = 44100;
3494         audio_channels = 2;
3495
3496         opt_default("packetsize", "2324");
3497         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3498
3499         /* We have to offset the PTS, so that it is consistent with the SCR.
3500            SCR starts at 36000, but the first two packs contain only padding
3501            and the first pack from the other stream, respectively, may also have
3502            been written before.
3503            So the real data starts at SCR 36000+3*1200. */
3504         mux_preload= (36000+3*1200) / 90000.0; //0.44
3505     } else if(!strcmp(arg, "svcd")) {
3506
3507         opt_video_codec("mpeg2video");
3508         opt_audio_codec("mp2");
3509         opt_format("svcd");
3510
3511         opt_frame_size(norm ? "480x480" : "480x576");
3512         opt_frame_rate(frame_rates[norm]);
3513         opt_default("gop", norm ? "18" : "15");
3514
3515         opt_default("b", "2040000");
3516         opt_default("maxrate", "2516000");
3517         opt_default("minrate", "0"); //1145000;
3518         opt_default("bufsize", "1835008"); //224*1024*8;
3519         opt_default("flags", "+SCAN_OFFSET");
3520
3521
3522         opt_default("ab", "224000");
3523         audio_sample_rate = 44100;
3524
3525         opt_default("packetsize", "2324");
3526
3527     } else if(!strcmp(arg, "dvd")) {
3528
3529         opt_video_codec("mpeg2video");
3530         opt_audio_codec("ac3");
3531         opt_format("dvd");
3532
3533         opt_frame_size(norm ? "720x480" : "720x576");
3534         opt_frame_rate(frame_rates[norm]);
3535         opt_default("gop", norm ? "18" : "15");
3536
3537         opt_default("b", "6000000");
3538         opt_default("maxrate", "9000000");
3539         opt_default("minrate", "0"); //1500000;
3540         opt_default("bufsize", "1835008"); //224*1024*8;
3541
3542         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3543         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3544
3545         opt_default("ab", "448000");
3546         audio_sample_rate = 48000;
3547
3548     } else if(!strncmp(arg, "dv", 2)) {
3549
3550         opt_format("dv");
3551
3552         opt_frame_size(norm ? "720x480" : "720x576");
3553         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3554                                              (norm ? "yuv411p" : "yuv420p"));
3555         opt_frame_rate(frame_rates[norm]);
3556
3557         audio_sample_rate = 48000;
3558         audio_channels = 2;
3559
3560     } else {
3561         fprintf(stderr, "Unknown target: %s\n", arg);
3562         exit(1);
3563     }
3564 }
3565
3566 static void opt_vstats_file (const char *arg)
3567 {
3568     av_free (vstats_filename);
3569     vstats_filename=av_strdup (arg);
3570 }
3571
3572 static void opt_vstats (void)
3573 {
3574     char filename[40];
3575     time_t today2 = time(NULL);
3576     struct tm *today = localtime(&today2);
3577
3578     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3579              today->tm_sec);
3580     opt_vstats_file(filename);
3581 }
3582
3583 static void opt_bsf(const char *opt, const char *arg)
3584 {
3585     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3586     AVBitStreamFilterContext **bsfp;
3587
3588     if(!bsfc){
3589         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3590         exit(1);
3591     }
3592
3593     bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3594     while(*bsfp)
3595         bsfp= &(*bsfp)->next;
3596
3597     *bsfp= bsfc;
3598 }
3599
3600 static void opt_show_version(void)
3601 {
3602     show_version(program_name);
3603     exit(0);
3604 }
3605
3606 static int opt_default(const char *opt, const char *arg){
3607     int type;
3608     const AVOption *o= NULL;
3609     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3610
3611     for(type=0; type<CODEC_TYPE_NB; type++){
3612         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3613         if(o2)
3614             o = av_set_string(avctx_opts[type], opt, arg);
3615     }
3616     if(!o)
3617         o = av_set_string(avformat_opts, opt, arg);
3618     if(!o)
3619         o = av_set_string(sws_opts, opt, arg);
3620     if(!o){
3621         if(opt[0] == 'a')
3622             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3623         else if(opt[0] == 'v')
3624             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3625         else if(opt[0] == 's')
3626             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3627     }
3628     if(!o)
3629         return -1;
3630
3631 //    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));
3632
3633     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3634     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3635     opt_names[opt_name_count++]= o->name;
3636
3637 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3638     /* disable generate of real time pts in ffm (need to be supressed anyway) */
3639     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3640         ffm_nopts = 1;
3641 #endif
3642
3643     if(avctx_opts[0]->debug)
3644         av_log_level = AV_LOG_DEBUG;
3645     return 0;
3646 }
3647
3648 const OptionDef options[] = {
3649     /* main options */
3650     { "L", 0, {(void*)opt_show_license}, "show license" },
3651     { "h", 0, {(void*)opt_show_help}, "show help" },
3652     { "version", 0, {(void*)opt_show_version}, "show version" },
3653     { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3654     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3655     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3656     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3657     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3658     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3659     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3660     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3661     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3662     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3663     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3664     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3665     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3666     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3667     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3668     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3669     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3670       "add timings for benchmarking" },
3671     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3672       "dump each input packet" },
3673     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3674       "when dumping packets, also dump the payload" },
3675     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3676     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3677     { "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)", "" },
3678     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3679     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3680     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3681     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3682     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3683     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3684     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3685     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3686     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3687     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3688     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3689
3690     /* video options */
3691     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3692     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3693     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3694     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3695     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3696     { "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" },
3697     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3698     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3699     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3700     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3701     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3702     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3703     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3704     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3705     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3706     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3707     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3708     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3709     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3710     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3711     { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3712     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3713     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3714     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3715     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3716     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3717       "use same video quality as source (implies VBR)" },
3718     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3719     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3720     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3721       "deinterlace pictures" },
3722     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3723     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3724     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3725 #ifdef CONFIG_VHOOK
3726     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3727 #endif
3728     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3729     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3730     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3731     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3732     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3733     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3734     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3735
3736     /* audio options */
3737     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3738     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3739     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3740     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3741     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3742     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3743     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3744     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3745     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3746     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3747
3748     /* subtitle options */
3749     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3750     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3751     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3752     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3753
3754     /* grab options */
3755     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3756     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3757     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3758
3759     /* muxer options */
3760     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3761     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3762
3763     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3764     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3765
3766     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3767     { NULL, },
3768 };
3769
3770 static void opt_show_license(void)
3771 {
3772     show_license();
3773     exit(0);
3774 }
3775
3776 /**
3777  * Trivial log callback.
3778  * Only suitable for show_help and similar since it lacks prefix handling.
3779  */
3780 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3781 {
3782     vfprintf(stdout, fmt, vl);
3783 }
3784
3785 static void show_help(void)
3786 {
3787     av_log_set_callback(log_callback_help);
3788     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3789            "Hyper fast Audio and Video encoder\n");
3790     printf("\n");
3791     show_help_options(options, "Main options:\n",
3792                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3793     show_help_options(options, "\nVideo options:\n",
3794                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3795                       OPT_VIDEO);
3796     show_help_options(options, "\nAdvanced Video options:\n",
3797                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3798                       OPT_VIDEO | OPT_EXPERT);
3799     show_help_options(options, "\nAudio options:\n",
3800                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3801                       OPT_AUDIO);
3802     show_help_options(options, "\nAdvanced Audio options:\n",
3803                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3804                       OPT_AUDIO | OPT_EXPERT);
3805     show_help_options(options, "\nSubtitle options:\n",
3806                       OPT_SUBTITLE | OPT_GRAB,
3807                       OPT_SUBTITLE);
3808     show_help_options(options, "\nAudio/Video grab options:\n",
3809                       OPT_GRAB,
3810                       OPT_GRAB);
3811     show_help_options(options, "\nAdvanced options:\n",
3812                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3813                       OPT_EXPERT);
3814     av_opt_show(avctx_opts[0], NULL);
3815     av_opt_show(avformat_opts, NULL);
3816     av_opt_show(sws_opts, NULL);
3817 }
3818
3819 static int av_exit()
3820 {
3821     int i;
3822
3823     /* close files */
3824     for(i=0;i<nb_output_files;i++) {
3825         /* maybe av_close_output_file ??? */
3826         AVFormatContext *s = output_files[i];
3827         int j;
3828         if (!(s->oformat->flags & AVFMT_NOFILE))
3829             url_fclose(&s->pb);
3830         for(j=0;j<s->nb_streams;j++) {
3831             av_free(s->streams[j]->codec);
3832             av_free(s->streams[j]);
3833         }
3834         av_free(s);
3835     }
3836     for(i=0;i<nb_input_files;i++)
3837         av_close_input_file(input_files[i]);
3838
3839     av_free_static();
3840
3841     av_free(intra_matrix);
3842     av_free(inter_matrix);
3843
3844     if (vstats_file)
3845         fclose(vstats_file);
3846     av_free(vstats_filename);
3847
3848     av_free(opt_names);
3849
3850     av_free(video_codec_name);
3851     av_free(audio_codec_name);
3852     av_free(subtitle_codec_name);
3853
3854     av_free(video_standard);
3855
3856 #ifdef CONFIG_POWERPC_PERF
3857     extern void powerpc_display_perf_report(void);
3858     powerpc_display_perf_report();
3859 #endif /* CONFIG_POWERPC_PERF */
3860
3861     if (received_sigterm) {
3862         fprintf(stderr,
3863             "Received signal %d: terminating.\n",
3864             (int) received_sigterm);
3865         exit (255);
3866     }
3867
3868     exit(0); /* not all OS-es handle main() return value */
3869     return 0;
3870 }
3871
3872 int main(int argc, char **argv)
3873 {
3874     int i;
3875     int64_t ti;
3876
3877     av_register_all();
3878
3879     for(i=0; i<CODEC_TYPE_NB; i++){
3880         avctx_opts[i]= avcodec_alloc_context2(i);
3881     }
3882     avformat_opts = av_alloc_format_context();
3883     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3884
3885     show_banner(program_name, program_birth_year);
3886     if (argc <= 1) {
3887         show_help();
3888         exit(1);
3889     }
3890
3891     /* parse options */
3892     parse_options(argc, argv, options, opt_output_file);
3893
3894     /* file converter / grab */
3895     if (nb_output_files <= 0) {
3896         fprintf(stderr, "Must supply at least one output file\n");
3897         exit(1);
3898     }
3899
3900     if (nb_input_files == 0) {
3901         fprintf(stderr, "Must supply at least one input file\n");
3902         exit(1);
3903     }
3904
3905     ti = getutime();
3906     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3907               stream_maps, nb_stream_maps);
3908     ti = getutime() - ti;
3909     if (do_benchmark) {
3910         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3911     }
3912
3913     return av_exit();
3914 }