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