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