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