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