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