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