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