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