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