Check for Decoder_Interface_init() instead of Speech_Decode_Frame_init() when
[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 osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1469                                 int fs_tmp = enc->frame_size;
1470                                 enc->frame_size = fifo_bytes / (osize * enc->channels);
1471                                 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1472                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1473                                 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1474                                                           ost->st->time_base.num, enc->sample_rate);
1475                                 enc->frame_size = fs_tmp;
1476                             }
1477                             if(ret <= 0) {
1478                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1479                             }
1480                             if (ret < 0) {
1481                                 fprintf(stderr, "Audio encoding failed\n");
1482                                 av_exit(1);
1483                             }
1484                             audio_size += ret;
1485                             pkt.flags |= PKT_FLAG_KEY;
1486                             break;
1487                         case CODEC_TYPE_VIDEO:
1488                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1489                             if (ret < 0) {
1490                                 fprintf(stderr, "Video encoding failed\n");
1491                                 av_exit(1);
1492                             }
1493                             video_size += ret;
1494                             if(enc->coded_frame && enc->coded_frame->key_frame)
1495                                 pkt.flags |= PKT_FLAG_KEY;
1496                             if (ost->logfile && enc->stats_out) {
1497                                 fprintf(ost->logfile, "%s", enc->stats_out);
1498                             }
1499                             break;
1500                         default:
1501                             ret=-1;
1502                         }
1503
1504                         if(ret<=0)
1505                             break;
1506                         pkt.data= bit_buffer;
1507                         pkt.size= ret;
1508                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1509                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1510                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1511                     }
1512                 }
1513             }
1514         }
1515     }
1516
1517     return 0;
1518  fail_decode:
1519     return -1;
1520 }
1521
1522 static void print_sdp(AVFormatContext **avc, int n)
1523 {
1524     char sdp[2048];
1525
1526     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1527     printf("SDP:\n%s\n", sdp);
1528     fflush(stdout);
1529 }
1530
1531 static int stream_index_from_inputs(AVFormatContext **input_files,
1532                                     int nb_input_files,
1533                                     AVInputFile *file_table,
1534                                     AVInputStream **ist_table,
1535                                     enum CodecType type,
1536                                     int programid)
1537 {
1538     int p, q, z;
1539     for(z=0; z<nb_input_files; z++) {
1540         AVFormatContext *ic = input_files[z];
1541         for(p=0; p<ic->nb_programs; p++) {
1542             AVProgram *program = ic->programs[p];
1543             if(program->id != programid)
1544                 continue;
1545             for(q=0; q<program->nb_stream_indexes; q++) {
1546                 int sidx = program->stream_index[q];
1547                 int ris = file_table[z].ist_index + sidx;
1548                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1549                     return ris;
1550             }
1551         }
1552     }
1553
1554     return -1;
1555 }
1556
1557 /*
1558  * The following code is the main loop of the file converter
1559  */
1560 static int av_encode(AVFormatContext **output_files,
1561                      int nb_output_files,
1562                      AVFormatContext **input_files,
1563                      int nb_input_files,
1564                      AVStreamMap *stream_maps, int nb_stream_maps)
1565 {
1566     int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1567     AVFormatContext *is, *os;
1568     AVCodecContext *codec, *icodec;
1569     AVOutputStream *ost, **ost_table = NULL;
1570     AVInputStream *ist, **ist_table = NULL;
1571     AVInputFile *file_table;
1572     char error[1024];
1573     int key;
1574     int want_sdp = 1;
1575     uint8_t no_packet[MAX_FILES]={0};
1576     int no_packet_count=0;
1577
1578     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1579     if (!file_table)
1580         goto fail;
1581
1582     /* input stream init */
1583     j = 0;
1584     for(i=0;i<nb_input_files;i++) {
1585         is = input_files[i];
1586         file_table[i].ist_index = j;
1587         file_table[i].nb_streams = is->nb_streams;
1588         j += is->nb_streams;
1589     }
1590     nb_istreams = j;
1591
1592     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1593     if (!ist_table)
1594         goto fail;
1595
1596     for(i=0;i<nb_istreams;i++) {
1597         ist = av_mallocz(sizeof(AVInputStream));
1598         if (!ist)
1599             goto fail;
1600         ist_table[i] = ist;
1601     }
1602     j = 0;
1603     for(i=0;i<nb_input_files;i++) {
1604         is = input_files[i];
1605         for(k=0;k<is->nb_streams;k++) {
1606             ist = ist_table[j++];
1607             ist->st = is->streams[k];
1608             ist->file_index = i;
1609             ist->index = k;
1610             ist->discard = 1; /* the stream is discarded by default
1611                                  (changed later) */
1612
1613             if (rate_emu) {
1614                 ist->start = av_gettime();
1615             }
1616         }
1617     }
1618
1619     /* output stream init */
1620     nb_ostreams = 0;
1621     for(i=0;i<nb_output_files;i++) {
1622         os = output_files[i];
1623         if (!os->nb_streams) {
1624             dump_format(output_files[i], i, output_files[i]->filename, 1);
1625             fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1626             av_exit(1);
1627         }
1628         nb_ostreams += os->nb_streams;
1629     }
1630     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1631         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1632         av_exit(1);
1633     }
1634
1635     /* Sanity check the mapping args -- do the input files & streams exist? */
1636     for(i=0;i<nb_stream_maps;i++) {
1637         int fi = stream_maps[i].file_index;
1638         int si = stream_maps[i].stream_index;
1639
1640         if (fi < 0 || fi > nb_input_files - 1 ||
1641             si < 0 || si > file_table[fi].nb_streams - 1) {
1642             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1643             av_exit(1);
1644         }
1645         fi = stream_maps[i].sync_file_index;
1646         si = stream_maps[i].sync_stream_index;
1647         if (fi < 0 || fi > nb_input_files - 1 ||
1648             si < 0 || si > file_table[fi].nb_streams - 1) {
1649             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1650             av_exit(1);
1651         }
1652     }
1653
1654     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1655     if (!ost_table)
1656         goto fail;
1657     for(i=0;i<nb_ostreams;i++) {
1658         ost = av_mallocz(sizeof(AVOutputStream));
1659         if (!ost)
1660             goto fail;
1661         ost_table[i] = ost;
1662     }
1663
1664     n = 0;
1665     for(k=0;k<nb_output_files;k++) {
1666         os = output_files[k];
1667         for(i=0;i<os->nb_streams;i++,n++) {
1668             int found;
1669             ost = ost_table[n];
1670             ost->file_index = k;
1671             ost->index = i;
1672             ost->st = os->streams[i];
1673             if (nb_stream_maps > 0) {
1674                 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1675                     stream_maps[n].stream_index;
1676
1677                 /* Sanity check that the stream types match */
1678                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1679                     int i= ost->file_index;
1680                     dump_format(output_files[i], i, output_files[i]->filename, 1);
1681                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1682                         stream_maps[n].file_index, stream_maps[n].stream_index,
1683                         ost->file_index, ost->index);
1684                     av_exit(1);
1685                 }
1686
1687             } else {
1688                 if(opt_programid) {
1689                     found = 0;
1690                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1691                     if(j != -1) {
1692                         ost->source_index = j;
1693                         found = 1;
1694                     }
1695                 } else {
1696                     /* get corresponding input stream index : we select the first one with the right type */
1697                     found = 0;
1698                     for(j=0;j<nb_istreams;j++) {
1699                         ist = ist_table[j];
1700                         if (ist->discard &&
1701                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1702                             ost->source_index = j;
1703                             found = 1;
1704                             break;
1705                         }
1706                     }
1707                 }
1708
1709                 if (!found) {
1710                     if(! opt_programid) {
1711                         /* try again and reuse existing stream */
1712                         for(j=0;j<nb_istreams;j++) {
1713                             ist = ist_table[j];
1714                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1715                                 ost->source_index = j;
1716                                 found = 1;
1717                             }
1718                         }
1719                     }
1720                     if (!found) {
1721                         int i= ost->file_index;
1722                         dump_format(output_files[i], i, output_files[i]->filename, 1);
1723                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1724                                 ost->file_index, ost->index);
1725                         av_exit(1);
1726                     }
1727                 }
1728             }
1729             ist = ist_table[ost->source_index];
1730             ist->discard = 0;
1731             ost->sync_ist = (nb_stream_maps > 0) ?
1732                 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1733                          stream_maps[n].sync_stream_index] : ist;
1734         }
1735     }
1736
1737     /* for each output stream, we compute the right encoding parameters */
1738     for(i=0;i<nb_ostreams;i++) {
1739         AVMetadataTag *lang;
1740         ost = ost_table[i];
1741         os = output_files[ost->file_index];
1742         ist = ist_table[ost->source_index];
1743
1744         codec = ost->st->codec;
1745         icodec = ist->st->codec;
1746
1747         if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1748             &&   !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1749             av_metadata_set(&ost->st->metadata, "language", lang->value);
1750
1751         ost->st->disposition = ist->st->disposition;
1752
1753         if (ost->st->stream_copy) {
1754             /* if stream_copy is selected, no need to decode or encode */
1755             codec->codec_id = icodec->codec_id;
1756             codec->codec_type = icodec->codec_type;
1757
1758             if(!codec->codec_tag){
1759                 if(   !os->oformat->codec_tag
1760                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1761                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1762                     codec->codec_tag = icodec->codec_tag;
1763             }
1764
1765             codec->bit_rate = icodec->bit_rate;
1766             codec->extradata= icodec->extradata;
1767             codec->extradata_size= icodec->extradata_size;
1768             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){
1769                 codec->time_base = icodec->time_base;
1770                 codec->time_base.num *= icodec->ticks_per_frame;
1771             }else
1772                 codec->time_base = ist->st->time_base;
1773             switch(codec->codec_type) {
1774             case CODEC_TYPE_AUDIO:
1775                 if(audio_volume != 256) {
1776                     fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1777                     av_exit(1);
1778                 }
1779                 codec->channel_layout = icodec->channel_layout;
1780                 codec->sample_rate = icodec->sample_rate;
1781                 codec->channels = icodec->channels;
1782                 codec->frame_size = icodec->frame_size;
1783                 codec->block_align= icodec->block_align;
1784                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1785                     codec->block_align= 0;
1786                 if(codec->codec_id == CODEC_ID_AC3)
1787                     codec->block_align= 0;
1788                 break;
1789             case CODEC_TYPE_VIDEO:
1790                 codec->pix_fmt = icodec->pix_fmt;
1791                 codec->width = icodec->width;
1792                 codec->height = icodec->height;
1793                 codec->has_b_frames = icodec->has_b_frames;
1794                 break;
1795             case CODEC_TYPE_SUBTITLE:
1796                 codec->width = icodec->width;
1797                 codec->height = icodec->height;
1798                 break;
1799             default:
1800                 abort();
1801             }
1802         } else {
1803             switch(codec->codec_type) {
1804             case CODEC_TYPE_AUDIO:
1805                 ost->fifo= av_fifo_alloc(1024);
1806                 if(!ost->fifo)
1807                     goto fail;
1808                 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1809                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1810                 icodec->request_channels = codec->channels;
1811                 ist->decoding_needed = 1;
1812                 ost->encoding_needed = 1;
1813                 break;
1814             case CODEC_TYPE_VIDEO:
1815                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1816                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1817                 ost->video_resample = ((codec->width != icodec->width -
1818                                 (frame_leftBand + frame_rightBand) +
1819                                 (frame_padleft + frame_padright)) ||
1820                         (codec->height != icodec->height -
1821                                 (frame_topBand  + frame_bottomBand) +
1822                                 (frame_padtop + frame_padbottom)) ||
1823                         (codec->pix_fmt != icodec->pix_fmt));
1824                 if (ost->video_crop) {
1825                     ost->topBand = frame_topBand;
1826                     ost->leftBand = frame_leftBand;
1827                 }
1828                 if (ost->video_pad) {
1829                     ost->padtop = frame_padtop;
1830                     ost->padleft = frame_padleft;
1831                     ost->padbottom = frame_padbottom;
1832                     ost->padright = frame_padright;
1833                     if (!ost->video_resample) {
1834                         avcodec_get_frame_defaults(&ost->pict_tmp);
1835                         if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1836                                          codec->width, codec->height))
1837                             goto fail;
1838                     }
1839                 }
1840                 if (ost->video_resample) {
1841                     avcodec_get_frame_defaults(&ost->pict_tmp);
1842                     if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1843                                          codec->width, codec->height)) {
1844                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1845                         av_exit(1);
1846                     }
1847                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1848                     ost->img_resample_ctx = sws_getContext(
1849                             icodec->width - (frame_leftBand + frame_rightBand),
1850                             icodec->height - (frame_topBand + frame_bottomBand),
1851                             icodec->pix_fmt,
1852                             codec->width - (frame_padleft + frame_padright),
1853                             codec->height - (frame_padtop + frame_padbottom),
1854                             codec->pix_fmt,
1855                             sws_flags, NULL, NULL, NULL);
1856                     if (ost->img_resample_ctx == NULL) {
1857                         fprintf(stderr, "Cannot get resampling context\n");
1858                         av_exit(1);
1859                     }
1860                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1861                 }
1862                 ost->encoding_needed = 1;
1863                 ist->decoding_needed = 1;
1864                 break;
1865             case CODEC_TYPE_SUBTITLE:
1866                 ost->encoding_needed = 1;
1867                 ist->decoding_needed = 1;
1868                 break;
1869             default:
1870                 abort();
1871                 break;
1872             }
1873             /* two pass mode */
1874             if (ost->encoding_needed &&
1875                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1876                 char logfilename[1024];
1877                 FILE *f;
1878                 int size;
1879                 char *logbuffer;
1880
1881                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1882                          pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1883                          i);
1884                 if (codec->flags & CODEC_FLAG_PASS1) {
1885                     f = fopen(logfilename, "w");
1886                     if (!f) {
1887                         fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1888                         av_exit(1);
1889                     }
1890                     ost->logfile = f;
1891                 } else {
1892                     /* read the log file */
1893                     f = fopen(logfilename, "r");
1894                     if (!f) {
1895                         fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1896                         av_exit(1);
1897                     }
1898                     fseek(f, 0, SEEK_END);
1899                     size = ftell(f);
1900                     fseek(f, 0, SEEK_SET);
1901                     logbuffer = av_malloc(size + 1);
1902                     if (!logbuffer) {
1903                         fprintf(stderr, "Could not allocate log buffer\n");
1904                         av_exit(1);
1905                     }
1906                     size = fread(logbuffer, 1, size, f);
1907                     fclose(f);
1908                     logbuffer[size] = '\0';
1909                     codec->stats_in = logbuffer;
1910                 }
1911             }
1912         }
1913         if(codec->codec_type == CODEC_TYPE_VIDEO){
1914             int size= codec->width * codec->height;
1915             bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1916         }
1917     }
1918
1919     if (!bit_buffer)
1920         bit_buffer = av_malloc(bit_buffer_size);
1921     if (!bit_buffer) {
1922         ret = AVERROR(ENOMEM);
1923         goto fail;
1924     }
1925
1926     /* open each encoder */
1927     for(i=0;i<nb_ostreams;i++) {
1928         ost = ost_table[i];
1929         if (ost->encoding_needed) {
1930             AVCodec *codec = output_codecs[i];
1931             if (!codec)
1932                 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1933             if (!codec) {
1934                 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1935                         ost->file_index, ost->index);
1936                 ret = AVERROR(EINVAL);
1937                 goto dump_format;
1938             }
1939             if (avcodec_open(ost->st->codec, codec) < 0) {
1940                 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1941                         ost->file_index, ost->index);
1942                 ret = AVERROR(EINVAL);
1943                 goto dump_format;
1944             }
1945             extra_size += ost->st->codec->extradata_size;
1946         }
1947     }
1948
1949     /* open each decoder */
1950     for(i=0;i<nb_istreams;i++) {
1951         ist = ist_table[i];
1952         if (ist->decoding_needed) {
1953             AVCodec *codec = input_codecs[i];
1954             if (!codec)
1955                 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1956             if (!codec) {
1957                 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1958                         ist->st->codec->codec_id, ist->file_index, ist->index);
1959                 ret = AVERROR(EINVAL);
1960                 goto dump_format;
1961             }
1962             if (avcodec_open(ist->st->codec, codec) < 0) {
1963                 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1964                         ist->file_index, ist->index);
1965                 ret = AVERROR(EINVAL);
1966                 goto dump_format;
1967             }
1968             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1969             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1970         }
1971     }
1972
1973     /* init pts */
1974     for(i=0;i<nb_istreams;i++) {
1975         ist = ist_table[i];
1976         is = input_files[ist->file_index];
1977         ist->pts = 0;
1978         ist->next_pts = AV_NOPTS_VALUE;
1979         ist->is_start = 1;
1980     }
1981
1982     /* set meta data information from input file if required */
1983     for (i=0;i<nb_meta_data_maps;i++) {
1984         AVFormatContext *out_file;
1985         AVFormatContext *in_file;
1986         AVMetadataTag *mtag;
1987
1988         int out_file_index = meta_data_maps[i].out_file;
1989         int in_file_index = meta_data_maps[i].in_file;
1990         if (out_file_index < 0 || out_file_index >= nb_output_files) {
1991             snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1992                      out_file_index, out_file_index, in_file_index);
1993             ret = AVERROR(EINVAL);
1994             goto dump_format;
1995         }
1996         if (in_file_index < 0 || in_file_index >= nb_input_files) {
1997             snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1998                      in_file_index, out_file_index, in_file_index);
1999             ret = AVERROR(EINVAL);
2000             goto dump_format;
2001         }
2002
2003         out_file = output_files[out_file_index];
2004         in_file = input_files[in_file_index];
2005
2006
2007         mtag=NULL;
2008         while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2009             av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2010         av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2011                                     in_file->iformat->metadata_conv);
2012     }
2013
2014     /* open files and write file headers */
2015     for(i=0;i<nb_output_files;i++) {
2016         os = output_files[i];
2017         if (av_write_header(os) < 0) {
2018             snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2019             ret = AVERROR(EINVAL);
2020             goto dump_format;
2021         }
2022         if (strcmp(output_files[i]->oformat->name, "rtp")) {
2023             want_sdp = 0;
2024         }
2025     }
2026
2027  dump_format:
2028     /* dump the file output parameters - cannot be done before in case
2029        of stream copy */
2030     for(i=0;i<nb_output_files;i++) {
2031         dump_format(output_files[i], i, output_files[i]->filename, 1);
2032     }
2033
2034     /* dump the stream mapping */
2035     if (verbose >= 0) {
2036         fprintf(stderr, "Stream mapping:\n");
2037         for(i=0;i<nb_ostreams;i++) {
2038             ost = ost_table[i];
2039             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
2040                     ist_table[ost->source_index]->file_index,
2041                     ist_table[ost->source_index]->index,
2042                     ost->file_index,
2043                     ost->index);
2044             if (ost->sync_ist != ist_table[ost->source_index])
2045                 fprintf(stderr, " [sync #%d.%d]",
2046                         ost->sync_ist->file_index,
2047                         ost->sync_ist->index);
2048             fprintf(stderr, "\n");
2049         }
2050     }
2051
2052     if (ret) {
2053         fprintf(stderr, "%s\n", error);
2054         goto fail;
2055     }
2056
2057     if (want_sdp) {
2058         print_sdp(output_files, nb_output_files);
2059     }
2060
2061     if (!using_stdin && verbose >= 0) {
2062         fprintf(stderr, "Press [q] to stop encoding\n");
2063         url_set_interrupt_cb(decode_interrupt_cb);
2064     }
2065     term_init();
2066
2067     key = -1;
2068     timer_start = av_gettime();
2069
2070     for(; received_sigterm == 0;) {
2071         int file_index, ist_index;
2072         AVPacket pkt;
2073         double ipts_min;
2074         double opts_min;
2075
2076     redo:
2077         ipts_min= 1e100;
2078         opts_min= 1e100;
2079         /* if 'q' pressed, exits */
2080         if (!using_stdin) {
2081             if (q_pressed)
2082                 break;
2083             /* read_key() returns 0 on EOF */
2084             key = read_key();
2085             if (key == 'q')
2086                 break;
2087         }
2088
2089         /* select the stream that we must read now by looking at the
2090            smallest output pts */
2091         file_index = -1;
2092         for(i=0;i<nb_ostreams;i++) {
2093             double ipts, opts;
2094             ost = ost_table[i];
2095             os = output_files[ost->file_index];
2096             ist = ist_table[ost->source_index];
2097             if(no_packet[ist->file_index])
2098                 continue;
2099             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2100                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2101             else
2102                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2103             ipts = (double)ist->pts;
2104             if (!file_table[ist->file_index].eof_reached){
2105                 if(ipts < ipts_min) {
2106                     ipts_min = ipts;
2107                     if(input_sync ) file_index = ist->file_index;
2108                 }
2109                 if(opts < opts_min) {
2110                     opts_min = opts;
2111                     if(!input_sync) file_index = ist->file_index;
2112                 }
2113             }
2114             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2115                 file_index= -1;
2116                 break;
2117             }
2118         }
2119         /* if none, if is finished */
2120         if (file_index < 0) {
2121             if(no_packet_count){
2122                 no_packet_count=0;
2123                 memset(no_packet, 0, sizeof(no_packet));
2124                 usleep(10000);
2125                 continue;
2126             }
2127             break;
2128         }
2129
2130         /* finish if recording time exhausted */
2131         if (opts_min >= (recording_time / 1000000.0))
2132             break;
2133
2134         /* finish if limit size exhausted */
2135         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2136             break;
2137
2138         /* read a frame from it and output it in the fifo */
2139         is = input_files[file_index];
2140         ret= av_read_frame(is, &pkt);
2141         if(ret == AVERROR(EAGAIN)){
2142             no_packet[file_index]=1;
2143             no_packet_count++;
2144             continue;
2145         }
2146         if (ret < 0) {
2147             file_table[file_index].eof_reached = 1;
2148             if (opt_shortest)
2149                 break;
2150             else
2151                 continue;
2152         }
2153
2154         no_packet_count=0;
2155         memset(no_packet, 0, sizeof(no_packet));
2156
2157         if (do_pkt_dump) {
2158             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2159         }
2160         /* the following test is needed in case new streams appear
2161            dynamically in stream : we ignore them */
2162         if (pkt.stream_index >= file_table[file_index].nb_streams)
2163             goto discard_packet;
2164         ist_index = file_table[file_index].ist_index + pkt.stream_index;
2165         ist = ist_table[ist_index];
2166         if (ist->discard)
2167             goto discard_packet;
2168
2169         if (pkt.dts != AV_NOPTS_VALUE)
2170             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2171         if (pkt.pts != AV_NOPTS_VALUE)
2172             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2173
2174         if(input_files_ts_scale[file_index][pkt.stream_index]){
2175             if(pkt.pts != AV_NOPTS_VALUE)
2176                 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2177             if(pkt.dts != AV_NOPTS_VALUE)
2178                 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2179         }
2180
2181 //        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);
2182         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2183             && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2184             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2185             int64_t delta= pkt_dts - ist->next_pts;
2186             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2187                 input_files_ts_offset[ist->file_index]-= delta;
2188                 if (verbose > 2)
2189                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2190                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2191                 if(pkt.pts != AV_NOPTS_VALUE)
2192                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2193             }
2194         }
2195
2196         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2197         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2198
2199             if (verbose >= 0)
2200                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2201                         ist->file_index, ist->index);
2202             if (exit_on_error)
2203                 av_exit(1);
2204             av_free_packet(&pkt);
2205             goto redo;
2206         }
2207
2208     discard_packet:
2209         av_free_packet(&pkt);
2210
2211         /* dump report by using the output first video and audio streams */
2212         print_report(output_files, ost_table, nb_ostreams, 0);
2213     }
2214
2215     /* at the end of stream, we must flush the decoder buffers */
2216     for(i=0;i<nb_istreams;i++) {
2217         ist = ist_table[i];
2218         if (ist->decoding_needed) {
2219             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2220         }
2221     }
2222
2223     term_exit();
2224
2225     /* write the trailer if needed and close file */
2226     for(i=0;i<nb_output_files;i++) {
2227         os = output_files[i];
2228         av_write_trailer(os);
2229     }
2230
2231     /* dump report by using the first video and audio streams */
2232     print_report(output_files, ost_table, nb_ostreams, 1);
2233
2234     /* close each encoder */
2235     for(i=0;i<nb_ostreams;i++) {
2236         ost = ost_table[i];
2237         if (ost->encoding_needed) {
2238             av_freep(&ost->st->codec->stats_in);
2239             avcodec_close(ost->st->codec);
2240         }
2241     }
2242
2243     /* close each decoder */
2244     for(i=0;i<nb_istreams;i++) {
2245         ist = ist_table[i];
2246         if (ist->decoding_needed) {
2247             avcodec_close(ist->st->codec);
2248         }
2249     }
2250
2251     /* finished ! */
2252     ret = 0;
2253
2254  fail:
2255     av_freep(&bit_buffer);
2256     av_free(file_table);
2257
2258     if (ist_table) {
2259         for(i=0;i<nb_istreams;i++) {
2260             ist = ist_table[i];
2261             av_free(ist);
2262         }
2263         av_free(ist_table);
2264     }
2265     if (ost_table) {
2266         for(i=0;i<nb_ostreams;i++) {
2267             ost = ost_table[i];
2268             if (ost) {
2269                 if (ost->logfile) {
2270                     fclose(ost->logfile);
2271                     ost->logfile = NULL;
2272                 }
2273                 av_fifo_free(ost->fifo); /* works even if fifo is not
2274                                              initialized but set to zero */
2275                 av_free(ost->pict_tmp.data[0]);
2276                 if (ost->video_resample)
2277                     sws_freeContext(ost->img_resample_ctx);
2278                 if (ost->resample)
2279                     audio_resample_close(ost->resample);
2280                 if (ost->reformat_ctx)
2281                     av_audio_convert_free(ost->reformat_ctx);
2282                 av_free(ost);
2283             }
2284         }
2285         av_free(ost_table);
2286     }
2287     return ret;
2288 }
2289
2290 #if 0
2291 int file_read(const char *filename)
2292 {
2293     URLContext *h;
2294     unsigned char buffer[1024];
2295     int len, i;
2296
2297     if (url_open(&h, filename, O_RDONLY) < 0) {
2298         printf("could not open '%s'\n", filename);
2299         return -1;
2300     }
2301     for(;;) {
2302         len = url_read(h, buffer, sizeof(buffer));
2303         if (len <= 0)
2304             break;
2305         for(i=0;i<len;i++) putchar(buffer[i]);
2306     }
2307     url_close(h);
2308     return 0;
2309 }
2310 #endif
2311
2312 static void opt_format(const char *arg)
2313 {
2314     /* compatibility stuff for pgmyuv */
2315     if (!strcmp(arg, "pgmyuv")) {
2316         pgmyuv_compatibility_hack=1;
2317 //        opt_image_format(arg);
2318         arg = "image2";
2319         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2320     }
2321
2322     file_iformat = av_find_input_format(arg);
2323     file_oformat = guess_format(arg, NULL, NULL);
2324     if (!file_iformat && !file_oformat) {
2325         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2326         av_exit(1);
2327     }
2328 }
2329
2330 static void opt_video_rc_override_string(const char *arg)
2331 {
2332     video_rc_override_string = arg;
2333 }
2334
2335 static int opt_me_threshold(const char *opt, const char *arg)
2336 {
2337     me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2338     return 0;
2339 }
2340
2341 static void opt_loglevel(const char *opt, const char *arg)
2342 {
2343     int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2344     av_log_set_level(level);
2345 }
2346
2347 static int opt_verbose(const char *opt, const char *arg)
2348 {
2349     verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2350     return 0;
2351 }
2352
2353 static int opt_frame_rate(const char *opt, const char *arg)
2354 {
2355     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2356         fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2357         av_exit(1);
2358     }
2359     return 0;
2360 }
2361
2362 static int opt_bitrate(const char *opt, const char *arg)
2363 {
2364     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2365
2366     opt_default(opt, arg);
2367
2368     if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2369         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2370
2371     return 0;
2372 }
2373
2374 static void opt_frame_crop_top(const char *arg)
2375 {
2376     frame_topBand = atoi(arg);
2377     if (frame_topBand < 0) {
2378         fprintf(stderr, "Incorrect top crop size\n");
2379         av_exit(1);
2380     }
2381     if ((frame_topBand % 2) != 0) {
2382         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2383         av_exit(1);
2384     }
2385     if ((frame_topBand) >= frame_height){
2386         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2387         av_exit(1);
2388     }
2389     frame_height -= frame_topBand;
2390 }
2391
2392 static void opt_frame_crop_bottom(const char *arg)
2393 {
2394     frame_bottomBand = atoi(arg);
2395     if (frame_bottomBand < 0) {
2396         fprintf(stderr, "Incorrect bottom crop size\n");
2397         av_exit(1);
2398     }
2399     if ((frame_bottomBand % 2) != 0) {
2400         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2401         av_exit(1);
2402     }
2403     if ((frame_bottomBand) >= frame_height){
2404         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2405         av_exit(1);
2406     }
2407     frame_height -= frame_bottomBand;
2408 }
2409
2410 static void opt_frame_crop_left(const char *arg)
2411 {
2412     frame_leftBand = atoi(arg);
2413     if (frame_leftBand < 0) {
2414         fprintf(stderr, "Incorrect left crop size\n");
2415         av_exit(1);
2416     }
2417     if ((frame_leftBand % 2) != 0) {
2418         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2419         av_exit(1);
2420     }
2421     if ((frame_leftBand) >= frame_width){
2422         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2423         av_exit(1);
2424     }
2425     frame_width -= frame_leftBand;
2426 }
2427
2428 static void opt_frame_crop_right(const char *arg)
2429 {
2430     frame_rightBand = atoi(arg);
2431     if (frame_rightBand < 0) {
2432         fprintf(stderr, "Incorrect right crop size\n");
2433         av_exit(1);
2434     }
2435     if ((frame_rightBand % 2) != 0) {
2436         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2437         av_exit(1);
2438     }
2439     if ((frame_rightBand) >= frame_width){
2440         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2441         av_exit(1);
2442     }
2443     frame_width -= frame_rightBand;
2444 }
2445
2446 static void opt_frame_size(const char *arg)
2447 {
2448     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2449         fprintf(stderr, "Incorrect frame size\n");
2450         av_exit(1);
2451     }
2452     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2453         fprintf(stderr, "Frame size must be a multiple of 2\n");
2454         av_exit(1);
2455     }
2456 }
2457
2458
2459 #define SCALEBITS 10
2460 #define ONE_HALF  (1 << (SCALEBITS - 1))
2461 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2462
2463 #define RGB_TO_Y(r, g, b) \
2464 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2465   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2466
2467 #define RGB_TO_U(r1, g1, b1, shift)\
2468 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2469      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2470
2471 #define RGB_TO_V(r1, g1, b1, shift)\
2472 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2473    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2474
2475 static void opt_pad_color(const char *arg) {
2476     /* Input is expected to be six hex digits similar to
2477        how colors are expressed in html tags (but without the #) */
2478     int rgb = strtol(arg, NULL, 16);
2479     int r,g,b;
2480
2481     r = (rgb >> 16);
2482     g = ((rgb >> 8) & 255);
2483     b = (rgb & 255);
2484
2485     padcolor[0] = RGB_TO_Y(r,g,b);
2486     padcolor[1] = RGB_TO_U(r,g,b,0);
2487     padcolor[2] = RGB_TO_V(r,g,b,0);
2488 }
2489
2490 static void opt_frame_pad_top(const char *arg)
2491 {
2492     frame_padtop = atoi(arg);
2493     if (frame_padtop < 0) {
2494         fprintf(stderr, "Incorrect top pad size\n");
2495         av_exit(1);
2496     }
2497     if ((frame_padtop % 2) != 0) {
2498         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2499         av_exit(1);
2500     }
2501 }
2502
2503 static void opt_frame_pad_bottom(const char *arg)
2504 {
2505     frame_padbottom = atoi(arg);
2506     if (frame_padbottom < 0) {
2507         fprintf(stderr, "Incorrect bottom pad size\n");
2508         av_exit(1);
2509     }
2510     if ((frame_padbottom % 2) != 0) {
2511         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2512         av_exit(1);
2513     }
2514 }
2515
2516
2517 static void opt_frame_pad_left(const char *arg)
2518 {
2519     frame_padleft = atoi(arg);
2520     if (frame_padleft < 0) {
2521         fprintf(stderr, "Incorrect left pad size\n");
2522         av_exit(1);
2523     }
2524     if ((frame_padleft % 2) != 0) {
2525         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2526         av_exit(1);
2527     }
2528 }
2529
2530
2531 static void opt_frame_pad_right(const char *arg)
2532 {
2533     frame_padright = atoi(arg);
2534     if (frame_padright < 0) {
2535         fprintf(stderr, "Incorrect right pad size\n");
2536         av_exit(1);
2537     }
2538     if ((frame_padright % 2) != 0) {
2539         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2540         av_exit(1);
2541     }
2542 }
2543
2544 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2545 {
2546     int i;
2547     char fmt_str[128];
2548     for (i=-1; i < nb_fmts; i++) {
2549         get_fmt_string (fmt_str, sizeof(fmt_str), i);
2550         fprintf(stdout, "%s\n", fmt_str);
2551     }
2552 }
2553
2554 static void opt_frame_pix_fmt(const char *arg)
2555 {
2556     if (strcmp(arg, "list")) {
2557         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2558         if (frame_pix_fmt == PIX_FMT_NONE) {
2559             fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2560             av_exit(1);
2561         }
2562     } else {
2563         list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2564         av_exit(0);
2565     }
2566 }
2567
2568 static void opt_frame_aspect_ratio(const char *arg)
2569 {
2570     int x = 0, y = 0;
2571     double ar = 0;
2572     const char *p;
2573     char *end;
2574
2575     p = strchr(arg, ':');
2576     if (p) {
2577         x = strtol(arg, &end, 10);
2578         if (end == p)
2579             y = strtol(end+1, &end, 10);
2580         if (x > 0 && y > 0)
2581             ar = (double)x / (double)y;
2582     } else
2583         ar = strtod(arg, NULL);
2584
2585     if (!ar) {
2586         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2587         av_exit(1);
2588     }
2589     frame_aspect_ratio = ar;
2590 }
2591
2592 static int opt_metadata(const char *opt, const char *arg)
2593 {
2594     char *mid= strchr(arg, '=');
2595
2596     if(!mid){
2597         fprintf(stderr, "Missing =\n");
2598         av_exit(1);
2599     }
2600     *mid++= 0;
2601
2602     metadata_count++;
2603     metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2604     metadata[metadata_count-1].key  = av_strdup(arg);
2605     metadata[metadata_count-1].value= av_strdup(mid);
2606
2607     return 0;
2608 }
2609
2610 static void opt_qscale(const char *arg)
2611 {
2612     video_qscale = atof(arg);
2613     if (video_qscale <= 0 ||
2614         video_qscale > 255) {
2615         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2616         av_exit(1);
2617     }
2618 }
2619
2620 static void opt_top_field_first(const char *arg)
2621 {
2622     top_field_first= atoi(arg);
2623 }
2624
2625 static int opt_thread_count(const char *opt, const char *arg)
2626 {
2627     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2628 #if !HAVE_THREADS
2629     if (verbose >= 0)
2630         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2631 #endif
2632     return 0;
2633 }
2634
2635 static void opt_audio_sample_fmt(const char *arg)
2636 {
2637     if (strcmp(arg, "list"))
2638         audio_sample_fmt = avcodec_get_sample_fmt(arg);
2639     else {
2640         list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2641         av_exit(0);
2642     }
2643 }
2644
2645 static int opt_audio_rate(const char *opt, const char *arg)
2646 {
2647     audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2648     return 0;
2649 }
2650
2651 static int opt_audio_channels(const char *opt, const char *arg)
2652 {
2653     audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2654     return 0;
2655 }
2656
2657 static void opt_video_channel(const char *arg)
2658 {
2659     video_channel = strtol(arg, NULL, 0);
2660 }
2661
2662 static void opt_video_standard(const char *arg)
2663 {
2664     video_standard = av_strdup(arg);
2665 }
2666
2667 static void opt_codec(int *pstream_copy, char **pcodec_name,
2668                       int codec_type, const char *arg)
2669 {
2670     av_freep(pcodec_name);
2671     if (!strcmp(arg, "copy")) {
2672         *pstream_copy = 1;
2673     } else {
2674         *pcodec_name = av_strdup(arg);
2675     }
2676 }
2677
2678 static void opt_audio_codec(const char *arg)
2679 {
2680     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2681 }
2682
2683 static void opt_audio_tag(const char *arg)
2684 {
2685     char *tail;
2686     audio_codec_tag= strtol(arg, &tail, 0);
2687
2688     if(!tail || *tail)
2689         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2690 }
2691
2692 static void opt_video_tag(const char *arg)
2693 {
2694     char *tail;
2695     video_codec_tag= strtol(arg, &tail, 0);
2696
2697     if(!tail || *tail)
2698         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2699 }
2700
2701 static void opt_video_codec(const char *arg)
2702 {
2703     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2704 }
2705
2706 static void opt_subtitle_codec(const char *arg)
2707 {
2708     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2709 }
2710
2711 static void opt_subtitle_tag(const char *arg)
2712 {
2713     char *tail;
2714     subtitle_codec_tag= strtol(arg, &tail, 0);
2715
2716     if(!tail || *tail)
2717         subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2718 }
2719
2720 static void opt_map(const char *arg)
2721 {
2722     AVStreamMap *m;
2723     char *p;
2724
2725     m = &stream_maps[nb_stream_maps++];
2726
2727     m->file_index = strtol(arg, &p, 0);
2728     if (*p)
2729         p++;
2730
2731     m->stream_index = strtol(p, &p, 0);
2732     if (*p) {
2733         p++;
2734         m->sync_file_index = strtol(p, &p, 0);
2735         if (*p)
2736             p++;
2737         m->sync_stream_index = strtol(p, &p, 0);
2738     } else {
2739         m->sync_file_index = m->file_index;
2740         m->sync_stream_index = m->stream_index;
2741     }
2742 }
2743
2744 static void opt_map_meta_data(const char *arg)
2745 {
2746     AVMetaDataMap *m;
2747     char *p;
2748
2749     m = &meta_data_maps[nb_meta_data_maps++];
2750
2751     m->out_file = strtol(arg, &p, 0);
2752     if (*p)
2753         p++;
2754
2755     m->in_file = strtol(p, &p, 0);
2756 }
2757
2758 static void opt_input_ts_scale(const char *arg)
2759 {
2760     unsigned int stream;
2761     double scale;
2762     char *p;
2763
2764     stream = strtol(arg, &p, 0);
2765     if (*p)
2766         p++;
2767     scale= strtod(p, &p);
2768
2769     if(stream >= MAX_STREAMS)
2770         av_exit(1);
2771
2772     input_files_ts_scale[nb_input_files][stream]= scale;
2773 }
2774
2775 static int opt_recording_time(const char *opt, const char *arg)
2776 {
2777     recording_time = parse_time_or_die(opt, arg, 1);
2778     return 0;
2779 }
2780
2781 static int opt_start_time(const char *opt, const char *arg)
2782 {
2783     start_time = parse_time_or_die(opt, arg, 1);
2784     return 0;
2785 }
2786
2787 static int opt_rec_timestamp(const char *opt, const char *arg)
2788 {
2789     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2790     return 0;
2791 }
2792
2793 static int opt_input_ts_offset(const char *opt, const char *arg)
2794 {
2795     input_ts_offset = parse_time_or_die(opt, arg, 1);
2796     return 0;
2797 }
2798
2799 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2800 {
2801     const char *codec_string = encoder ? "encoder" : "decoder";
2802     AVCodec *codec;
2803
2804     if(!name)
2805         return CODEC_ID_NONE;
2806     codec = encoder ?
2807         avcodec_find_encoder_by_name(name) :
2808         avcodec_find_decoder_by_name(name);
2809     if(!codec) {
2810         fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2811         av_exit(1);
2812     }
2813     if(codec->type != type) {
2814         fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2815         av_exit(1);
2816     }
2817     return codec->id;
2818 }
2819
2820 static void opt_input_file(const char *filename)
2821 {
2822     AVFormatContext *ic;
2823     AVFormatParameters params, *ap = &params;
2824     int err, i, ret, rfps, rfps_base;
2825     int64_t timestamp;
2826
2827     if (!strcmp(filename, "-"))
2828         filename = "pipe:";
2829
2830     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2831                     !strcmp(filename, "/dev/stdin");
2832
2833     /* get default parameters from command line */
2834     ic = avformat_alloc_context();
2835
2836     memset(ap, 0, sizeof(*ap));
2837     ap->prealloced_context = 1;
2838     ap->sample_rate = audio_sample_rate;
2839     ap->channels = audio_channels;
2840     ap->time_base.den = frame_rate.num;
2841     ap->time_base.num = frame_rate.den;
2842     ap->width = frame_width + frame_padleft + frame_padright;
2843     ap->height = frame_height + frame_padtop + frame_padbottom;
2844     ap->pix_fmt = frame_pix_fmt;
2845    // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2846     ap->channel = video_channel;
2847     ap->standard = video_standard;
2848     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2849     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2850     if(pgmyuv_compatibility_hack)
2851         ap->video_codec_id= CODEC_ID_PGMYUV;
2852
2853     set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2854
2855     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2856     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2857     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2858     ic->flags |= AVFMT_FLAG_NONBLOCK;
2859
2860     /* open the input file with generic libav function */
2861     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2862     if (err < 0) {
2863         print_error(filename, err);
2864         av_exit(1);
2865     }
2866     if(opt_programid) {
2867         int i;
2868         for(i=0; i<ic->nb_programs; i++)
2869             if(ic->programs[i]->id != opt_programid)
2870                 ic->programs[i]->discard = AVDISCARD_ALL;
2871     }
2872
2873     ic->loop_input = loop_input;
2874
2875     /* If not enough info to get the stream parameters, we decode the
2876        first frames to get it. (used in mpeg case for example) */
2877     ret = av_find_stream_info(ic);
2878     if (ret < 0 && verbose >= 0) {
2879         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2880         av_exit(1);
2881     }
2882
2883     timestamp = start_time;
2884     /* add the stream start time */
2885     if (ic->start_time != AV_NOPTS_VALUE)
2886         timestamp += ic->start_time;
2887
2888     /* if seeking requested, we execute it */
2889     if (start_time != 0) {
2890         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2891         if (ret < 0) {
2892             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2893                     filename, (double)timestamp / AV_TIME_BASE);
2894         }
2895         /* reset seek info */
2896         start_time = 0;
2897     }
2898
2899     /* update the current parameters so that they match the one of the input stream */
2900     for(i=0;i<ic->nb_streams;i++) {
2901         AVCodecContext *enc = ic->streams[i]->codec;
2902         if(thread_count>1)
2903             avcodec_thread_init(enc, thread_count);
2904         enc->thread_count= thread_count;
2905         switch(enc->codec_type) {
2906         case CODEC_TYPE_AUDIO:
2907             set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2908             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2909             channel_layout = enc->channel_layout;
2910             audio_channels = enc->channels;
2911             audio_sample_rate = enc->sample_rate;
2912             audio_sample_fmt = enc->sample_fmt;
2913             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2914             if(audio_disable)
2915                 ic->streams[i]->discard= AVDISCARD_ALL;
2916             break;
2917         case CODEC_TYPE_VIDEO:
2918             set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2919             frame_height = enc->height;
2920             frame_width = enc->width;
2921             if(ic->streams[i]->sample_aspect_ratio.num)
2922                 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2923             else
2924                 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2925             frame_aspect_ratio *= (float) enc->width / enc->height;
2926             frame_pix_fmt = enc->pix_fmt;
2927             rfps      = ic->streams[i]->r_frame_rate.num;
2928             rfps_base = ic->streams[i]->r_frame_rate.den;
2929             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2930             if(me_threshold)
2931                 enc->debug |= FF_DEBUG_MV;
2932
2933             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2934
2935                 if (verbose >= 0)
2936                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2937                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2938
2939                     (float)rfps / rfps_base, rfps, rfps_base);
2940             }
2941             /* update the current frame rate to match the stream frame rate */
2942             frame_rate.num = rfps;
2943             frame_rate.den = rfps_base;
2944
2945             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2946             if(video_disable)
2947                 ic->streams[i]->discard= AVDISCARD_ALL;
2948             else if(video_discard)
2949                 ic->streams[i]->discard= video_discard;
2950             break;
2951         case CODEC_TYPE_DATA:
2952             break;
2953         case CODEC_TYPE_SUBTITLE:
2954             input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2955             if(subtitle_disable)
2956                 ic->streams[i]->discard = AVDISCARD_ALL;
2957             break;
2958         case CODEC_TYPE_ATTACHMENT:
2959         case CODEC_TYPE_UNKNOWN:
2960             nb_icodecs++;
2961             break;
2962         default:
2963             abort();
2964         }
2965     }
2966
2967     input_files[nb_input_files] = ic;
2968     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2969     /* dump the file content */
2970     if (verbose >= 0)
2971         dump_format(ic, nb_input_files, filename, 0);
2972
2973     nb_input_files++;
2974     file_iformat = NULL;
2975     file_oformat = NULL;
2976
2977     video_channel = 0;
2978
2979     av_freep(&video_codec_name);
2980     av_freep(&audio_codec_name);
2981     av_freep(&subtitle_codec_name);
2982 }
2983
2984 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2985                                          int *has_subtitle_ptr)
2986 {
2987     int has_video, has_audio, has_subtitle, i, j;
2988     AVFormatContext *ic;
2989
2990     has_video = 0;
2991     has_audio = 0;
2992     has_subtitle = 0;
2993     for(j=0;j<nb_input_files;j++) {
2994         ic = input_files[j];
2995         for(i=0;i<ic->nb_streams;i++) {
2996             AVCodecContext *enc = ic->streams[i]->codec;
2997             switch(enc->codec_type) {
2998             case CODEC_TYPE_AUDIO:
2999                 has_audio = 1;
3000                 break;
3001             case CODEC_TYPE_VIDEO:
3002                 has_video = 1;
3003                 break;
3004             case CODEC_TYPE_SUBTITLE:
3005                 has_subtitle = 1;
3006                 break;
3007             case CODEC_TYPE_DATA:
3008             case CODEC_TYPE_ATTACHMENT:
3009             case CODEC_TYPE_UNKNOWN:
3010                 break;
3011             default:
3012                 abort();
3013             }
3014         }
3015     }
3016     *has_video_ptr = has_video;
3017     *has_audio_ptr = has_audio;
3018     *has_subtitle_ptr = has_subtitle;
3019 }
3020
3021 static void new_video_stream(AVFormatContext *oc)
3022 {
3023     AVStream *st;
3024     AVCodecContext *video_enc;
3025     int codec_id;
3026
3027     st = av_new_stream(oc, oc->nb_streams);
3028     if (!st) {
3029         fprintf(stderr, "Could not alloc stream\n");
3030         av_exit(1);
3031     }
3032     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3033     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3034     video_bitstream_filters= NULL;
3035
3036     if(thread_count>1)
3037         avcodec_thread_init(st->codec, thread_count);
3038
3039     video_enc = st->codec;
3040
3041     if(video_codec_tag)
3042         video_enc->codec_tag= video_codec_tag;
3043
3044     if(   (video_global_header&1)
3045        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3046         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3047         avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3048     }
3049     if(video_global_header&2){
3050         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3051         avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3052     }
3053
3054     if (video_stream_copy) {
3055         st->stream_copy = 1;
3056         video_enc->codec_type = CODEC_TYPE_VIDEO;
3057         video_enc->sample_aspect_ratio =
3058         st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3059     } else {
3060         const char *p;
3061         int i;
3062         AVCodec *codec;
3063         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3064
3065         if (video_codec_name) {
3066             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3067             codec = avcodec_find_encoder_by_name(video_codec_name);
3068             output_codecs[nb_ocodecs] = codec;
3069         } else {
3070             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3071             codec = avcodec_find_encoder(codec_id);
3072         }
3073
3074         video_enc->codec_id = codec_id;
3075
3076         set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3077
3078         if (codec && codec->supported_framerates && !force_fps)
3079             fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3080         video_enc->time_base.den = fps.num;
3081         video_enc->time_base.num = fps.den;
3082
3083         video_enc->width = frame_width + frame_padright + frame_padleft;
3084         video_enc->height = frame_height + frame_padtop + frame_padbottom;
3085         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3086         video_enc->pix_fmt = frame_pix_fmt;
3087         st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3088
3089         if(codec && codec->pix_fmts){
3090             const enum PixelFormat *p= codec->pix_fmts;
3091             for(; *p!=-1; p++){
3092                 if(*p == video_enc->pix_fmt)
3093                     break;
3094             }
3095             if(*p == -1)
3096                 video_enc->pix_fmt = codec->pix_fmts[0];
3097         }
3098
3099         if (intra_only)
3100             video_enc->gop_size = 0;
3101         if (video_qscale || same_quality) {
3102             video_enc->flags |= CODEC_FLAG_QSCALE;
3103             video_enc->global_quality=
3104                 st->quality = FF_QP2LAMBDA * video_qscale;
3105         }
3106
3107         if(intra_matrix)
3108             video_enc->intra_matrix = intra_matrix;
3109         if(inter_matrix)
3110             video_enc->inter_matrix = inter_matrix;
3111
3112         video_enc->thread_count = thread_count;
3113         p= video_rc_override_string;
3114         for(i=0; p; i++){
3115             int start, end, q;
3116             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3117             if(e!=3){
3118                 fprintf(stderr, "error parsing rc_override\n");
3119                 av_exit(1);
3120             }
3121             video_enc->rc_override=
3122                 av_realloc(video_enc->rc_override,
3123                            sizeof(RcOverride)*(i+1));
3124             video_enc->rc_override[i].start_frame= start;
3125             video_enc->rc_override[i].end_frame  = end;
3126             if(q>0){
3127                 video_enc->rc_override[i].qscale= q;
3128                 video_enc->rc_override[i].quality_factor= 1.0;
3129             }
3130             else{
3131                 video_enc->rc_override[i].qscale= 0;
3132                 video_enc->rc_override[i].quality_factor= -q/100.0;
3133             }
3134             p= strchr(p, '/');
3135             if(p) p++;
3136         }
3137         video_enc->rc_override_count=i;
3138         if (!video_enc->rc_initial_buffer_occupancy)
3139             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3140         video_enc->me_threshold= me_threshold;
3141         video_enc->intra_dc_precision= intra_dc_precision - 8;
3142
3143         if (do_psnr)
3144             video_enc->flags|= CODEC_FLAG_PSNR;
3145
3146         /* two pass mode */
3147         if (do_pass) {
3148             if (do_pass == 1) {
3149                 video_enc->flags |= CODEC_FLAG_PASS1;
3150             } else {
3151                 video_enc->flags |= CODEC_FLAG_PASS2;
3152             }
3153         }
3154     }
3155     nb_ocodecs++;
3156
3157     /* reset some key parameters */
3158     video_disable = 0;
3159     av_freep(&video_codec_name);
3160     video_stream_copy = 0;
3161 }
3162
3163 static void new_audio_stream(AVFormatContext *oc)
3164 {
3165     AVStream *st;
3166     AVCodecContext *audio_enc;
3167     int codec_id;
3168
3169     st = av_new_stream(oc, oc->nb_streams);
3170     if (!st) {
3171         fprintf(stderr, "Could not alloc stream\n");
3172         av_exit(1);
3173     }
3174     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3175
3176     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3177     audio_bitstream_filters= NULL;
3178
3179     if(thread_count>1)
3180         avcodec_thread_init(st->codec, thread_count);
3181
3182     audio_enc = st->codec;
3183     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3184
3185     if(audio_codec_tag)
3186         audio_enc->codec_tag= audio_codec_tag;
3187
3188     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3189         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3190         avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3191     }
3192     if (audio_stream_copy) {
3193         st->stream_copy = 1;
3194         audio_enc->channels = audio_channels;
3195     } else {
3196         AVCodec *codec;
3197
3198         set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3199
3200         if (audio_codec_name) {
3201             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3202             codec = avcodec_find_encoder_by_name(audio_codec_name);
3203             output_codecs[nb_ocodecs] = codec;
3204         } else {
3205             codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3206             codec = avcodec_find_encoder(codec_id);
3207         }
3208         audio_enc->codec_id = codec_id;
3209
3210         if (audio_qscale > QSCALE_NONE) {
3211             audio_enc->flags |= CODEC_FLAG_QSCALE;
3212             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3213         }
3214         audio_enc->thread_count = thread_count;
3215         audio_enc->channels = audio_channels;
3216         audio_enc->sample_fmt = audio_sample_fmt;
3217         audio_enc->channel_layout = channel_layout;
3218
3219         if(codec && codec->sample_fmts){
3220             const enum SampleFormat *p= codec->sample_fmts;
3221             for(; *p!=-1; p++){
3222                 if(*p == audio_enc->sample_fmt)
3223                     break;
3224             }
3225             if(*p == -1)
3226                 audio_enc->sample_fmt = codec->sample_fmts[0];
3227         }
3228     }
3229     nb_ocodecs++;
3230     audio_enc->sample_rate = audio_sample_rate;
3231     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3232     if (audio_language) {
3233         av_metadata_set(&st->metadata, "language", audio_language);
3234         av_free(audio_language);
3235         audio_language = NULL;
3236     }
3237
3238     /* reset some key parameters */
3239     audio_disable = 0;
3240     av_freep(&audio_codec_name);
3241     audio_stream_copy = 0;
3242 }
3243
3244 static void new_subtitle_stream(AVFormatContext *oc)
3245 {
3246     AVStream *st;
3247     AVCodecContext *subtitle_enc;
3248
3249     st = av_new_stream(oc, oc->nb_streams);
3250     if (!st) {
3251         fprintf(stderr, "Could not alloc stream\n");
3252         av_exit(1);
3253     }
3254     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3255
3256     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3257     subtitle_bitstream_filters= NULL;
3258
3259     subtitle_enc = st->codec;
3260     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3261
3262     if(subtitle_codec_tag)
3263         subtitle_enc->codec_tag= subtitle_codec_tag;
3264
3265     if (subtitle_stream_copy) {
3266         st->stream_copy = 1;
3267     } else {
3268         set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3269         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3270         output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3271     }
3272     nb_ocodecs++;
3273
3274     if (subtitle_language) {
3275         av_metadata_set(&st->metadata, "language", subtitle_language);
3276         av_free(subtitle_language);
3277         subtitle_language = NULL;
3278     }
3279
3280     subtitle_disable = 0;
3281     av_freep(&subtitle_codec_name);
3282     subtitle_stream_copy = 0;
3283 }
3284
3285 static void opt_new_audio_stream(void)
3286 {
3287     AVFormatContext *oc;
3288     if (nb_output_files <= 0) {
3289         fprintf(stderr, "At least one output file must be specified\n");
3290         av_exit(1);
3291     }
3292     oc = output_files[nb_output_files - 1];
3293     new_audio_stream(oc);
3294 }
3295
3296 static void opt_new_video_stream(void)
3297 {
3298     AVFormatContext *oc;
3299     if (nb_output_files <= 0) {
3300         fprintf(stderr, "At least one output file must be specified\n");
3301         av_exit(1);
3302     }
3303     oc = output_files[nb_output_files - 1];
3304     new_video_stream(oc);
3305 }
3306
3307 static void opt_new_subtitle_stream(void)
3308 {
3309     AVFormatContext *oc;
3310     if (nb_output_files <= 0) {
3311         fprintf(stderr, "At least one output file must be specified\n");
3312         av_exit(1);
3313     }
3314     oc = output_files[nb_output_files - 1];
3315     new_subtitle_stream(oc);
3316 }
3317
3318 static void opt_output_file(const char *filename)
3319 {
3320     AVFormatContext *oc;
3321     int use_video, use_audio, use_subtitle;
3322     int input_has_video, input_has_audio, input_has_subtitle;
3323     AVFormatParameters params, *ap = &params;
3324
3325     if (!strcmp(filename, "-"))
3326         filename = "pipe:";
3327
3328     oc = avformat_alloc_context();
3329
3330     if (!file_oformat) {
3331         file_oformat = guess_format(NULL, filename, NULL);
3332         if (!file_oformat) {
3333             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3334                     filename);
3335             av_exit(1);
3336         }
3337     }
3338
3339     oc->oformat = file_oformat;
3340     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3341
3342     if (!strcmp(file_oformat->name, "ffm") &&
3343         av_strstart(filename, "http:", NULL)) {
3344         /* special case for files sent to ffserver: we get the stream
3345            parameters from ffserver */
3346         int err = read_ffserver_streams(oc, filename);
3347         if (err < 0) {
3348             print_error(filename, err);
3349             av_exit(1);
3350         }
3351     } else {
3352         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3353         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3354         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3355
3356         /* disable if no corresponding type found and at least one
3357            input file */
3358         if (nb_input_files > 0) {
3359             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3360                                          &input_has_subtitle);
3361             if (!input_has_video)
3362                 use_video = 0;
3363             if (!input_has_audio)
3364                 use_audio = 0;
3365             if (!input_has_subtitle)
3366                 use_subtitle = 0;
3367         }
3368
3369         /* manual disable */
3370         if (audio_disable) {
3371             use_audio = 0;
3372         }
3373         if (video_disable) {
3374             use_video = 0;
3375         }
3376         if (subtitle_disable) {
3377             use_subtitle = 0;
3378         }
3379
3380         if (use_video) {
3381             new_video_stream(oc);
3382         }
3383
3384         if (use_audio) {
3385             new_audio_stream(oc);
3386         }
3387
3388         if (use_subtitle) {
3389             new_subtitle_stream(oc);
3390         }
3391
3392         oc->timestamp = rec_timestamp;
3393
3394         for(; metadata_count>0; metadata_count--){
3395             av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3396                                            metadata[metadata_count-1].value);
3397         }
3398         av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3399     }
3400
3401     output_files[nb_output_files++] = oc;
3402
3403     /* check filename in case of an image number is expected */
3404     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3405         if (!av_filename_number_test(oc->filename)) {
3406             print_error(oc->filename, AVERROR_NUMEXPECTED);
3407             av_exit(1);
3408         }
3409     }
3410
3411     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3412         /* test if it already exists to avoid loosing precious files */
3413         if (!file_overwrite &&
3414             (strchr(filename, ':') == NULL ||
3415              filename[1] == ':' ||
3416              av_strstart(filename, "file:", NULL))) {
3417             if (url_exist(filename)) {
3418                 if (!using_stdin) {
3419                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3420                     fflush(stderr);
3421                     if (!read_yesno()) {
3422                         fprintf(stderr, "Not overwriting - exiting\n");
3423                         av_exit(1);
3424                     }
3425                 }
3426                 else {
3427                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3428                     av_exit(1);
3429                 }
3430             }
3431         }
3432
3433         /* open the file */
3434         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3435             fprintf(stderr, "Could not open '%s'\n", filename);
3436             av_exit(1);
3437         }
3438     }
3439
3440     memset(ap, 0, sizeof(*ap));
3441     if (av_set_parameters(oc, ap) < 0) {
3442         fprintf(stderr, "%s: Invalid encoding parameters\n",
3443                 oc->filename);
3444         av_exit(1);
3445     }
3446
3447     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3448     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3449     oc->loop_output = loop_output;
3450     oc->flags |= AVFMT_FLAG_NONBLOCK;
3451
3452     set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3453
3454     /* reset some options */
3455     file_oformat = NULL;
3456     file_iformat = NULL;
3457 }
3458
3459 /* same option as mencoder */
3460 static void opt_pass(const char *pass_str)
3461 {
3462     int pass;
3463     pass = atoi(pass_str);
3464     if (pass != 1 && pass != 2) {
3465         fprintf(stderr, "pass number can be only 1 or 2\n");
3466         av_exit(1);
3467     }
3468     do_pass = pass;
3469 }
3470
3471 static int64_t getutime(void)
3472 {
3473 #if HAVE_GETRUSAGE
3474     struct rusage rusage;
3475
3476     getrusage(RUSAGE_SELF, &rusage);
3477     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3478 #elif HAVE_GETPROCESSTIMES
3479     HANDLE proc;
3480     FILETIME c, e, k, u;
3481     proc = GetCurrentProcess();
3482     GetProcessTimes(proc, &c, &e, &k, &u);
3483     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3484 #else
3485     return av_gettime();
3486 #endif
3487 }
3488
3489 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3490 {
3491     int i;
3492     const char *p = str;
3493     for(i = 0;; i++) {
3494         dest[i] = atoi(p);
3495         if(i == 63)
3496             break;
3497         p = strchr(p, ',');
3498         if(!p) {
3499             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3500             av_exit(1);
3501         }
3502         p++;
3503     }
3504 }
3505
3506 static void opt_inter_matrix(const char *arg)
3507 {
3508     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3509     parse_matrix_coeffs(inter_matrix, arg);
3510 }
3511
3512 static void opt_intra_matrix(const char *arg)
3513 {
3514     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3515     parse_matrix_coeffs(intra_matrix, arg);
3516 }
3517
3518 /**
3519  * Trivial log callback.
3520  * Only suitable for show_help and similar since it lacks prefix handling.
3521  */
3522 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3523 {
3524     vfprintf(stdout, fmt, vl);
3525 }
3526
3527 static void show_help(void)
3528 {
3529     av_log_set_callback(log_callback_help);
3530     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3531            "Hyper fast Audio and Video encoder\n");
3532     printf("\n");
3533     show_help_options(options, "Main options:\n",
3534                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3535     show_help_options(options, "\nAdvanced options:\n",
3536                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3537                       OPT_EXPERT);
3538     show_help_options(options, "\nVideo options:\n",
3539                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3540                       OPT_VIDEO);
3541     show_help_options(options, "\nAdvanced Video options:\n",
3542                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3543                       OPT_VIDEO | OPT_EXPERT);
3544     show_help_options(options, "\nAudio options:\n",
3545                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3546                       OPT_AUDIO);
3547     show_help_options(options, "\nAdvanced Audio options:\n",
3548                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3549                       OPT_AUDIO | OPT_EXPERT);
3550     show_help_options(options, "\nSubtitle options:\n",
3551                       OPT_SUBTITLE | OPT_GRAB,
3552                       OPT_SUBTITLE);
3553     show_help_options(options, "\nAudio/Video grab options:\n",
3554                       OPT_GRAB,
3555                       OPT_GRAB);
3556     printf("\n");
3557     av_opt_show(avcodec_opts[0], NULL);
3558     printf("\n");
3559     av_opt_show(avformat_opts, NULL);
3560     printf("\n");
3561     av_opt_show(sws_opts, NULL);
3562 }
3563
3564 static void opt_target(const char *arg)
3565 {
3566     int norm = -1;
3567     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3568
3569     if(!strncmp(arg, "pal-", 4)) {
3570         norm = 0;
3571         arg += 4;
3572     } else if(!strncmp(arg, "ntsc-", 5)) {
3573         norm = 1;
3574         arg += 5;
3575     } else if(!strncmp(arg, "film-", 5)) {
3576         norm = 2;
3577         arg += 5;
3578     } else {
3579         int fr;
3580         /* Calculate FR via float to avoid int overflow */
3581         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3582         if(fr == 25000) {
3583             norm = 0;
3584         } else if((fr == 29970) || (fr == 23976)) {
3585             norm = 1;
3586         } else {
3587             /* Try to determine PAL/NTSC by peeking in the input files */
3588             if(nb_input_files) {
3589                 int i, j;
3590                 for(j = 0; j < nb_input_files; j++) {
3591                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3592                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3593                         if(c->codec_type != CODEC_TYPE_VIDEO)
3594                             continue;
3595                         fr = c->time_base.den * 1000 / c->time_base.num;
3596                         if(fr == 25000) {
3597                             norm = 0;
3598                             break;
3599                         } else if((fr == 29970) || (fr == 23976)) {
3600                             norm = 1;
3601                             break;
3602                         }
3603                     }
3604                     if(norm >= 0)
3605                         break;
3606                 }
3607             }
3608         }
3609         if(verbose && norm >= 0)
3610             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3611     }
3612
3613     if(norm < 0) {
3614         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3615         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3616         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3617         av_exit(1);
3618     }
3619
3620     if(!strcmp(arg, "vcd")) {
3621
3622         opt_video_codec("mpeg1video");
3623         opt_audio_codec("mp2");
3624         opt_format("vcd");
3625
3626         opt_frame_size(norm ? "352x240" : "352x288");
3627         opt_frame_rate(NULL, frame_rates[norm]);
3628         opt_default("gop", norm ? "18" : "15");
3629
3630         opt_default("b", "1150000");
3631         opt_default("maxrate", "1150000");
3632         opt_default("minrate", "1150000");
3633         opt_default("bufsize", "327680"); // 40*1024*8;
3634
3635         opt_default("ab", "224000");
3636         audio_sample_rate = 44100;
3637         audio_channels = 2;
3638
3639         opt_default("packetsize", "2324");
3640         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3641
3642         /* We have to offset the PTS, so that it is consistent with the SCR.
3643            SCR starts at 36000, but the first two packs contain only padding
3644            and the first pack from the other stream, respectively, may also have
3645            been written before.
3646            So the real data starts at SCR 36000+3*1200. */
3647         mux_preload= (36000+3*1200) / 90000.0; //0.44
3648     } else if(!strcmp(arg, "svcd")) {
3649
3650         opt_video_codec("mpeg2video");
3651         opt_audio_codec("mp2");
3652         opt_format("svcd");
3653
3654         opt_frame_size(norm ? "480x480" : "480x576");
3655         opt_frame_rate(NULL, frame_rates[norm]);
3656         opt_default("gop", norm ? "18" : "15");
3657
3658         opt_default("b", "2040000");
3659         opt_default("maxrate", "2516000");
3660         opt_default("minrate", "0"); //1145000;
3661         opt_default("bufsize", "1835008"); //224*1024*8;
3662         opt_default("flags", "+scan_offset");
3663
3664
3665         opt_default("ab", "224000");
3666         audio_sample_rate = 44100;
3667
3668         opt_default("packetsize", "2324");
3669
3670     } else if(!strcmp(arg, "dvd")) {
3671
3672         opt_video_codec("mpeg2video");
3673         opt_audio_codec("ac3");
3674         opt_format("dvd");
3675
3676         opt_frame_size(norm ? "720x480" : "720x576");
3677         opt_frame_rate(NULL, frame_rates[norm]);
3678         opt_default("gop", norm ? "18" : "15");
3679
3680         opt_default("b", "6000000");
3681         opt_default("maxrate", "9000000");
3682         opt_default("minrate", "0"); //1500000;
3683         opt_default("bufsize", "1835008"); //224*1024*8;
3684
3685         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3686         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3687
3688         opt_default("ab", "448000");
3689         audio_sample_rate = 48000;
3690
3691     } else if(!strncmp(arg, "dv", 2)) {
3692
3693         opt_format("dv");
3694
3695         opt_frame_size(norm ? "720x480" : "720x576");
3696         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3697                                              (norm ? "yuv411p" : "yuv420p"));
3698         opt_frame_rate(NULL, frame_rates[norm]);
3699
3700         audio_sample_rate = 48000;
3701         audio_channels = 2;
3702
3703     } else {
3704         fprintf(stderr, "Unknown target: %s\n", arg);
3705         av_exit(1);
3706     }
3707 }