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