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