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