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