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