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