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