Compiling ffmpeg.c fails when when the .ffm demuxer is enabled, but the .ffm
[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 "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
33 #include "libavformat/framehook.h"
34 #include "libavcodec/opt.h"
35 #include "libavutil/fifo.h"
36 #include "libavutil/avstring.h"
37 #include "libavformat/os_support.h"
38
39 #ifdef HAVE_SYS_RESOURCE_H
40 #include <sys/types.h>
41 #include <sys/resource.h>
42 #elif defined(HAVE_GETPROCESSTIMES)
43 #include <windows.h>
44 #endif
45
46 #if defined(HAVE_TERMIOS_H)
47 #include <unistd.h>
48 #include <fcntl.h>
49 #include <sys/ioctl.h>
50 #include <sys/time.h>
51 #include <termios.h>
52 #elif defined(HAVE_CONIO_H)
53 #include <conio.h>
54 #endif
55 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
56 #include <time.h>
57
58 #include "cmdutils.h"
59
60 #undef NDEBUG
61 #include <assert.h>
62
63 #undef exit
64
65 const char program_name[] = "FFmpeg";
66 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(intra_matrix);
396     av_free(inter_matrix);
397
398     if (vstats_file)
399         fclose(vstats_file);
400     av_free(vstats_filename);
401
402     av_free(opt_names);
403
404     av_free(video_codec_name);
405     av_free(audio_codec_name);
406     av_free(subtitle_codec_name);
407
408     av_free(video_standard);
409
410 #ifdef CONFIG_POWERPC_PERF
411     extern void powerpc_display_perf_report(void);
412     powerpc_display_perf_report();
413 #endif /* CONFIG_POWERPC_PERF */
414
415     if (received_sigterm) {
416         fprintf(stderr,
417             "Received signal %d: terminating.\n",
418             (int) received_sigterm);
419         exit (255);
420     }
421
422     exit(ret); /* not all OS-es handle main() return value */
423     return ret;
424 }
425
426 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
427 {
428     int i, err;
429     AVFormatContext *ic;
430
431     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
432     if (err < 0)
433         return err;
434     /* copy stream format */
435     s->nb_streams = ic->nb_streams;
436     for(i=0;i<ic->nb_streams;i++) {
437         AVStream *st;
438
439         // FIXME: a more elegant solution is needed
440         st = av_mallocz(sizeof(AVStream));
441         memcpy(st, ic->streams[i], sizeof(AVStream));
442         st->codec = avcodec_alloc_context();
443         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
444         s->streams[i] = st;
445     }
446
447     av_close_input_file(ic);
448     return 0;
449 }
450
451 static double
452 get_sync_ipts(const AVOutputStream *ost)
453 {
454     const AVInputStream *ist = ost->sync_ist;
455     return (double)(ist->pts - start_time)/AV_TIME_BASE;
456 }
457
458 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
459     int ret;
460
461     while(bsfc){
462         AVPacket new_pkt= *pkt;
463         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
464                                           &new_pkt.data, &new_pkt.size,
465                                           pkt->data, pkt->size,
466                                           pkt->flags & PKT_FLAG_KEY);
467         if(a>0){
468             av_free_packet(pkt);
469             new_pkt.destruct= av_destruct_packet;
470         } else if(a<0){
471             fprintf(stderr, "%s failed for stream %d, codec %s",
472                     bsfc->filter->name, pkt->stream_index,
473                     avctx->codec ? avctx->codec->name : "copy");
474             print_error("", a);
475         }
476         *pkt= new_pkt;
477
478         bsfc= bsfc->next;
479     }
480
481     ret= av_interleaved_write_frame(s, pkt);
482     if(ret < 0){
483         print_error("av_interleaved_write_frame()", ret);
484         av_exit(1);
485     }
486 }
487
488 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
489
490 static void do_audio_out(AVFormatContext *s,
491                          AVOutputStream *ost,
492                          AVInputStream *ist,
493                          unsigned char *buf, int size)
494 {
495     uint8_t *buftmp;
496     static uint8_t *audio_buf = NULL;
497     static uint8_t *audio_out = NULL;
498     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
499
500     int size_out, frame_bytes, ret;
501     AVCodecContext *enc= ost->st->codec;
502     AVCodecContext *dec= ist->st->codec;
503
504     /* SC: dynamic allocation of buffers */
505     if (!audio_buf)
506         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
507     if (!audio_out)
508         audio_out = av_malloc(audio_out_size);
509     if (!audio_buf || !audio_out)
510         return;               /* Should signal an error ! */
511
512     if (enc->channels != dec->channels)
513         ost->audio_resample = 1;
514
515     if (ost->audio_resample && !ost->resample) {
516         ost->resample = audio_resample_init(enc->channels,    dec->channels,
517                                             enc->sample_rate, dec->sample_rate);
518         if (!ost->resample) {
519             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
520                     dec->channels, dec->sample_rate,
521                     enc->channels, enc->sample_rate);
522             av_exit(1);
523         }
524     }
525
526     if(audio_sync_method){
527         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
528                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
529         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
530         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
531
532         //FIXME resample delay
533         if(fabs(delta) > 50){
534             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
535                 if(byte_delta < 0){
536                     byte_delta= FFMAX(byte_delta, -size);
537                     size += byte_delta;
538                     buf  -= byte_delta;
539                     if(verbose > 2)
540                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
541                     if(!size)
542                         return;
543                     ist->is_start=0;
544                 }else{
545                     static uint8_t *input_tmp= NULL;
546                     input_tmp= av_realloc(input_tmp, byte_delta + size);
547
548                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
549                         ist->is_start=0;
550                     else
551                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
552
553                     memset(input_tmp, 0, byte_delta);
554                     memcpy(input_tmp + byte_delta, buf, size);
555                     buf= input_tmp;
556                     size += byte_delta;
557                     if(verbose > 2)
558                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
559                 }
560             }else if(audio_sync_method>1){
561                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
562                 assert(ost->audio_resample);
563                 if(verbose > 2)
564                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
565 //                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));
566                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
567             }
568         }
569     }else
570         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
571                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
572
573     if (ost->audio_resample) {
574         buftmp = audio_buf;
575         size_out = audio_resample(ost->resample,
576                                   (short *)buftmp, (short *)buf,
577                                   size / (ist->st->codec->channels * 2));
578         size_out = size_out * enc->channels * 2;
579     } else {
580         buftmp = buf;
581         size_out = size;
582     }
583
584     /* now encode as many frames as possible */
585     if (enc->frame_size > 1) {
586         /* output resampled raw samples */
587         av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
588         av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
589
590         frame_bytes = enc->frame_size * 2 * enc->channels;
591
592         while (av_fifo_size(&ost->fifo) >= frame_bytes) {
593             AVPacket pkt;
594             av_init_packet(&pkt);
595
596             av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
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->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->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                      !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                      !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){
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.2f 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                                 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1388                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1389                                 enc->frame_size = fs_tmp;
1390                             }
1391                             if(ret <= 0) {
1392                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1393                             }
1394                             audio_size += ret;
1395                             pkt.flags |= PKT_FLAG_KEY;
1396                             break;
1397                         case CODEC_TYPE_VIDEO:
1398                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1399                             video_size += ret;
1400                             if(enc->coded_frame && enc->coded_frame->key_frame)
1401                                 pkt.flags |= PKT_FLAG_KEY;
1402                             if (ost->logfile && enc->stats_out) {
1403                                 fprintf(ost->logfile, "%s", enc->stats_out);
1404                             }
1405                             break;
1406                         default:
1407                             ret=-1;
1408                         }
1409
1410                         if(ret<=0)
1411                             break;
1412                         pkt.data= bit_buffer;
1413                         pkt.size= ret;
1414                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1415                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1416                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1417                     }
1418                 }
1419             }
1420         }
1421     }
1422
1423     return 0;
1424  fail_decode:
1425     return -1;
1426 }
1427
1428 static void print_sdp(AVFormatContext **avc, int n)
1429 {
1430     char sdp[2048];
1431
1432     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1433     printf("SDP:\n%s\n", sdp);
1434 }
1435
1436 static int stream_index_from_inputs(AVFormatContext **input_files,
1437                                     int nb_input_files,
1438                                     AVInputFile *file_table,
1439                                     AVInputStream **ist_table,
1440                                     enum CodecType type,
1441                                     int programid)
1442 {
1443     int p, q, z;
1444     for(z=0; z<nb_input_files; z++) {
1445         AVFormatContext *ic = input_files[z];
1446         for(p=0; p<ic->nb_programs; p++) {
1447             AVProgram *program = ic->programs[p];
1448             if(program->id != programid)
1449                 continue;
1450             for(q=0; q<program->nb_stream_indexes; q++) {
1451                 int sidx = program->stream_index[q];
1452                 int ris = file_table[z].ist_index + sidx;
1453                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1454                     return ris;
1455             }
1456         }
1457     }
1458
1459     return -1;
1460 }
1461
1462 /*
1463  * The following code is the main loop of the file converter
1464  */
1465 static int av_encode(AVFormatContext **output_files,
1466                      int nb_output_files,
1467                      AVFormatContext **input_files,
1468                      int nb_input_files,
1469                      AVStreamMap *stream_maps, int nb_stream_maps)
1470 {
1471     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1472     AVFormatContext *is, *os;
1473     AVCodecContext *codec, *icodec;
1474     AVOutputStream *ost, **ost_table = NULL;
1475     AVInputStream *ist, **ist_table = NULL;
1476     AVInputFile *file_table;
1477     int key;
1478     int want_sdp = 1;
1479
1480     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1481     if (!file_table)
1482         goto fail;
1483
1484     /* input stream init */
1485     j = 0;
1486     for(i=0;i<nb_input_files;i++) {
1487         is = input_files[i];
1488         file_table[i].ist_index = j;
1489         file_table[i].nb_streams = is->nb_streams;
1490         j += is->nb_streams;
1491     }
1492     nb_istreams = j;
1493
1494     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1495     if (!ist_table)
1496         goto fail;
1497
1498     for(i=0;i<nb_istreams;i++) {
1499         ist = av_mallocz(sizeof(AVInputStream));
1500         if (!ist)
1501             goto fail;
1502         ist_table[i] = ist;
1503     }
1504     j = 0;
1505     for(i=0;i<nb_input_files;i++) {
1506         is = input_files[i];
1507         for(k=0;k<is->nb_streams;k++) {
1508             ist = ist_table[j++];
1509             ist->st = is->streams[k];
1510             ist->file_index = i;
1511             ist->index = k;
1512             ist->discard = 1; /* the stream is discarded by default
1513                                  (changed later) */
1514
1515             if (ist->st->codec->rate_emu) {
1516                 ist->start = av_gettime();
1517                 ist->frame = 0;
1518             }
1519         }
1520     }
1521
1522     /* output stream init */
1523     nb_ostreams = 0;
1524     for(i=0;i<nb_output_files;i++) {
1525         os = output_files[i];
1526         if (!os->nb_streams) {
1527             fprintf(stderr, "Output file does not contain any stream\n");
1528             av_exit(1);
1529         }
1530         nb_ostreams += os->nb_streams;
1531     }
1532     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1533         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1534         av_exit(1);
1535     }
1536
1537     /* Sanity check the mapping args -- do the input files & streams exist? */
1538     for(i=0;i<nb_stream_maps;i++) {
1539         int fi = stream_maps[i].file_index;
1540         int si = stream_maps[i].stream_index;
1541
1542         if (fi < 0 || fi > nb_input_files - 1 ||
1543             si < 0 || si > file_table[fi].nb_streams - 1) {
1544             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1545             av_exit(1);
1546         }
1547         fi = stream_maps[i].sync_file_index;
1548         si = stream_maps[i].sync_stream_index;
1549         if (fi < 0 || fi > nb_input_files - 1 ||
1550             si < 0 || si > file_table[fi].nb_streams - 1) {
1551             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1552             av_exit(1);
1553         }
1554     }
1555
1556     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1557     if (!ost_table)
1558         goto fail;
1559     for(i=0;i<nb_ostreams;i++) {
1560         ost = av_mallocz(sizeof(AVOutputStream));
1561         if (!ost)
1562             goto fail;
1563         ost_table[i] = ost;
1564     }
1565
1566     n = 0;
1567     for(k=0;k<nb_output_files;k++) {
1568         os = output_files[k];
1569         for(i=0;i<os->nb_streams;i++) {
1570             int found;
1571             ost = ost_table[n++];
1572             ost->file_index = k;
1573             ost->index = i;
1574             ost->st = os->streams[i];
1575             if (nb_stream_maps > 0) {
1576                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1577                     stream_maps[n-1].stream_index;
1578
1579                 /* Sanity check that the stream types match */
1580                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1581                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1582                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1583                         ost->file_index, ost->index);
1584                     av_exit(1);
1585                 }
1586
1587             } else {
1588                 if(opt_programid) {
1589                     found = 0;
1590                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1591                     if(j != -1) {
1592                         ost->source_index = j;
1593                         found = 1;
1594                     }
1595                 } else {
1596                     /* get corresponding input stream index : we select the first one with the right type */
1597                     found = 0;
1598                     for(j=0;j<nb_istreams;j++) {
1599                         ist = ist_table[j];
1600                         if (ist->discard &&
1601                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1602                             ost->source_index = j;
1603                             found = 1;
1604                             break;
1605                         }
1606                     }
1607                 }
1608
1609                 if (!found) {
1610                     if(! opt_programid) {
1611                         /* try again and reuse existing stream */
1612                         for(j=0;j<nb_istreams;j++) {
1613                             ist = ist_table[j];
1614                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1615                                 ost->source_index = j;
1616                                 found = 1;
1617                             }
1618                         }
1619                     }
1620                     if (!found) {
1621                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1622                                 ost->file_index, ost->index);
1623                         av_exit(1);
1624                     }
1625                 }
1626             }
1627             ist = ist_table[ost->source_index];
1628             ist->discard = 0;
1629             ost->sync_ist = (nb_stream_maps > 0) ?
1630                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1631                          stream_maps[n-1].sync_stream_index] : ist;
1632         }
1633     }
1634
1635     /* for each output stream, we compute the right encoding parameters */
1636     for(i=0;i<nb_ostreams;i++) {
1637         ost = ost_table[i];
1638         os = output_files[ost->file_index];
1639         ist = ist_table[ost->source_index];
1640
1641         codec = ost->st->codec;
1642         icodec = ist->st->codec;
1643
1644         if (!ost->st->language[0])
1645             av_strlcpy(ost->st->language, ist->st->language,
1646                        sizeof(ost->st->language));
1647
1648         ost->st->disposition = ist->st->disposition;
1649
1650         if (ost->st->stream_copy) {
1651             /* if stream_copy is selected, no need to decode or encode */
1652             codec->codec_id = icodec->codec_id;
1653             codec->codec_type = icodec->codec_type;
1654
1655             if(!codec->codec_tag){
1656                 if(   !os->oformat->codec_tag
1657                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1658                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1659                     codec->codec_tag = icodec->codec_tag;
1660             }
1661
1662             codec->bit_rate = icodec->bit_rate;
1663             codec->extradata= icodec->extradata;
1664             codec->extradata_size= icodec->extradata_size;
1665             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1666                 codec->time_base = icodec->time_base;
1667             else
1668                 codec->time_base = ist->st->time_base;
1669             switch(codec->codec_type) {
1670             case CODEC_TYPE_AUDIO:
1671                 codec->sample_rate = icodec->sample_rate;
1672                 codec->channels = icodec->channels;
1673                 codec->frame_size = icodec->frame_size;
1674                 codec->block_align= icodec->block_align;
1675                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1676                     codec->block_align= 0;
1677                 if(codec->codec_id == CODEC_ID_AC3)
1678                     codec->block_align= 0;
1679                 break;
1680             case CODEC_TYPE_VIDEO:
1681                 if(using_vhook) {
1682                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1683                     av_exit(1);
1684                 }
1685                 codec->pix_fmt = icodec->pix_fmt;
1686                 codec->width = icodec->width;
1687                 codec->height = icodec->height;
1688                 codec->has_b_frames = icodec->has_b_frames;
1689                 break;
1690             case CODEC_TYPE_SUBTITLE:
1691                 break;
1692             default:
1693                 abort();
1694             }
1695         } else {
1696             switch(codec->codec_type) {
1697             case CODEC_TYPE_AUDIO:
1698                 if (av_fifo_init(&ost->fifo, 1024))
1699                     goto fail;
1700                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1701                 icodec->request_channels = codec->channels;
1702                 ist->decoding_needed = 1;
1703                 ost->encoding_needed = 1;
1704                 break;
1705             case CODEC_TYPE_VIDEO:
1706                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1707                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1708                 ost->video_resample = ((codec->width != icodec->width -
1709                                 (frame_leftBand + frame_rightBand) +
1710                                 (frame_padleft + frame_padright)) ||
1711                         (codec->height != icodec->height -
1712                                 (frame_topBand  + frame_bottomBand) +
1713                                 (frame_padtop + frame_padbottom)) ||
1714                         (codec->pix_fmt != icodec->pix_fmt));
1715                 if (ost->video_crop) {
1716                     ost->topBand = frame_topBand;
1717                     ost->leftBand = frame_leftBand;
1718                 }
1719                 if (ost->video_pad) {
1720                     ost->padtop = frame_padtop;
1721                     ost->padleft = frame_padleft;
1722                     ost->padbottom = frame_padbottom;
1723                     ost->padright = frame_padright;
1724                     if (!ost->video_resample) {
1725                         avcodec_get_frame_defaults(&ost->pict_tmp);
1726                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1727                                          codec->width, codec->height))
1728                             goto fail;
1729                     }
1730                 }
1731                 if (ost->video_resample) {
1732                     avcodec_get_frame_defaults(&ost->pict_tmp);
1733                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1734                                          codec->width, codec->height)) {
1735                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1736                         av_exit(1);
1737                     }
1738                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1739                     ost->img_resample_ctx = sws_getContext(
1740                             icodec->width - (frame_leftBand + frame_rightBand),
1741                             icodec->height - (frame_topBand + frame_bottomBand),
1742                             icodec->pix_fmt,
1743                             codec->width - (frame_padleft + frame_padright),
1744                             codec->height - (frame_padtop + frame_padbottom),
1745                             codec->pix_fmt,
1746                             sws_flags, NULL, NULL, NULL);
1747                     if (ost->img_resample_ctx == NULL) {
1748                         fprintf(stderr, "Cannot get resampling context\n");
1749                         av_exit(1);
1750                     }
1751                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1752                 }
1753                 ost->encoding_needed = 1;
1754                 ist->decoding_needed = 1;
1755                 break;
1756             case CODEC_TYPE_SUBTITLE:
1757                 ost->encoding_needed = 1;
1758                 ist->decoding_needed = 1;
1759                 break;
1760             default:
1761                 abort();
1762                 break;
1763             }
1764             /* two pass mode */
1765             if (ost->encoding_needed &&
1766                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1767                 char logfilename[1024];
1768                 FILE *f;
1769                 int size;
1770                 char *logbuffer;
1771
1772                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1773                          pass_logfilename ?
1774                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1775                 if (codec->flags & CODEC_FLAG_PASS1) {
1776                     f = fopen(logfilename, "w");
1777                     if (!f) {
1778                         perror(logfilename);
1779                         av_exit(1);
1780                     }
1781                     ost->logfile = f;
1782                 } else {
1783                     /* read the log file */
1784                     f = fopen(logfilename, "r");
1785                     if (!f) {
1786                         perror(logfilename);
1787                         av_exit(1);
1788                     }
1789                     fseek(f, 0, SEEK_END);
1790                     size = ftell(f);
1791                     fseek(f, 0, SEEK_SET);
1792                     logbuffer = av_malloc(size + 1);
1793                     if (!logbuffer) {
1794                         fprintf(stderr, "Could not allocate log buffer\n");
1795                         av_exit(1);
1796                     }
1797                     size = fread(logbuffer, 1, size, f);
1798                     fclose(f);
1799                     logbuffer[size] = '\0';
1800                     codec->stats_in = logbuffer;
1801                 }
1802             }
1803         }
1804         if(codec->codec_type == CODEC_TYPE_VIDEO){
1805             int size= codec->width * codec->height;
1806             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1807         }
1808     }
1809
1810     if (!bit_buffer)
1811         bit_buffer = av_malloc(bit_buffer_size);
1812     if (!bit_buffer)
1813         goto fail;
1814
1815     /* dump the file output parameters - cannot be done before in case
1816        of stream copy */
1817     for(i=0;i<nb_output_files;i++) {
1818         dump_format(output_files[i], i, output_files[i]->filename, 1);
1819     }
1820
1821     /* dump the stream mapping */
1822     if (verbose >= 0) {
1823         fprintf(stderr, "Stream mapping:\n");
1824         for(i=0;i<nb_ostreams;i++) {
1825             ost = ost_table[i];
1826             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1827                     ist_table[ost->source_index]->file_index,
1828                     ist_table[ost->source_index]->index,
1829                     ost->file_index,
1830                     ost->index);
1831             if (ost->sync_ist != ist_table[ost->source_index])
1832                 fprintf(stderr, " [sync #%d.%d]",
1833                         ost->sync_ist->file_index,
1834                         ost->sync_ist->index);
1835             fprintf(stderr, "\n");
1836         }
1837     }
1838
1839     /* open each encoder */
1840     for(i=0;i<nb_ostreams;i++) {
1841         ost = ost_table[i];
1842         if (ost->encoding_needed) {
1843             AVCodec *codec;
1844             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1845             if (!codec) {
1846                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1847                         ost->file_index, ost->index);
1848                 av_exit(1);
1849             }
1850             if (avcodec_open(ost->st->codec, codec) < 0) {
1851                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1852                         ost->file_index, ost->index);
1853                 av_exit(1);
1854             }
1855             extra_size += ost->st->codec->extradata_size;
1856         }
1857     }
1858
1859     /* open each decoder */
1860     for(i=0;i<nb_istreams;i++) {
1861         ist = ist_table[i];
1862         if (ist->decoding_needed) {
1863             AVCodec *codec;
1864             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1865             if (!codec) {
1866                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1867                         ist->st->codec->codec_id, ist->file_index, ist->index);
1868                 av_exit(1);
1869             }
1870             if (avcodec_open(ist->st->codec, codec) < 0) {
1871                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1872                         ist->file_index, ist->index);
1873                 av_exit(1);
1874             }
1875             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1876             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1877         }
1878     }
1879
1880     /* init pts */
1881     for(i=0;i<nb_istreams;i++) {
1882         ist = ist_table[i];
1883         is = input_files[ist->file_index];
1884         ist->pts = 0;
1885         ist->next_pts = AV_NOPTS_VALUE;
1886         ist->is_start = 1;
1887     }
1888
1889     /* set meta data information from input file if required */
1890     for (i=0;i<nb_meta_data_maps;i++) {
1891         AVFormatContext *out_file;
1892         AVFormatContext *in_file;
1893
1894         int out_file_index = meta_data_maps[i].out_file;
1895         int in_file_index = meta_data_maps[i].in_file;
1896         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1897             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1898             ret = AVERROR(EINVAL);
1899             goto fail;
1900         }
1901         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1902             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1903             ret = AVERROR(EINVAL);
1904             goto fail;
1905         }
1906
1907         out_file = output_files[out_file_index];
1908         in_file = input_files[in_file_index];
1909
1910         strcpy(out_file->title, in_file->title);
1911         strcpy(out_file->author, in_file->author);
1912         strcpy(out_file->copyright, in_file->copyright);
1913         strcpy(out_file->comment, in_file->comment);
1914         strcpy(out_file->album, in_file->album);
1915         out_file->year = in_file->year;
1916         out_file->track = in_file->track;
1917         strcpy(out_file->genre, in_file->genre);
1918     }
1919
1920     /* open files and write file headers */
1921     for(i=0;i<nb_output_files;i++) {
1922         os = output_files[i];
1923         if (av_write_header(os) < 0) {
1924             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1925             ret = AVERROR(EINVAL);
1926             goto fail;
1927         }
1928         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1929             want_sdp = 0;
1930         }
1931     }
1932     if (want_sdp) {
1933         print_sdp(output_files, nb_output_files);
1934     }
1935
1936     if (!using_stdin && verbose >= 0) {
1937         fprintf(stderr, "Press [q] to stop encoding\n");
1938         url_set_interrupt_cb(decode_interrupt_cb);
1939     }
1940     term_init();
1941
1942     key = -1;
1943     timer_start = av_gettime();
1944
1945     for(; received_sigterm == 0;) {
1946         int file_index, ist_index;
1947         AVPacket pkt;
1948         double ipts_min;
1949         double opts_min;
1950
1951     redo:
1952         ipts_min= 1e100;
1953         opts_min= 1e100;
1954         /* if 'q' pressed, exits */
1955         if (!using_stdin) {
1956             if (q_pressed)
1957                 break;
1958             /* read_key() returns 0 on EOF */
1959             key = read_key();
1960             if (key == 'q')
1961                 break;
1962         }
1963
1964         /* select the stream that we must read now by looking at the
1965            smallest output pts */
1966         file_index = -1;
1967         for(i=0;i<nb_ostreams;i++) {
1968             double ipts, opts;
1969             ost = ost_table[i];
1970             os = output_files[ost->file_index];
1971             ist = ist_table[ost->source_index];
1972             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1973                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1974             else
1975                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1976             ipts = (double)ist->pts;
1977             if (!file_table[ist->file_index].eof_reached){
1978                 if(ipts < ipts_min) {
1979                     ipts_min = ipts;
1980                     if(input_sync ) file_index = ist->file_index;
1981                 }
1982                 if(opts < opts_min) {
1983                     opts_min = opts;
1984                     if(!input_sync) file_index = ist->file_index;
1985                 }
1986             }
1987             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1988                 file_index= -1;
1989                 break;
1990             }
1991         }
1992         /* if none, if is finished */
1993         if (file_index < 0) {
1994             break;
1995         }
1996
1997         /* finish if recording time exhausted */
1998         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1999             break;
2000
2001         /* finish if limit size exhausted */
2002         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2003             break;
2004
2005         /* read a frame from it and output it in the fifo */
2006         is = input_files[file_index];
2007         if (av_read_frame(is, &pkt) < 0) {
2008             file_table[file_index].eof_reached = 1;
2009             if (opt_shortest)
2010                 break;
2011             else
2012                 continue;
2013         }
2014
2015         if (do_pkt_dump) {
2016             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2017         }
2018         /* the following test is needed in case new streams appear
2019            dynamically in stream : we ignore them */
2020         if (pkt.stream_index >= file_table[file_index].nb_streams)
2021             goto discard_packet;
2022         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2023         ist = ist_table[ist_index];
2024         if (ist->discard)
2025             goto discard_packet;
2026
2027         if (pkt.dts != AV_NOPTS_VALUE)
2028             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2029         if (pkt.pts != AV_NOPTS_VALUE)
2030             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2031
2032 //        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);
2033         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2034             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2035             int64_t delta= pkt_dts - ist->next_pts;
2036             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2037                 input_files_ts_offset[ist->file_index]-= delta;
2038                 if (verbose > 2)
2039                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2040                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2041                 if(pkt.pts != AV_NOPTS_VALUE)
2042                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2043             }
2044         }
2045
2046         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2047         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2048
2049             if (verbose >= 0)
2050                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2051                         ist->file_index, ist->index);
2052
2053             av_free_packet(&pkt);
2054             goto redo;
2055         }
2056
2057     discard_packet:
2058         av_free_packet(&pkt);
2059
2060         /* dump report by using the output first video and audio streams */
2061         print_report(output_files, ost_table, nb_ostreams, 0);
2062     }
2063
2064     /* at the end of stream, we must flush the decoder buffers */
2065     for(i=0;i<nb_istreams;i++) {
2066         ist = ist_table[i];
2067         if (ist->decoding_needed) {
2068             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2069         }
2070     }
2071
2072     term_exit();
2073
2074     /* write the trailer if needed and close file */
2075     for(i=0;i<nb_output_files;i++) {
2076         os = output_files[i];
2077         av_write_trailer(os);
2078     }
2079
2080     /* dump report by using the first video and audio streams */
2081     print_report(output_files, ost_table, nb_ostreams, 1);
2082
2083     /* close each encoder */
2084     for(i=0;i<nb_ostreams;i++) {
2085         ost = ost_table[i];
2086         if (ost->encoding_needed) {
2087             av_freep(&ost->st->codec->stats_in);
2088             avcodec_close(ost->st->codec);
2089         }
2090     }
2091
2092     /* close each decoder */
2093     for(i=0;i<nb_istreams;i++) {
2094         ist = ist_table[i];
2095         if (ist->decoding_needed) {
2096             avcodec_close(ist->st->codec);
2097         }
2098     }
2099
2100     /* finished ! */
2101
2102     ret = 0;
2103  fail1:
2104     av_freep(&bit_buffer);
2105     av_free(file_table);
2106
2107     if (ist_table) {
2108         for(i=0;i<nb_istreams;i++) {
2109             ist = ist_table[i];
2110             av_free(ist);
2111         }
2112         av_free(ist_table);
2113     }
2114     if (ost_table) {
2115         for(i=0;i<nb_ostreams;i++) {
2116             ost = ost_table[i];
2117             if (ost) {
2118                 if (ost->logfile) {
2119                     fclose(ost->logfile);
2120                     ost->logfile = NULL;
2121                 }
2122                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2123                                              initialized but set to zero */
2124                 av_free(ost->pict_tmp.data[0]);
2125                 if (ost->video_resample)
2126                     sws_freeContext(ost->img_resample_ctx);
2127                 if (ost->resample)
2128                     audio_resample_close(ost->resample);
2129                 av_free(ost);
2130             }
2131         }
2132         av_free(ost_table);
2133     }
2134     return ret;
2135  fail:
2136     ret = AVERROR(ENOMEM);
2137     goto fail1;
2138 }
2139
2140 #if 0
2141 int file_read(const char *filename)
2142 {
2143     URLContext *h;
2144     unsigned char buffer[1024];
2145     int len, i;
2146
2147     if (url_open(&h, filename, O_RDONLY) < 0) {
2148         printf("could not open '%s'\n", filename);
2149         return -1;
2150     }
2151     for(;;) {
2152         len = url_read(h, buffer, sizeof(buffer));
2153         if (len <= 0)
2154             break;
2155         for(i=0;i<len;i++) putchar(buffer[i]);
2156     }
2157     url_close(h);
2158     return 0;
2159 }
2160 #endif
2161
2162 static void opt_format(const char *arg)
2163 {
2164     /* compatibility stuff for pgmyuv */
2165     if (!strcmp(arg, "pgmyuv")) {
2166         pgmyuv_compatibility_hack=1;
2167 //        opt_image_format(arg);
2168         arg = "image2";
2169         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2170     }
2171
2172     file_iformat = av_find_input_format(arg);
2173     file_oformat = guess_format(arg, NULL, NULL);
2174     if (!file_iformat && !file_oformat) {
2175         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2176         av_exit(1);
2177     }
2178 }
2179
2180 extern int ffm_nopts;
2181
2182 static int opt_default(const char *opt, const char *arg){
2183     int type;
2184     const AVOption *o= NULL;
2185     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2186
2187     for(type=0; type<CODEC_TYPE_NB; type++){
2188         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2189         if(o2)
2190             o = av_set_string(avctx_opts[type], opt, arg);
2191     }
2192     if(!o)
2193         o = av_set_string(avformat_opts, opt, arg);
2194     if(!o)
2195         o = av_set_string(sws_opts, opt, arg);
2196     if(!o){
2197         if(opt[0] == 'a')
2198             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2199         else if(opt[0] == 'v')
2200             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2201         else if(opt[0] == 's')
2202             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2203     }
2204     if(!o)
2205         return -1;
2206
2207 //    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));
2208
2209     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2210     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2211     opt_names[opt_name_count++]= o->name;
2212
2213 #ifdef CONFIG_FFM_MUXER
2214     /* disable generate of real time pts in ffm (need to be supressed anyway) */
2215     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2216         ffm_nopts = 1;
2217 #endif
2218
2219     if(avctx_opts[0]->debug)
2220         av_log_set_level(AV_LOG_DEBUG);
2221     return 0;
2222 }
2223
2224 static void opt_video_rc_override_string(const char *arg)
2225 {
2226     video_rc_override_string = arg;
2227 }
2228
2229 static int opt_me_threshold(const char *opt, const char *arg)
2230 {
2231     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2232     return 0;
2233 }
2234
2235 static int opt_verbose(const char *opt, const char *arg)
2236 {
2237     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2238     av_log_set_level(verbose);
2239     return 0;
2240 }
2241
2242 static void opt_frame_rate(const char *arg)
2243 {
2244     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2245         fprintf(stderr, "Incorrect frame rate\n");
2246         av_exit(1);
2247     }
2248 }
2249
2250 static int opt_bitrate(const char *opt, const char *arg)
2251 {
2252     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2253
2254     opt_default(opt, arg);
2255
2256     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2257         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2258
2259     return 0;
2260 }
2261
2262 static void opt_frame_crop_top(const char *arg)
2263 {
2264     frame_topBand = atoi(arg);
2265     if (frame_topBand < 0) {
2266         fprintf(stderr, "Incorrect top crop size\n");
2267         av_exit(1);
2268     }
2269     if ((frame_topBand % 2) != 0) {
2270         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2271         av_exit(1);
2272     }
2273     if ((frame_topBand) >= frame_height){
2274         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2275         av_exit(1);
2276     }
2277     frame_height -= frame_topBand;
2278 }
2279
2280 static void opt_frame_crop_bottom(const char *arg)
2281 {
2282     frame_bottomBand = atoi(arg);
2283     if (frame_bottomBand < 0) {
2284         fprintf(stderr, "Incorrect bottom crop size\n");
2285         av_exit(1);
2286     }
2287     if ((frame_bottomBand % 2) != 0) {
2288         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2289         av_exit(1);
2290     }
2291     if ((frame_bottomBand) >= frame_height){
2292         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2293         av_exit(1);
2294     }
2295     frame_height -= frame_bottomBand;
2296 }
2297
2298 static void opt_frame_crop_left(const char *arg)
2299 {
2300     frame_leftBand = atoi(arg);
2301     if (frame_leftBand < 0) {
2302         fprintf(stderr, "Incorrect left crop size\n");
2303         av_exit(1);
2304     }
2305     if ((frame_leftBand % 2) != 0) {
2306         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2307         av_exit(1);
2308     }
2309     if ((frame_leftBand) >= frame_width){
2310         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311         av_exit(1);
2312     }
2313     frame_width -= frame_leftBand;
2314 }
2315
2316 static void opt_frame_crop_right(const char *arg)
2317 {
2318     frame_rightBand = atoi(arg);
2319     if (frame_rightBand < 0) {
2320         fprintf(stderr, "Incorrect right crop size\n");
2321         av_exit(1);
2322     }
2323     if ((frame_rightBand % 2) != 0) {
2324         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2325         av_exit(1);
2326     }
2327     if ((frame_rightBand) >= frame_width){
2328         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329         av_exit(1);
2330     }
2331     frame_width -= frame_rightBand;
2332 }
2333
2334 static void opt_frame_size(const char *arg)
2335 {
2336     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2337         fprintf(stderr, "Incorrect frame size\n");
2338         av_exit(1);
2339     }
2340     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2341         fprintf(stderr, "Frame size must be a multiple of 2\n");
2342         av_exit(1);
2343     }
2344 }
2345
2346
2347 #define SCALEBITS 10
2348 #define ONE_HALF  (1 << (SCALEBITS - 1))
2349 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2350
2351 #define RGB_TO_Y(r, g, b) \
2352 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2353   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2354
2355 #define RGB_TO_U(r1, g1, b1, shift)\
2356 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2357      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2358
2359 #define RGB_TO_V(r1, g1, b1, shift)\
2360 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2361    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2362
2363 static void opt_pad_color(const char *arg) {
2364     /* Input is expected to be six hex digits similar to
2365        how colors are expressed in html tags (but without the #) */
2366     int rgb = strtol(arg, NULL, 16);
2367     int r,g,b;
2368
2369     r = (rgb >> 16);
2370     g = ((rgb >> 8) & 255);
2371     b = (rgb & 255);
2372
2373     padcolor[0] = RGB_TO_Y(r,g,b);
2374     padcolor[1] = RGB_TO_U(r,g,b,0);
2375     padcolor[2] = RGB_TO_V(r,g,b,0);
2376 }
2377
2378 static void opt_frame_pad_top(const char *arg)
2379 {
2380     frame_padtop = atoi(arg);
2381     if (frame_padtop < 0) {
2382         fprintf(stderr, "Incorrect top pad size\n");
2383         av_exit(1);
2384     }
2385     if ((frame_padtop % 2) != 0) {
2386         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2387         av_exit(1);
2388     }
2389 }
2390
2391 static void opt_frame_pad_bottom(const char *arg)
2392 {
2393     frame_padbottom = atoi(arg);
2394     if (frame_padbottom < 0) {
2395         fprintf(stderr, "Incorrect bottom pad size\n");
2396         av_exit(1);
2397     }
2398     if ((frame_padbottom % 2) != 0) {
2399         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2400         av_exit(1);
2401     }
2402 }
2403
2404
2405 static void opt_frame_pad_left(const char *arg)
2406 {
2407     frame_padleft = atoi(arg);
2408     if (frame_padleft < 0) {
2409         fprintf(stderr, "Incorrect left pad size\n");
2410         av_exit(1);
2411     }
2412     if ((frame_padleft % 2) != 0) {
2413         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2414         av_exit(1);
2415     }
2416 }
2417
2418
2419 static void opt_frame_pad_right(const char *arg)
2420 {
2421     frame_padright = atoi(arg);
2422     if (frame_padright < 0) {
2423         fprintf(stderr, "Incorrect right pad size\n");
2424         av_exit(1);
2425     }
2426     if ((frame_padright % 2) != 0) {
2427         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2428         av_exit(1);
2429     }
2430 }
2431
2432 static void list_pix_fmts(void)
2433 {
2434     int i;
2435     char pix_fmt_str[128];
2436     for (i=-1; i < PIX_FMT_NB; i++) {
2437         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2438         fprintf(stdout, "%s\n", pix_fmt_str);
2439     }
2440 }
2441
2442 static void opt_frame_pix_fmt(const char *arg)
2443 {
2444     if (strcmp(arg, "list"))
2445         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2446     else {
2447         list_pix_fmts();
2448         av_exit(0);
2449     }
2450 }
2451
2452 static void opt_frame_aspect_ratio(const char *arg)
2453 {
2454     int x = 0, y = 0;
2455     double ar = 0;
2456     const char *p;
2457     char *end;
2458
2459     p = strchr(arg, ':');
2460     if (p) {
2461         x = strtol(arg, &end, 10);
2462         if (end == p)
2463             y = strtol(end+1, &end, 10);
2464         if (x > 0 && y > 0)
2465             ar = (double)x / (double)y;
2466     } else
2467         ar = strtod(arg, NULL);
2468
2469     if (!ar) {
2470         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2471         av_exit(1);
2472     }
2473     frame_aspect_ratio = ar;
2474 }
2475
2476 static void opt_qscale(const char *arg)
2477 {
2478     video_qscale = atof(arg);
2479     if (video_qscale <= 0 ||
2480         video_qscale > 255) {
2481         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2482         av_exit(1);
2483     }
2484 }
2485
2486 static void opt_qdiff(const char *arg)
2487 {
2488     video_qdiff = atoi(arg);
2489     if (video_qdiff < 0 ||
2490         video_qdiff > 31) {
2491         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2492         av_exit(1);
2493     }
2494 }
2495
2496 static void opt_strict(const char *arg)
2497 {
2498     strict= atoi(arg);
2499 }
2500
2501 static void opt_top_field_first(const char *arg)
2502 {
2503     top_field_first= atoi(arg);
2504 }
2505
2506 static void opt_thread_count(const char *arg)
2507 {
2508     thread_count= atoi(arg);
2509 #if !defined(HAVE_THREADS)
2510     if (verbose >= 0)
2511         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2512 #endif
2513 }
2514
2515 static int opt_audio_rate(const char *opt, const char *arg)
2516 {
2517     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2518     return 0;
2519 }
2520
2521 static int opt_audio_channels(const char *opt, const char *arg)
2522 {
2523     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2524     return 0;
2525 }
2526
2527 static void opt_video_channel(const char *arg)
2528 {
2529     video_channel = strtol(arg, NULL, 0);
2530 }
2531
2532 static void opt_video_standard(const char *arg)
2533 {
2534     video_standard = av_strdup(arg);
2535 }
2536
2537 static void opt_codec(int *pstream_copy, char **pcodec_name,
2538                       int codec_type, const char *arg)
2539 {
2540     av_freep(pcodec_name);
2541     if (!strcmp(arg, "copy")) {
2542         *pstream_copy = 1;
2543     } else {
2544         *pcodec_name = av_strdup(arg);
2545     }
2546 }
2547
2548 static void opt_audio_codec(const char *arg)
2549 {
2550     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2551 }
2552
2553 static void opt_audio_tag(const char *arg)
2554 {
2555     char *tail;
2556     audio_codec_tag= strtol(arg, &tail, 0);
2557
2558     if(!tail || *tail)
2559         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2560 }
2561
2562 static void opt_video_tag(const char *arg)
2563 {
2564     char *tail;
2565     video_codec_tag= strtol(arg, &tail, 0);
2566
2567     if(!tail || *tail)
2568         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2569 }
2570
2571 #ifdef CONFIG_VHOOK
2572 static void add_frame_hooker(const char *arg)
2573 {
2574     int argc = 0;
2575     char *argv[64];
2576     int i;
2577     char *args = av_strdup(arg);
2578
2579     using_vhook = 1;
2580
2581     argv[0] = strtok(args, " ");
2582     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2583     }
2584
2585     i = frame_hook_add(argc, argv);
2586
2587     if (i != 0) {
2588         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2589         av_exit(1);
2590     }
2591 }
2592 #endif
2593
2594 static void opt_video_codec(const char *arg)
2595 {
2596     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2597 }
2598
2599 static void opt_subtitle_codec(const char *arg)
2600 {
2601     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2602 }
2603
2604 static void opt_map(const char *arg)
2605 {
2606     AVStreamMap *m;
2607     char *p;
2608
2609     m = &stream_maps[nb_stream_maps++];
2610
2611     m->file_index = strtol(arg, &p, 0);
2612     if (*p)
2613         p++;
2614
2615     m->stream_index = strtol(p, &p, 0);
2616     if (*p) {
2617         p++;
2618         m->sync_file_index = strtol(p, &p, 0);
2619         if (*p)
2620             p++;
2621         m->sync_stream_index = strtol(p, &p, 0);
2622     } else {
2623         m->sync_file_index = m->file_index;
2624         m->sync_stream_index = m->stream_index;
2625     }
2626 }
2627
2628 static void opt_map_meta_data(const char *arg)
2629 {
2630     AVMetaDataMap *m;
2631     char *p;
2632
2633     m = &meta_data_maps[nb_meta_data_maps++];
2634
2635     m->out_file = strtol(arg, &p, 0);
2636     if (*p)
2637         p++;
2638
2639     m->in_file = strtol(p, &p, 0);
2640 }
2641
2642 static int opt_recording_time(const char *opt, const char *arg)
2643 {
2644     recording_time = parse_time_or_die(opt, arg, 1);
2645     return 0;
2646 }
2647
2648 static int opt_start_time(const char *opt, const char *arg)
2649 {
2650     start_time = parse_time_or_die(opt, arg, 1);
2651     return 0;
2652 }
2653
2654 static int opt_rec_timestamp(const char *opt, const char *arg)
2655 {
2656     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2657     return 0;
2658 }
2659
2660 static int opt_input_ts_offset(const char *opt, const char *arg)
2661 {
2662     input_ts_offset = parse_time_or_die(opt, arg, 1);
2663     return 0;
2664 }
2665
2666 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2667 {
2668     const char *codec_string = encoder ? "encoder" : "decoder";
2669     AVCodec *codec;
2670
2671     if(!name)
2672         return CODEC_ID_NONE;
2673     codec = encoder ?
2674         avcodec_find_encoder_by_name(name) :
2675         avcodec_find_decoder_by_name(name);
2676     if(!codec) {
2677         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2678         av_exit(1);
2679     }
2680     if(codec->type != type) {
2681         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2682         av_exit(1);
2683     }
2684     return codec->id;
2685 }
2686
2687 static void opt_input_file(const char *filename)
2688 {
2689     AVFormatContext *ic;
2690     AVFormatParameters params, *ap = &params;
2691     int err, i, ret, rfps, rfps_base;
2692     int64_t timestamp;
2693
2694     if (!strcmp(filename, "-"))
2695         filename = "pipe:";
2696
2697     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2698                     !strcmp(filename, "/dev/stdin");
2699
2700     /* get default parameters from command line */
2701     ic = av_alloc_format_context();
2702
2703     memset(ap, 0, sizeof(*ap));
2704     ap->prealloced_context = 1;
2705     ap->sample_rate = audio_sample_rate;
2706     ap->channels = audio_channels;
2707     ap->time_base.den = frame_rate.num;
2708     ap->time_base.num = frame_rate.den;
2709     ap->width = frame_width + frame_padleft + frame_padright;
2710     ap->height = frame_height + frame_padtop + frame_padbottom;
2711     ap->pix_fmt = frame_pix_fmt;
2712     ap->channel = video_channel;
2713     ap->standard = video_standard;
2714     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2715     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2716     if(pgmyuv_compatibility_hack)
2717         ap->video_codec_id= CODEC_ID_PGMYUV;
2718
2719     for(i=0; i<opt_name_count; i++){
2720         char buf[256];
2721         const AVOption *opt;
2722         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2723         if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2724             av_set_string(ic, opt_names[i], str);
2725     }
2726
2727     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2728     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2729     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2730
2731     /* open the input file with generic libav function */
2732     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2733     if (err < 0) {
2734         print_error(filename, err);
2735         av_exit(1);
2736     }
2737     if(opt_programid) {
2738         int i;
2739         for(i=0; i<ic->nb_programs; i++)
2740             if(ic->programs[i]->id != opt_programid)
2741                 ic->programs[i]->discard = AVDISCARD_ALL;
2742     }
2743
2744     ic->loop_input = loop_input;
2745
2746     /* If not enough info to get the stream parameters, we decode the
2747        first frames to get it. (used in mpeg case for example) */
2748     ret = av_find_stream_info(ic);
2749     if (ret < 0 && verbose >= 0) {
2750         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2751         av_exit(1);
2752     }
2753
2754     timestamp = start_time;
2755     /* add the stream start time */
2756     if (ic->start_time != AV_NOPTS_VALUE)
2757         timestamp += ic->start_time;
2758
2759     /* if seeking requested, we execute it */
2760     if (start_time != 0) {
2761         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2762         if (ret < 0) {
2763             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2764                     filename, (double)timestamp / AV_TIME_BASE);
2765         }
2766         /* reset seek info */
2767         start_time = 0;
2768     }
2769
2770     /* update the current parameters so that they match the one of the input stream */
2771     for(i=0;i<ic->nb_streams;i++) {
2772         int j;
2773         AVCodecContext *enc = ic->streams[i]->codec;
2774         if(thread_count>1)
2775             avcodec_thread_init(enc, thread_count);
2776         enc->thread_count= thread_count;
2777         switch(enc->codec_type) {
2778         case CODEC_TYPE_AUDIO:
2779             for(j=0; j<opt_name_count; j++){
2780                 char buf[256];
2781                 const AVOption *opt;
2782                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2783                 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2784                     av_set_string(enc, opt_names[j], str);
2785             }
2786             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2787             audio_channels = enc->channels;
2788             audio_sample_rate = enc->sample_rate;
2789             if(audio_disable)
2790                 ic->streams[i]->discard= AVDISCARD_ALL;
2791             break;
2792         case CODEC_TYPE_VIDEO:
2793             for(j=0; j<opt_name_count; j++){
2794                 char buf[256];
2795                 const AVOption *opt;
2796                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2797                 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2798                     av_set_string(enc, opt_names[j], str);
2799             }
2800             frame_height = enc->height;
2801             frame_width = enc->width;
2802             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2803             frame_pix_fmt = enc->pix_fmt;
2804             rfps      = ic->streams[i]->r_frame_rate.num;
2805             rfps_base = ic->streams[i]->r_frame_rate.den;
2806             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2807             if(me_threshold)
2808                 enc->debug |= FF_DEBUG_MV;
2809
2810             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2811
2812                 if (verbose >= 0)
2813                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2814                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2815
2816                     (float)rfps / rfps_base, rfps, rfps_base);
2817             }
2818             /* update the current frame rate to match the stream frame rate */
2819             frame_rate.num = rfps;
2820             frame_rate.den = rfps_base;
2821
2822             enc->rate_emu = rate_emu;
2823             if(video_disable)
2824                 ic->streams[i]->discard= AVDISCARD_ALL;
2825             else if(video_discard)
2826                 ic->streams[i]->discard= video_discard;
2827             break;
2828         case CODEC_TYPE_DATA:
2829             break;
2830         case CODEC_TYPE_SUBTITLE:
2831             if(subtitle_disable)
2832                 ic->streams[i]->discard = AVDISCARD_ALL;
2833             break;
2834         case CODEC_TYPE_ATTACHMENT:
2835         case CODEC_TYPE_UNKNOWN:
2836             break;
2837         default:
2838             abort();
2839         }
2840     }
2841
2842     input_files[nb_input_files] = ic;
2843     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2844     /* dump the file content */
2845     if (verbose >= 0)
2846         dump_format(ic, nb_input_files, filename, 0);
2847
2848     nb_input_files++;
2849     file_iformat = NULL;
2850     file_oformat = NULL;
2851
2852     video_channel = 0;
2853
2854     rate_emu = 0;
2855     av_freep(&video_codec_name);
2856     av_freep(&audio_codec_name);
2857     av_freep(&subtitle_codec_name);
2858 }
2859
2860 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2861                                          int *has_subtitle_ptr)
2862 {
2863     int has_video, has_audio, has_subtitle, i, j;
2864     AVFormatContext *ic;
2865
2866     has_video = 0;
2867     has_audio = 0;
2868     has_subtitle = 0;
2869     for(j=0;j<nb_input_files;j++) {
2870         ic = input_files[j];
2871         for(i=0;i<ic->nb_streams;i++) {
2872             AVCodecContext *enc = ic->streams[i]->codec;
2873             switch(enc->codec_type) {
2874             case CODEC_TYPE_AUDIO:
2875                 has_audio = 1;
2876                 break;
2877             case CODEC_TYPE_VIDEO:
2878                 has_video = 1;
2879                 break;
2880             case CODEC_TYPE_SUBTITLE:
2881                 has_subtitle = 1;
2882                 break;
2883             case CODEC_TYPE_DATA:
2884             case CODEC_TYPE_ATTACHMENT:
2885             case CODEC_TYPE_UNKNOWN:
2886                 break;
2887             default:
2888                 abort();
2889             }
2890         }
2891     }
2892     *has_video_ptr = has_video;
2893     *has_audio_ptr = has_audio;
2894     *has_subtitle_ptr = has_subtitle;
2895 }
2896
2897 static void new_video_stream(AVFormatContext *oc)
2898 {
2899     AVStream *st;
2900     AVCodecContext *video_enc;
2901     int codec_id;
2902
2903     st = av_new_stream(oc, oc->nb_streams);
2904     if (!st) {
2905         fprintf(stderr, "Could not alloc stream\n");
2906         av_exit(1);
2907     }
2908     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2909     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2910     video_bitstream_filters= NULL;
2911
2912     if(thread_count>1)
2913         avcodec_thread_init(st->codec, thread_count);
2914
2915     video_enc = st->codec;
2916
2917     if(video_codec_tag)
2918         video_enc->codec_tag= video_codec_tag;
2919
2920     if(   (video_global_header&1)
2921        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2922         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2923         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2924     }
2925     if(video_global_header&2){
2926         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2927         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2928     }
2929
2930     if (video_stream_copy) {
2931         st->stream_copy = 1;
2932         video_enc->codec_type = CODEC_TYPE_VIDEO;
2933     } else {
2934         const char *p;
2935         int i;
2936         AVCodec *codec;
2937         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2938
2939         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2940         if (video_codec_name)
2941             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2942
2943         video_enc->codec_id = codec_id;
2944         codec = avcodec_find_encoder(codec_id);
2945
2946         for(i=0; i<opt_name_count; i++){
2947             char buf[256];
2948             const AVOption *opt;
2949             const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2950             if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2951                 av_set_string(video_enc, opt_names[i], str);
2952         }
2953
2954         video_enc->time_base.den = fps.num;
2955         video_enc->time_base.num = fps.den;
2956         if(codec && codec->supported_framerates){
2957             const AVRational *p= codec->supported_framerates;
2958             const AVRational *best=NULL;
2959             AVRational best_error= (AVRational){INT_MAX, 1};
2960             for(; p->den!=0; p++){
2961                 AVRational error= av_sub_q(fps, *p);
2962                 if(error.num <0) error.num *= -1;
2963                 if(av_cmp_q(error, best_error) < 0){
2964                     best_error= error;
2965                     best= p;
2966                 }
2967             }
2968             video_enc->time_base.den= best->num;
2969             video_enc->time_base.num= best->den;
2970         }
2971
2972         video_enc->width = frame_width + frame_padright + frame_padleft;
2973         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2974         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2975         video_enc->pix_fmt = frame_pix_fmt;
2976
2977         if(codec && codec->pix_fmts){
2978             const enum PixelFormat *p= codec->pix_fmts;
2979             for(; *p!=-1; p++){
2980                 if(*p == video_enc->pix_fmt)
2981                     break;
2982             }
2983             if(*p == -1)
2984                 video_enc->pix_fmt = codec->pix_fmts[0];
2985         }
2986
2987         if (intra_only)
2988             video_enc->gop_size = 0;
2989         if (video_qscale || same_quality) {
2990             video_enc->flags |= CODEC_FLAG_QSCALE;
2991             video_enc->global_quality=
2992                 st->quality = FF_QP2LAMBDA * video_qscale;
2993         }
2994
2995         if(intra_matrix)
2996             video_enc->intra_matrix = intra_matrix;
2997         if(inter_matrix)
2998             video_enc->inter_matrix = inter_matrix;
2999
3000         video_enc->max_qdiff = video_qdiff;
3001         video_enc->thread_count = thread_count;
3002         p= video_rc_override_string;
3003         for(i=0; p; i++){
3004             int start, end, q;
3005             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3006             if(e!=3){
3007                 fprintf(stderr, "error parsing rc_override\n");
3008                 av_exit(1);
3009             }
3010             video_enc->rc_override=
3011                 av_realloc(video_enc->rc_override,
3012                            sizeof(RcOverride)*(i+1));
3013             video_enc->rc_override[i].start_frame= start;
3014             video_enc->rc_override[i].end_frame  = end;
3015             if(q>0){
3016                 video_enc->rc_override[i].qscale= q;
3017                 video_enc->rc_override[i].quality_factor= 1.0;
3018             }
3019             else{
3020                 video_enc->rc_override[i].qscale= 0;
3021                 video_enc->rc_override[i].quality_factor= -q/100.0;
3022             }
3023             p= strchr(p, '/');
3024             if(p) p++;
3025         }
3026         video_enc->rc_override_count=i;
3027         if (!video_enc->rc_initial_buffer_occupancy)
3028             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3029         video_enc->me_threshold= me_threshold;
3030         video_enc->intra_dc_precision= intra_dc_precision - 8;
3031         video_enc->strict_std_compliance = strict;
3032
3033         if (do_psnr)
3034             video_enc->flags|= CODEC_FLAG_PSNR;
3035
3036         /* two pass mode */
3037         if (do_pass) {
3038             if (do_pass == 1) {
3039                 video_enc->flags |= CODEC_FLAG_PASS1;
3040             } else {
3041                 video_enc->flags |= CODEC_FLAG_PASS2;
3042             }
3043         }
3044     }
3045
3046     /* reset some key parameters */
3047     video_disable = 0;
3048     av_freep(&video_codec_name);
3049     video_stream_copy = 0;
3050 }
3051
3052 static void new_audio_stream(AVFormatContext *oc)
3053 {
3054     AVStream *st;
3055     AVCodecContext *audio_enc;
3056     int codec_id, i;
3057
3058     st = av_new_stream(oc, oc->nb_streams);
3059     if (!st) {
3060         fprintf(stderr, "Could not alloc stream\n");
3061         av_exit(1);
3062     }
3063     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3064
3065     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3066     audio_bitstream_filters= NULL;
3067
3068     if(thread_count>1)
3069         avcodec_thread_init(st->codec, thread_count);
3070
3071     audio_enc = st->codec;
3072     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3073     audio_enc->strict_std_compliance = strict;
3074
3075     if(audio_codec_tag)
3076         audio_enc->codec_tag= audio_codec_tag;
3077
3078     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3079         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3080         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3081     }
3082     if (audio_stream_copy) {
3083         st->stream_copy = 1;
3084         audio_enc->channels = audio_channels;
3085     } else {
3086         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3087
3088         for(i=0; i<opt_name_count; i++){
3089             char buf[256];
3090             const AVOption *opt;
3091             const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3092             if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3093                 av_set_string(audio_enc, opt_names[i], str);
3094         }
3095
3096         if (audio_codec_name)
3097             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3098         audio_enc->codec_id = codec_id;
3099
3100         if (audio_qscale > QSCALE_NONE) {
3101             audio_enc->flags |= CODEC_FLAG_QSCALE;
3102             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3103         }
3104         audio_enc->thread_count = thread_count;
3105         audio_enc->channels = audio_channels;
3106     }
3107     audio_enc->sample_rate = audio_sample_rate;
3108     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3109     if (audio_language) {
3110         av_strlcpy(st->language, audio_language, sizeof(st->language));
3111         av_free(audio_language);
3112         audio_language = NULL;
3113     }
3114
3115     /* reset some key parameters */
3116     audio_disable = 0;
3117     av_freep(&audio_codec_name);
3118     audio_stream_copy = 0;
3119 }
3120
3121 static void new_subtitle_stream(AVFormatContext *oc)
3122 {
3123     AVStream *st;
3124     AVCodecContext *subtitle_enc;
3125     int i;
3126
3127     st = av_new_stream(oc, oc->nb_streams);
3128     if (!st) {
3129         fprintf(stderr, "Could not alloc stream\n");
3130         av_exit(1);
3131     }
3132     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3133
3134     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3135     subtitle_bitstream_filters= NULL;
3136
3137     subtitle_enc = st->codec;
3138     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3139     if (subtitle_stream_copy) {
3140         st->stream_copy = 1;
3141     } else {
3142         for(i=0; i<opt_name_count; i++){
3143             char buf[256];
3144             const AVOption *opt;
3145             const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3146             if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3147                 av_set_string(subtitle_enc, opt_names[i], str);
3148         }
3149         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3150     }
3151
3152     if (subtitle_language) {
3153         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3154         av_free(subtitle_language);
3155         subtitle_language = NULL;
3156     }
3157
3158     subtitle_disable = 0;
3159     av_freep(&subtitle_codec_name);
3160     subtitle_stream_copy = 0;
3161 }
3162
3163 static void opt_new_audio_stream(void)
3164 {
3165     AVFormatContext *oc;
3166     if (nb_output_files <= 0) {
3167         fprintf(stderr, "At least one output file must be specified\n");
3168         av_exit(1);
3169     }
3170     oc = output_files[nb_output_files - 1];
3171     new_audio_stream(oc);
3172 }
3173
3174 static void opt_new_video_stream(void)
3175 {
3176     AVFormatContext *oc;
3177     if (nb_output_files <= 0) {
3178         fprintf(stderr, "At least one output file must be specified\n");
3179         av_exit(1);
3180     }
3181     oc = output_files[nb_output_files - 1];
3182     new_video_stream(oc);
3183 }
3184
3185 static void opt_new_subtitle_stream(void)
3186 {
3187     AVFormatContext *oc;
3188     if (nb_output_files <= 0) {
3189         fprintf(stderr, "At least one output file must be specified\n");
3190         av_exit(1);
3191     }
3192     oc = output_files[nb_output_files - 1];
3193     new_subtitle_stream(oc);
3194 }
3195
3196 static void opt_output_file(const char *filename)
3197 {
3198     AVFormatContext *oc;
3199     int use_video, use_audio, use_subtitle;
3200     int input_has_video, input_has_audio, input_has_subtitle, i;
3201     AVFormatParameters params, *ap = &params;
3202
3203     if (!strcmp(filename, "-"))
3204         filename = "pipe:";
3205
3206     oc = av_alloc_format_context();
3207
3208     if (!file_oformat) {
3209         file_oformat = guess_format(NULL, filename, NULL);
3210         if (!file_oformat) {
3211             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3212                     filename);
3213             av_exit(1);
3214         }
3215     }
3216
3217     oc->oformat = file_oformat;
3218     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3219
3220     if (!strcmp(file_oformat->name, "ffm") &&
3221         av_strstart(filename, "http:", NULL)) {
3222         /* special case for files sent to ffserver: we get the stream
3223            parameters from ffserver */
3224         if (read_ffserver_streams(oc, filename) < 0) {
3225             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3226             av_exit(1);
3227         }
3228     } else {
3229         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3230         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3231         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3232
3233         /* disable if no corresponding type found and at least one
3234            input file */
3235         if (nb_input_files > 0) {
3236             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3237                                          &input_has_subtitle);
3238             if (!input_has_video)
3239                 use_video = 0;
3240             if (!input_has_audio)
3241                 use_audio = 0;
3242             if (!input_has_subtitle)
3243                 use_subtitle = 0;
3244         }
3245
3246         /* manual disable */
3247         if (audio_disable) {
3248             use_audio = 0;
3249         }
3250         if (video_disable) {
3251             use_video = 0;
3252         }
3253         if (subtitle_disable) {
3254             use_subtitle = 0;
3255         }
3256
3257         if (use_video) {
3258             new_video_stream(oc);
3259         }
3260
3261         if (use_audio) {
3262             new_audio_stream(oc);
3263         }
3264
3265         if (use_subtitle) {
3266             new_subtitle_stream(oc);
3267         }
3268
3269         oc->timestamp = rec_timestamp;
3270
3271         if (str_title)
3272             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3273         if (str_author)
3274             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3275         if (str_copyright)
3276             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3277         if (str_comment)
3278             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3279         if (str_album)
3280             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3281         if (str_genre)
3282             av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3283     }
3284
3285     output_files[nb_output_files++] = oc;
3286
3287     /* check filename in case of an image number is expected */
3288     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3289         if (!av_filename_number_test(oc->filename)) {
3290             print_error(oc->filename, AVERROR_NUMEXPECTED);
3291             av_exit(1);
3292         }
3293     }
3294
3295     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3296         /* test if it already exists to avoid loosing precious files */
3297         if (!file_overwrite &&
3298             (strchr(filename, ':') == NULL ||
3299              filename[1] == ':' ||
3300              av_strstart(filename, "file:", NULL))) {
3301             if (url_exist(filename)) {
3302                 int c;
3303
3304                 if (!using_stdin) {
3305                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3306                     fflush(stderr);
3307                     c = getchar();
3308                     if (toupper(c) != 'Y') {
3309                         fprintf(stderr, "Not overwriting - exiting\n");
3310                         av_exit(1);
3311                     }
3312                 }
3313                 else {
3314                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3315                     av_exit(1);
3316                 }
3317             }
3318         }
3319
3320         /* open the file */
3321         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3322             fprintf(stderr, "Could not open '%s'\n", filename);
3323             av_exit(1);
3324         }
3325     }
3326
3327     memset(ap, 0, sizeof(*ap));
3328     if (av_set_parameters(oc, ap) < 0) {
3329         fprintf(stderr, "%s: Invalid encoding parameters\n",
3330                 oc->filename);
3331         av_exit(1);
3332     }
3333
3334     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3335     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3336     oc->loop_output = loop_output;
3337
3338     for(i=0; i<opt_name_count; i++){
3339         char buf[256];
3340         const AVOption *opt;
3341         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3342         if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3343             av_set_string(oc, opt_names[i], str);
3344     }
3345
3346     /* reset some options */
3347     file_oformat = NULL;
3348     file_iformat = NULL;
3349 }
3350
3351 /* same option as mencoder */
3352 static void opt_pass(const char *pass_str)
3353 {
3354     int pass;
3355     pass = atoi(pass_str);
3356     if (pass != 1 && pass != 2) {
3357         fprintf(stderr, "pass number can be only 1 or 2\n");
3358         av_exit(1);
3359     }
3360     do_pass = pass;
3361 }
3362
3363 static int64_t getutime(void)
3364 {
3365 #ifdef HAVE_GETRUSAGE
3366     struct rusage rusage;
3367
3368     getrusage(RUSAGE_SELF, &rusage);
3369     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3370 #elif defined(HAVE_GETPROCESSTIMES)
3371     HANDLE proc;
3372     FILETIME c, e, k, u;
3373     proc = GetCurrentProcess();
3374     GetProcessTimes(proc, &c, &e, &k, &u);
3375     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3376 #else
3377     return av_gettime();
3378 #endif
3379 }
3380
3381 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3382 {
3383     int i;
3384     const char *p = str;
3385     for(i = 0;; i++) {
3386         dest[i] = atoi(p);
3387         if(i == 63)
3388             break;
3389         p = strchr(p, ',');
3390         if(!p) {
3391             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3392             av_exit(1);
3393         }
3394         p++;
3395     }
3396 }
3397
3398 static void opt_inter_matrix(const char *arg)
3399 {
3400     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3401     parse_matrix_coeffs(inter_matrix, arg);
3402 }
3403
3404 static void opt_intra_matrix(const char *arg)
3405 {
3406     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3407     parse_matrix_coeffs(intra_matrix, arg);
3408 }
3409
3410 /**
3411  * Trivial log callback.
3412  * Only suitable for show_help and similar since it lacks prefix handling.
3413  */
3414 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3415 {
3416     vfprintf(stdout, fmt, vl);
3417 }
3418
3419 static void show_help(void)
3420 {
3421     av_log_set_callback(log_callback_help);
3422     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3423            "Hyper fast Audio and Video encoder\n");
3424     printf("\n");
3425     show_help_options(options, "Main options:\n",
3426                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3427     show_help_options(options, "\nVideo options:\n",
3428                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3429                       OPT_VIDEO);
3430     show_help_options(options, "\nAdvanced Video options:\n",
3431                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3432                       OPT_VIDEO | OPT_EXPERT);
3433     show_help_options(options, "\nAudio options:\n",
3434                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3435                       OPT_AUDIO);
3436     show_help_options(options, "\nAdvanced Audio options:\n",
3437                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3438                       OPT_AUDIO | OPT_EXPERT);
3439     show_help_options(options, "\nSubtitle options:\n",
3440                       OPT_SUBTITLE | OPT_GRAB,
3441                       OPT_SUBTITLE);
3442     show_help_options(options, "\nAudio/Video grab options:\n",
3443                       OPT_GRAB,
3444                       OPT_GRAB);
3445     show_help_options(options, "\nAdvanced options:\n",
3446                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3447                       OPT_EXPERT);
3448     av_opt_show(avctx_opts[0], NULL);
3449     av_opt_show(avformat_opts, NULL);
3450     av_opt_show(sws_opts, NULL);
3451 }
3452
3453 static void opt_target(const char *arg)
3454 {
3455     int norm = -1;
3456     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3457
3458     if(!strncmp(arg, "pal-", 4)) {
3459         norm = 0;
3460         arg += 4;
3461     } else if(!strncmp(arg, "ntsc-", 5)) {
3462         norm = 1;
3463         arg += 5;
3464     } else if(!strncmp(arg, "film-", 5)) {
3465         norm = 2;
3466         arg += 5;
3467     } else {
3468         int fr;
3469         /* Calculate FR via float to avoid int overflow */
3470         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3471         if(fr == 25000) {
3472             norm = 0;
3473         } else if((fr == 29970) || (fr == 23976)) {
3474             norm = 1;
3475         } else {
3476             /* Try to determine PAL/NTSC by peeking in the input files */
3477             if(nb_input_files) {
3478                 int i, j;
3479                 for(j = 0; j < nb_input_files; j++) {
3480                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3481                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3482                         if(c->codec_type != CODEC_TYPE_VIDEO)
3483                             continue;
3484                         fr = c->time_base.den * 1000 / c->time_base.num;
3485                         if(fr == 25000) {
3486                             norm = 0;
3487                             break;
3488                         } else if((fr == 29970) || (fr == 23976)) {
3489                             norm = 1;
3490                             break;
3491                         }
3492                     }
3493                     if(norm >= 0)
3494                         break;
3495                 }
3496             }
3497         }
3498         if(verbose && norm >= 0)
3499             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3500     }
3501
3502     if(norm < 0) {
3503         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3504         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3505         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3506         av_exit(1);
3507     }
3508
3509     if(!strcmp(arg, "vcd")) {
3510
3511         opt_video_codec("mpeg1video");
3512         opt_audio_codec("mp2");
3513         opt_format("vcd");
3514
3515         opt_frame_size(norm ? "352x240" : "352x288");
3516         opt_frame_rate(frame_rates[norm]);
3517         opt_default("gop", norm ? "18" : "15");
3518
3519         opt_default("b", "1150000");
3520         opt_default("maxrate", "1150000");
3521         opt_default("minrate", "1150000");
3522         opt_default("bufsize", "327680"); // 40*1024*8;
3523
3524         opt_default("ab", "224000");
3525         audio_sample_rate = 44100;
3526         audio_channels = 2;
3527
3528         opt_default("packetsize", "2324");
3529         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3530
3531         /* We have to offset the PTS, so that it is consistent with the SCR.
3532            SCR starts at 36000, but the first two packs contain only padding
3533            and the first pack from the other stream, respectively, may also have
3534            been written before.
3535            So the real data starts at SCR 36000+3*1200. */
3536         mux_preload= (36000+3*1200) / 90000.0; //0.44
3537     } else if(!strcmp(arg, "svcd")) {
3538
3539         opt_video_codec("mpeg2video");
3540         opt_audio_codec("mp2");
3541         opt_format("svcd");
3542
3543         opt_frame_size(norm ? "480x480" : "480x576");
3544         opt_frame_rate(frame_rates[norm]);
3545         opt_default("gop", norm ? "18" : "15");
3546
3547         opt_default("b", "2040000");
3548         opt_default("maxrate", "2516000");
3549         opt_default("minrate", "0"); //1145000;
3550         opt_default("bufsize", "1835008"); //224*1024*8;
3551         opt_default("flags", "+SCAN_OFFSET");
3552
3553
3554         opt_default("ab", "224000");
3555         audio_sample_rate = 44100;
3556
3557         opt_default("packetsize", "2324");
3558
3559     } else if(!strcmp(arg, "dvd")) {
3560
3561         opt_video_codec("mpeg2video");
3562         opt_audio_codec("ac3");
3563         opt_format("dvd");
3564
3565         opt_frame_size(norm ? "720x480" : "720x576");
3566         opt_frame_rate(frame_rates[norm]);
3567         opt_default("gop", norm ? "18" : "15");
3568
3569         opt_default("b", "6000000");
3570         opt_default("maxrate", "9000000");
3571         opt_default("minrate", "0"); //1500000;
3572         opt_default("bufsize", "1835008"); //224*1024*8;
3573
3574         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3575         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3576
3577         opt_default("ab", "448000");
3578         audio_sample_rate = 48000;
3579
3580     } else if(!strncmp(arg, "dv", 2)) {
3581
3582         opt_format("dv");
3583
3584         opt_frame_size(norm ? "720x480" : "720x576");
3585         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3586                                              (norm ? "yuv411p" : "yuv420p"));
3587         opt_frame_rate(frame_rates[norm]);
3588
3589         audio_sample_rate = 48000;
3590         audio_channels = 2;
3591
3592     } else {
3593         fprintf(stderr, "Unknown target: %s\n", arg);
3594         av_exit(1);
3595     }
3596 }
3597
3598 static void opt_vstats_file (const char *arg)
3599 {
3600     av_free (vstats_filename);
3601     vstats_filename=av_strdup (arg);
3602 }
3603
3604 static void opt_vstats (void)
3605 {
3606     char filename[40];
3607     time_t today2 = time(NULL);
3608     struct tm *today = localtime(&today2);
3609
3610     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3611              today->tm_sec);
3612     opt_vstats_file(filename);
3613 }
3614
3615 static int opt_bsf(const char *opt, const char *arg)
3616 {
3617     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3618     AVBitStreamFilterContext **bsfp;
3619
3620     if(!bsfc){
3621         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3622         av_exit(1);
3623     }
3624
3625     bsfp= *opt == 'v' ? &video_bitstream_filters :
3626           *opt == 'a' ? &audio_bitstream_filters :
3627                         &subtitle_bitstream_filters;
3628     while(*bsfp)
3629         bsfp= &(*bsfp)->next;
3630
3631     *bsfp= bsfc;
3632
3633     return 0;
3634 }
3635
3636 static const OptionDef options[] = {
3637     /* main options */
3638     { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3639     { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3640     { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3641     { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3642     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3643     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3644     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3645     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3646     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3647     { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3648     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3649     { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3650     { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3651     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3652     { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3653     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3654     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3655     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3656     { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3657     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3658     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3659       "add timings for benchmarking" },
3660     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3661       "dump each input packet" },
3662     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3663       "when dumping packets, also dump the payload" },
3664     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3665     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3666     { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3667     { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3668     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3669     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3670     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3671     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3672     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3673     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3674     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3675     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3676     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3677     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3678
3679     /* video options */
3680     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3681     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3682     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3683     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3684     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3685     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3686     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3687     { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3688     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3689     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3690     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3691     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3692     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3693     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3694     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3695     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3696     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3697     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3698     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3699     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3700     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3701     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3702     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3703     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3704     { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "threshold" },
3705     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3706     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3707       "use same video quality as source (implies VBR)" },
3708     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3709     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3710     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3711       "deinterlace pictures" },
3712     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3713     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3714     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3715 #ifdef CONFIG_VHOOK
3716     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3717 #endif
3718     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3719     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3720     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3721     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3722     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3723     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3724     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3725
3726     /* audio options */
3727     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3728     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3729     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3730     { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3731     { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3732     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3733     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3734     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3735     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3736     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3737     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3738
3739     /* subtitle options */
3740     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3741     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3742     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3743     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3744
3745     /* grab options */
3746     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3747     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3748     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3749
3750     /* muxer options */
3751     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3752     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3753
3754     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3755     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3756     { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3757
3758     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3759     { NULL, },
3760 };
3761
3762 int main(int argc, char **argv)
3763 {
3764     int i;
3765     int64_t ti;
3766
3767     avcodec_register_all();
3768     avdevice_register_all();
3769     av_register_all();
3770
3771     for(i=0; i<CODEC_TYPE_NB; i++){
3772         avctx_opts[i]= avcodec_alloc_context2(i);
3773     }
3774     avformat_opts = av_alloc_format_context();
3775     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3776
3777     show_banner();
3778     if (argc <= 1) {
3779         show_help();
3780         av_exit(1);
3781     }
3782
3783     /* parse options */
3784     parse_options(argc, argv, options, opt_output_file);
3785
3786     /* file converter / grab */
3787     if (nb_output_files <= 0) {
3788         fprintf(stderr, "Must supply at least one output file\n");
3789         av_exit(1);
3790     }
3791
3792     if (nb_input_files == 0) {
3793         fprintf(stderr, "Must supply at least one input file\n");
3794         av_exit(1);
3795     }
3796
3797     ti = getutime();
3798     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3799               stream_maps, nb_stream_maps);
3800     ti = getutime() - ti;
3801     if (do_benchmark) {
3802         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3803     }
3804
3805     return av_exit(0);
3806 }