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