Allow overriding codec_ids.
[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
2666     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2667     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2668     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2669
2670     /* open the input file with generic libav function */
2671     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2672     if (err < 0) {
2673         print_error(filename, err);
2674         exit(1);
2675     }
2676     if(opt_programid) {
2677         int i;
2678         for(i=0; i<ic->nb_programs; i++)
2679             if(ic->programs[i]->id != opt_programid)
2680                 ic->programs[i]->discard = AVDISCARD_ALL;
2681     }
2682
2683     ic->loop_input = loop_input;
2684
2685     /* If not enough info to get the stream parameters, we decode the
2686        first frames to get it. (used in mpeg case for example) */
2687     ret = av_find_stream_info(ic);
2688     if (ret < 0 && verbose >= 0) {
2689         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2690         exit(1);
2691     }
2692
2693     timestamp = start_time;
2694     /* add the stream start time */
2695     if (ic->start_time != AV_NOPTS_VALUE)
2696         timestamp += ic->start_time;
2697
2698     /* if seeking requested, we execute it */
2699     if (start_time != 0) {
2700         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2701         if (ret < 0) {
2702             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2703                     filename, (double)timestamp / AV_TIME_BASE);
2704         }
2705         /* reset seek info */
2706         start_time = 0;
2707     }
2708
2709     /* update the current parameters so that they match the one of the input stream */
2710     for(i=0;i<ic->nb_streams;i++) {
2711         int j;
2712         AVCodecContext *enc = ic->streams[i]->codec;
2713         if(thread_count>1)
2714             avcodec_thread_init(enc, thread_count);
2715         enc->thread_count= thread_count;
2716         switch(enc->codec_type) {
2717         case CODEC_TYPE_AUDIO:
2718             for(j=0; j<opt_name_count; j++){
2719                 char buf[256];
2720                 const AVOption *opt;
2721                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2722                 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2723                     av_set_string(enc, opt_names[j], str);
2724             }
2725             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2726             audio_channels = enc->channels;
2727             audio_sample_rate = enc->sample_rate;
2728             if(audio_disable)
2729                 ic->streams[i]->discard= AVDISCARD_ALL;
2730             break;
2731         case CODEC_TYPE_VIDEO:
2732             for(j=0; j<opt_name_count; j++){
2733                 char buf[256];
2734                 const AVOption *opt;
2735                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2736                 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2737                     av_set_string(enc, opt_names[j], str);
2738             }
2739             frame_height = enc->height;
2740             frame_width = enc->width;
2741             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2742             frame_pix_fmt = enc->pix_fmt;
2743             rfps      = ic->streams[i]->r_frame_rate.num;
2744             rfps_base = ic->streams[i]->r_frame_rate.den;
2745             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2746             if(me_threshold)
2747                 enc->debug |= FF_DEBUG_MV;
2748
2749             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2750
2751                 if (verbose >= 0)
2752                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2753                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2754
2755                     (float)rfps / rfps_base, rfps, rfps_base);
2756             }
2757             /* update the current frame rate to match the stream frame rate */
2758             frame_rate.num = rfps;
2759             frame_rate.den = rfps_base;
2760
2761             enc->rate_emu = rate_emu;
2762             if(video_disable)
2763                 ic->streams[i]->discard= AVDISCARD_ALL;
2764             else if(video_discard)
2765                 ic->streams[i]->discard= video_discard;
2766             break;
2767         case CODEC_TYPE_DATA:
2768             break;
2769         case CODEC_TYPE_SUBTITLE:
2770             if(subtitle_disable)
2771                 ic->streams[i]->discard = AVDISCARD_ALL;
2772             break;
2773         case CODEC_TYPE_UNKNOWN:
2774             break;
2775         default:
2776             abort();
2777         }
2778     }
2779
2780     input_files[nb_input_files] = ic;
2781     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2782     /* dump the file content */
2783     if (verbose >= 0)
2784         dump_format(ic, nb_input_files, filename, 0);
2785
2786     nb_input_files++;
2787     file_iformat = NULL;
2788     file_oformat = NULL;
2789
2790     video_channel = 0;
2791
2792     rate_emu = 0;
2793 }
2794
2795 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2796                                          int *has_subtitle_ptr)
2797 {
2798     int has_video, has_audio, has_subtitle, i, j;
2799     AVFormatContext *ic;
2800
2801     has_video = 0;
2802     has_audio = 0;
2803     has_subtitle = 0;
2804     for(j=0;j<nb_input_files;j++) {
2805         ic = input_files[j];
2806         for(i=0;i<ic->nb_streams;i++) {
2807             AVCodecContext *enc = ic->streams[i]->codec;
2808             switch(enc->codec_type) {
2809             case CODEC_TYPE_AUDIO:
2810                 has_audio = 1;
2811                 break;
2812             case CODEC_TYPE_VIDEO:
2813                 has_video = 1;
2814                 break;
2815             case CODEC_TYPE_SUBTITLE:
2816                 has_subtitle = 1;
2817                 break;
2818             case CODEC_TYPE_DATA:
2819             case CODEC_TYPE_UNKNOWN:
2820                 break;
2821             default:
2822                 abort();
2823             }
2824         }
2825     }
2826     *has_video_ptr = has_video;
2827     *has_audio_ptr = has_audio;
2828     *has_subtitle_ptr = has_subtitle;
2829 }
2830
2831 static void new_video_stream(AVFormatContext *oc)
2832 {
2833     AVStream *st;
2834     AVCodecContext *video_enc;
2835     int codec_id;
2836
2837     st = av_new_stream(oc, oc->nb_streams);
2838     if (!st) {
2839         fprintf(stderr, "Could not alloc stream\n");
2840         exit(1);
2841     }
2842     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2843     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2844     video_bitstream_filters= NULL;
2845
2846     if(thread_count>1)
2847         avcodec_thread_init(st->codec, thread_count);
2848
2849     video_enc = st->codec;
2850
2851     if(video_codec_tag)
2852         video_enc->codec_tag= video_codec_tag;
2853
2854     if(   (video_global_header&1)
2855        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2856         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2857         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2858     }
2859     if(video_global_header&2){
2860         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2861         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2862     }
2863
2864     if (video_stream_copy) {
2865         st->stream_copy = 1;
2866         video_enc->codec_type = CODEC_TYPE_VIDEO;
2867     } else {
2868         char *p;
2869         int i;
2870         AVCodec *codec;
2871
2872         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2873         if (video_codec_name)
2874             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2875
2876         video_enc->codec_id = codec_id;
2877         codec = avcodec_find_encoder(codec_id);
2878
2879         for(i=0; i<opt_name_count; i++){
2880             char buf[256];
2881             const AVOption *opt;
2882             const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2883             if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2884                 av_set_string(video_enc, opt_names[i], str);
2885         }
2886
2887         video_enc->time_base.den = frame_rate.num;
2888         video_enc->time_base.num = frame_rate.den;
2889         if(codec && codec->supported_framerates){
2890             const AVRational *p= codec->supported_framerates;
2891             AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2892             const AVRational *best=NULL;
2893             AVRational best_error= (AVRational){INT_MAX, 1};
2894             for(; p->den!=0; p++){
2895                 AVRational error= av_sub_q(req, *p);
2896                 if(error.num <0) error.num *= -1;
2897                 if(av_cmp_q(error, best_error) < 0){
2898                     best_error= error;
2899                     best= p;
2900                 }
2901             }
2902             video_enc->time_base.den= best->num;
2903             video_enc->time_base.num= best->den;
2904         }
2905
2906         video_enc->width = frame_width + frame_padright + frame_padleft;
2907         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2908         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2909         video_enc->pix_fmt = frame_pix_fmt;
2910
2911         if(codec && codec->pix_fmts){
2912             const enum PixelFormat *p= codec->pix_fmts;
2913             for(; *p!=-1; p++){
2914                 if(*p == video_enc->pix_fmt)
2915                     break;
2916             }
2917             if(*p == -1)
2918                 video_enc->pix_fmt = codec->pix_fmts[0];
2919         }
2920
2921         if (intra_only)
2922             video_enc->gop_size = 0;
2923         if (video_qscale || same_quality) {
2924             video_enc->flags |= CODEC_FLAG_QSCALE;
2925             video_enc->global_quality=
2926                 st->quality = FF_QP2LAMBDA * video_qscale;
2927         }
2928
2929         if(intra_matrix)
2930             video_enc->intra_matrix = intra_matrix;
2931         if(inter_matrix)
2932             video_enc->inter_matrix = inter_matrix;
2933
2934         video_enc->max_qdiff = video_qdiff;
2935         video_enc->thread_count = thread_count;
2936         p= video_rc_override_string;
2937         for(i=0; p; i++){
2938             int start, end, q;
2939             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2940             if(e!=3){
2941                 fprintf(stderr, "error parsing rc_override\n");
2942                 exit(1);
2943             }
2944             video_enc->rc_override=
2945                 av_realloc(video_enc->rc_override,
2946                            sizeof(RcOverride)*(i+1));
2947             video_enc->rc_override[i].start_frame= start;
2948             video_enc->rc_override[i].end_frame  = end;
2949             if(q>0){
2950                 video_enc->rc_override[i].qscale= q;
2951                 video_enc->rc_override[i].quality_factor= 1.0;
2952             }
2953             else{
2954                 video_enc->rc_override[i].qscale= 0;
2955                 video_enc->rc_override[i].quality_factor= -q/100.0;
2956             }
2957             p= strchr(p, '/');
2958             if(p) p++;
2959         }
2960         video_enc->rc_override_count=i;
2961         if (!video_enc->rc_initial_buffer_occupancy)
2962             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2963         video_enc->me_threshold= me_threshold;
2964         video_enc->intra_dc_precision= intra_dc_precision - 8;
2965         video_enc->strict_std_compliance = strict;
2966
2967         if (do_psnr)
2968             video_enc->flags|= CODEC_FLAG_PSNR;
2969
2970         /* two pass mode */
2971         if (do_pass) {
2972             if (do_pass == 1) {
2973                 video_enc->flags |= CODEC_FLAG_PASS1;
2974             } else {
2975                 video_enc->flags |= CODEC_FLAG_PASS2;
2976             }
2977         }
2978     }
2979
2980     /* reset some key parameters */
2981     video_disable = 0;
2982     av_freep(&video_codec_name);
2983     video_stream_copy = 0;
2984 }
2985
2986 static void new_audio_stream(AVFormatContext *oc)
2987 {
2988     AVStream *st;
2989     AVCodecContext *audio_enc;
2990     int codec_id, i;
2991
2992     st = av_new_stream(oc, oc->nb_streams);
2993     if (!st) {
2994         fprintf(stderr, "Could not alloc stream\n");
2995         exit(1);
2996     }
2997     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2998
2999     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3000     audio_bitstream_filters= NULL;
3001
3002     if(thread_count>1)
3003         avcodec_thread_init(st->codec, thread_count);
3004
3005     audio_enc = st->codec;
3006     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3007     audio_enc->strict_std_compliance = strict;
3008
3009     if(audio_codec_tag)
3010         audio_enc->codec_tag= audio_codec_tag;
3011
3012     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3013         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3014         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3015     }
3016     if (audio_stream_copy) {
3017         st->stream_copy = 1;
3018         audio_enc->channels = audio_channels;
3019     } else {
3020         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3021
3022         for(i=0; i<opt_name_count; i++){
3023             char buf[256];
3024             const AVOption *opt;
3025             const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3026             if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3027                 av_set_string(audio_enc, opt_names[i], str);
3028         }
3029
3030         if (audio_codec_name)
3031             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3032         audio_enc->codec_id = codec_id;
3033
3034         if (audio_qscale > QSCALE_NONE) {
3035             audio_enc->flags |= CODEC_FLAG_QSCALE;
3036             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3037         }
3038         audio_enc->thread_count = thread_count;
3039         audio_enc->channels = audio_channels;
3040     }
3041     audio_enc->sample_rate = audio_sample_rate;
3042     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3043     if (audio_language) {
3044         av_strlcpy(st->language, audio_language, sizeof(st->language));
3045         av_free(audio_language);
3046         audio_language = NULL;
3047     }
3048
3049     /* reset some key parameters */
3050     audio_disable = 0;
3051     av_freep(&audio_codec_name);
3052     audio_stream_copy = 0;
3053 }
3054
3055 static void new_subtitle_stream(AVFormatContext *oc)
3056 {
3057     AVStream *st;
3058     AVCodecContext *subtitle_enc;
3059     int i;
3060
3061     st = av_new_stream(oc, oc->nb_streams);
3062     if (!st) {
3063         fprintf(stderr, "Could not alloc stream\n");
3064         exit(1);
3065     }
3066     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3067
3068     subtitle_enc = st->codec;
3069     subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3070     if (subtitle_stream_copy) {
3071         st->stream_copy = 1;
3072     } else {
3073         for(i=0; i<opt_name_count; i++){
3074             char buf[256];
3075             const AVOption *opt;
3076             const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3077             if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3078                 av_set_string(subtitle_enc, opt_names[i], str);
3079         }
3080         subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3081     }
3082
3083     if (subtitle_language) {
3084         av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3085         av_free(subtitle_language);
3086         subtitle_language = NULL;
3087     }
3088
3089     subtitle_disable = 0;
3090     av_freep(&subtitle_codec_name);
3091     subtitle_stream_copy = 0;
3092 }
3093
3094 static void opt_new_audio_stream(void)
3095 {
3096     AVFormatContext *oc;
3097     if (nb_output_files <= 0) {
3098         fprintf(stderr, "At least one output file must be specified\n");
3099         exit(1);
3100     }
3101     oc = output_files[nb_output_files - 1];
3102     new_audio_stream(oc);
3103 }
3104
3105 static void opt_new_video_stream(void)
3106 {
3107     AVFormatContext *oc;
3108     if (nb_output_files <= 0) {
3109         fprintf(stderr, "At least one output file must be specified\n");
3110         exit(1);
3111     }
3112     oc = output_files[nb_output_files - 1];
3113     new_video_stream(oc);
3114 }
3115
3116 static void opt_new_subtitle_stream(void)
3117 {
3118     AVFormatContext *oc;
3119     if (nb_output_files <= 0) {
3120         fprintf(stderr, "At least one output file must be specified\n");
3121         exit(1);
3122     }
3123     oc = output_files[nb_output_files - 1];
3124     new_subtitle_stream(oc);
3125 }
3126
3127 static void opt_output_file(const char *filename)
3128 {
3129     AVFormatContext *oc;
3130     int use_video, use_audio, use_subtitle;
3131     int input_has_video, input_has_audio, input_has_subtitle, i;
3132     AVFormatParameters params, *ap = &params;
3133
3134     if (!strcmp(filename, "-"))
3135         filename = "pipe:";
3136
3137     oc = av_alloc_format_context();
3138
3139     if (!file_oformat) {
3140         file_oformat = guess_format(NULL, filename, NULL);
3141         if (!file_oformat) {
3142             fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3143                     filename);
3144             exit(1);
3145         }
3146     }
3147
3148     oc->oformat = file_oformat;
3149     av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3150
3151     if (!strcmp(file_oformat->name, "ffm") &&
3152         av_strstart(filename, "http:", NULL)) {
3153         /* special case for files sent to ffserver: we get the stream
3154            parameters from ffserver */
3155         if (read_ffserver_streams(oc, filename) < 0) {
3156             fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3157             exit(1);
3158         }
3159     } else {
3160         use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3161         use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3162         use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3163
3164         /* disable if no corresponding type found and at least one
3165            input file */
3166         if (nb_input_files > 0) {
3167             check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3168                                          &input_has_subtitle);
3169             if (!input_has_video)
3170                 use_video = 0;
3171             if (!input_has_audio)
3172                 use_audio = 0;
3173             if (!input_has_subtitle)
3174                 use_subtitle = 0;
3175         }
3176
3177         /* manual disable */
3178         if (audio_disable) {
3179             use_audio = 0;
3180         }
3181         if (video_disable) {
3182             use_video = 0;
3183         }
3184         if (subtitle_disable) {
3185             use_subtitle = 0;
3186         }
3187
3188         if (use_video) {
3189             new_video_stream(oc);
3190         }
3191
3192         if (use_audio) {
3193             new_audio_stream(oc);
3194         }
3195
3196         if (use_subtitle) {
3197             new_subtitle_stream(oc);
3198         }
3199
3200         oc->timestamp = rec_timestamp;
3201
3202         if (str_title)
3203             av_strlcpy(oc->title, str_title, sizeof(oc->title));
3204         if (str_author)
3205             av_strlcpy(oc->author, str_author, sizeof(oc->author));
3206         if (str_copyright)
3207             av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3208         if (str_comment)
3209             av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3210         if (str_album)
3211             av_strlcpy(oc->album, str_album, sizeof(oc->album));
3212     }
3213
3214     output_files[nb_output_files++] = oc;
3215
3216     /* check filename in case of an image number is expected */
3217     if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3218         if (!av_filename_number_test(oc->filename)) {
3219             print_error(oc->filename, AVERROR_NUMEXPECTED);
3220             exit(1);
3221         }
3222     }
3223
3224     if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3225         /* test if it already exists to avoid loosing precious files */
3226         if (!file_overwrite &&
3227             (strchr(filename, ':') == NULL ||
3228              av_strstart(filename, "file:", NULL))) {
3229             if (url_exist(filename)) {
3230                 int c;
3231
3232                 if ( !using_stdin ) {
3233                     fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3234                     fflush(stderr);
3235                     c = getchar();
3236                     if (toupper(c) != 'Y') {
3237                         fprintf(stderr, "Not overwriting - exiting\n");
3238                         exit(1);
3239                     }
3240                                 }
3241                                 else {
3242                     fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3243                     exit(1);
3244                                 }
3245             }
3246         }
3247
3248         /* open the file */
3249         if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3250             fprintf(stderr, "Could not open '%s'\n", filename);
3251             exit(1);
3252         }
3253     }
3254
3255     memset(ap, 0, sizeof(*ap));
3256     if (av_set_parameters(oc, ap) < 0) {
3257         fprintf(stderr, "%s: Invalid encoding parameters\n",
3258                 oc->filename);
3259         exit(1);
3260     }
3261
3262     oc->preload= (int)(mux_preload*AV_TIME_BASE);
3263     oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3264     oc->loop_output = loop_output;
3265
3266     for(i=0; i<opt_name_count; i++){
3267         char buf[256];
3268         const AVOption *opt;
3269         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3270         if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3271             av_set_string(oc, opt_names[i], str);
3272     }
3273
3274     /* reset some options */
3275     file_oformat = NULL;
3276     file_iformat = NULL;
3277 }
3278
3279 /* same option as mencoder */
3280 static void opt_pass(const char *pass_str)
3281 {
3282     int pass;
3283     pass = atoi(pass_str);
3284     if (pass != 1 && pass != 2) {
3285         fprintf(stderr, "pass number can be only 1 or 2\n");
3286         exit(1);
3287     }
3288     do_pass = pass;
3289 }
3290
3291 static int64_t getutime(void)
3292 {
3293 #ifdef HAVE_GETRUSAGE
3294     struct rusage rusage;
3295
3296     getrusage(RUSAGE_SELF, &rusage);
3297     return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3298 #elif defined(HAVE_GETPROCESSTIMES)
3299     HANDLE proc;
3300     FILETIME c, e, k, u;
3301     proc = GetCurrentProcess();
3302     GetProcessTimes(proc, &c, &e, &k, &u);
3303     return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3304 #else
3305     return av_gettime();
3306 #endif
3307 }
3308
3309 static void opt_show_formats(void)
3310 {
3311     AVInputFormat *ifmt=NULL;
3312     AVOutputFormat *ofmt=NULL;
3313     URLProtocol *up=NULL;
3314     AVCodec *p=NULL, *p2;
3315     AVBitStreamFilter *bsf=NULL;
3316     const char *last_name;
3317
3318     printf("File formats:\n");
3319     last_name= "000";
3320     for(;;){
3321         int decode=0;
3322         int encode=0;
3323         const char *name=NULL;
3324         const char *long_name=NULL;
3325
3326         while(ofmt= av_oformat_next(ofmt)) {
3327             if((name == NULL || strcmp(ofmt->name, name)<0) &&
3328                 strcmp(ofmt->name, last_name)>0){
3329                 name= ofmt->name;
3330                 long_name= ofmt->long_name;
3331                 encode=1;
3332             }
3333         }
3334         while(ifmt= av_iformat_next(ifmt)) {
3335             if((name == NULL || strcmp(ifmt->name, name)<0) &&
3336                 strcmp(ifmt->name, last_name)>0){
3337                 name= ifmt->name;
3338                 long_name= ifmt->long_name;
3339                 encode=0;
3340             }
3341             if(name && strcmp(ifmt->name, name)==0)
3342                 decode=1;
3343         }
3344         if(name==NULL)
3345             break;
3346         last_name= name;
3347
3348         printf(
3349             " %s%s %-15s %s\n",
3350             decode ? "D":" ",
3351             encode ? "E":" ",
3352             name,
3353             long_name ? long_name:" ");
3354     }
3355     printf("\n");
3356
3357     printf("Codecs:\n");
3358     last_name= "000";
3359     for(;;){
3360         int decode=0;
3361         int encode=0;
3362         int cap=0;
3363         const char *type_str;
3364
3365         p2=NULL;
3366         while(p= av_codec_next(p)) {
3367             if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3368                 strcmp(p->name, last_name)>0){
3369                 p2= p;
3370                 decode= encode= cap=0;
3371             }
3372             if(p2 && strcmp(p->name, p2->name)==0){
3373                 if(p->decode) decode=1;
3374                 if(p->encode) encode=1;
3375                 cap |= p->capabilities;
3376             }
3377         }
3378         if(p2==NULL)
3379             break;
3380         last_name= p2->name;
3381
3382         switch(p2->type) {
3383         case CODEC_TYPE_VIDEO:
3384             type_str = "V";
3385             break;
3386         case CODEC_TYPE_AUDIO:
3387             type_str = "A";
3388             break;
3389         case CODEC_TYPE_SUBTITLE:
3390             type_str = "S";
3391             break;
3392         default:
3393             type_str = "?";
3394             break;
3395         }
3396         printf(
3397             " %s%s%s%s%s%s %s",
3398             decode ? "D": (/*p2->decoder ? "d":*/" "),
3399             encode ? "E":" ",
3400             type_str,
3401             cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3402             cap & CODEC_CAP_DR1 ? "D":" ",
3403             cap & CODEC_CAP_TRUNCATED ? "T":" ",
3404             p2->name);
3405        /* if(p2->decoder && decode==0)
3406             printf(" use %s for decoding", p2->decoder->name);*/
3407         printf("\n");
3408     }
3409     printf("\n");
3410
3411     printf("Bitstream filters:\n");
3412     while(bsf = av_bitstream_filter_next(bsf))
3413         printf(" %s", bsf->name);
3414     printf("\n");
3415
3416     printf("Supported file protocols:\n");
3417     while(up = av_protocol_next(up))
3418         printf(" %s:", up->name);
3419     printf("\n");
3420
3421     printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3422     printf("\n");
3423     printf(
3424 "Note, the names of encoders and decoders do not always match, so there are\n"
3425 "several cases where the above table shows encoder only or decoder only entries\n"
3426 "even though both encoding and decoding are supported. For example, the h263\n"
3427 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3428 "worse.\n");
3429     exit(0);
3430 }
3431
3432 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3433 {
3434     int i;
3435     const char *p = str;
3436     for(i = 0;; i++) {
3437         dest[i] = atoi(p);
3438         if(i == 63)
3439             break;
3440         p = strchr(p, ',');
3441         if(!p) {
3442             fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3443             exit(1);
3444         }
3445         p++;
3446     }
3447 }
3448
3449 static void opt_inter_matrix(const char *arg)
3450 {
3451     inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3452     parse_matrix_coeffs(inter_matrix, arg);
3453 }
3454
3455 static void opt_intra_matrix(const char *arg)
3456 {
3457     intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3458     parse_matrix_coeffs(intra_matrix, arg);
3459 }
3460
3461 /**
3462  * Trivial log callback.
3463  * Only suitable for show_help and similar since it lacks prefix handling.
3464  */
3465 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3466 {
3467     vfprintf(stdout, fmt, vl);
3468 }
3469
3470 static void show_help(void)
3471 {
3472     av_log_set_callback(log_callback_help);
3473     printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3474            "Hyper fast Audio and Video encoder\n");
3475     printf("\n");
3476     show_help_options(options, "Main options:\n",
3477                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3478     show_help_options(options, "\nVideo options:\n",
3479                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3480                       OPT_VIDEO);
3481     show_help_options(options, "\nAdvanced Video options:\n",
3482                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3483                       OPT_VIDEO | OPT_EXPERT);
3484     show_help_options(options, "\nAudio options:\n",
3485                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3486                       OPT_AUDIO);
3487     show_help_options(options, "\nAdvanced Audio options:\n",
3488                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3489                       OPT_AUDIO | OPT_EXPERT);
3490     show_help_options(options, "\nSubtitle options:\n",
3491                       OPT_SUBTITLE | OPT_GRAB,
3492                       OPT_SUBTITLE);
3493     show_help_options(options, "\nAudio/Video grab options:\n",
3494                       OPT_GRAB,
3495                       OPT_GRAB);
3496     show_help_options(options, "\nAdvanced options:\n",
3497                       OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3498                       OPT_EXPERT);
3499     av_opt_show(avctx_opts[0], NULL);
3500     av_opt_show(avformat_opts, NULL);
3501     av_opt_show(sws_opts, NULL);
3502 }
3503
3504 static void opt_show_help(void)
3505 {
3506     show_help();
3507     exit(0);
3508 }
3509
3510 static void opt_target(const char *arg)
3511 {
3512     int norm = -1;
3513     static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3514
3515     if(!strncmp(arg, "pal-", 4)) {
3516         norm = 0;
3517         arg += 4;
3518     } else if(!strncmp(arg, "ntsc-", 5)) {
3519         norm = 1;
3520         arg += 5;
3521     } else if(!strncmp(arg, "film-", 5)) {
3522         norm = 2;
3523         arg += 5;
3524     } else {
3525         int fr;
3526         /* Calculate FR via float to avoid int overflow */
3527         fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3528         if(fr == 25000) {
3529             norm = 0;
3530         } else if((fr == 29970) || (fr == 23976)) {
3531             norm = 1;
3532         } else {
3533             /* Try to determine PAL/NTSC by peeking in the input files */
3534             if(nb_input_files) {
3535                 int i, j;
3536                 for(j = 0; j < nb_input_files; j++) {
3537                     for(i = 0; i < input_files[j]->nb_streams; i++) {
3538                         AVCodecContext *c = input_files[j]->streams[i]->codec;
3539                         if(c->codec_type != CODEC_TYPE_VIDEO)
3540                             continue;
3541                         fr = c->time_base.den * 1000 / c->time_base.num;
3542                         if(fr == 25000) {
3543                             norm = 0;
3544                             break;
3545                         } else if((fr == 29970) || (fr == 23976)) {
3546                             norm = 1;
3547                             break;
3548                         }
3549                     }
3550                     if(norm >= 0)
3551                         break;
3552                 }
3553             }
3554         }
3555         if(verbose && norm >= 0)
3556             fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3557     }
3558
3559     if(norm < 0) {
3560         fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3561         fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3562         fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3563         exit(1);
3564     }
3565
3566     if(!strcmp(arg, "vcd")) {
3567
3568         opt_video_codec("mpeg1video");
3569         opt_audio_codec("mp2");
3570         opt_format("vcd");
3571
3572         opt_frame_size(norm ? "352x240" : "352x288");
3573         opt_frame_rate(frame_rates[norm]);
3574         opt_default("gop", norm ? "18" : "15");
3575
3576         opt_default("b", "1150000");
3577         opt_default("maxrate", "1150000");
3578         opt_default("minrate", "1150000");
3579         opt_default("bufsize", "327680"); // 40*1024*8;
3580
3581         opt_default("ab", "224000");
3582         audio_sample_rate = 44100;
3583         audio_channels = 2;
3584
3585         opt_default("packetsize", "2324");
3586         opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3587
3588         /* We have to offset the PTS, so that it is consistent with the SCR.
3589            SCR starts at 36000, but the first two packs contain only padding
3590            and the first pack from the other stream, respectively, may also have
3591            been written before.
3592            So the real data starts at SCR 36000+3*1200. */
3593         mux_preload= (36000+3*1200) / 90000.0; //0.44
3594     } else if(!strcmp(arg, "svcd")) {
3595
3596         opt_video_codec("mpeg2video");
3597         opt_audio_codec("mp2");
3598         opt_format("svcd");
3599
3600         opt_frame_size(norm ? "480x480" : "480x576");
3601         opt_frame_rate(frame_rates[norm]);
3602         opt_default("gop", norm ? "18" : "15");
3603
3604         opt_default("b", "2040000");
3605         opt_default("maxrate", "2516000");
3606         opt_default("minrate", "0"); //1145000;
3607         opt_default("bufsize", "1835008"); //224*1024*8;
3608         opt_default("flags", "+SCAN_OFFSET");
3609
3610
3611         opt_default("ab", "224000");
3612         audio_sample_rate = 44100;
3613
3614         opt_default("packetsize", "2324");
3615
3616     } else if(!strcmp(arg, "dvd")) {
3617
3618         opt_video_codec("mpeg2video");
3619         opt_audio_codec("ac3");
3620         opt_format("dvd");
3621
3622         opt_frame_size(norm ? "720x480" : "720x576");
3623         opt_frame_rate(frame_rates[norm]);
3624         opt_default("gop", norm ? "18" : "15");
3625
3626         opt_default("b", "6000000");
3627         opt_default("maxrate", "9000000");
3628         opt_default("minrate", "0"); //1500000;
3629         opt_default("bufsize", "1835008"); //224*1024*8;
3630
3631         opt_default("packetsize", "2048");  // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3632         opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3633
3634         opt_default("ab", "448000");
3635         audio_sample_rate = 48000;
3636
3637     } else if(!strncmp(arg, "dv", 2)) {
3638
3639         opt_format("dv");
3640
3641         opt_frame_size(norm ? "720x480" : "720x576");
3642         opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3643                                              (norm ? "yuv411p" : "yuv420p"));
3644         opt_frame_rate(frame_rates[norm]);
3645
3646         audio_sample_rate = 48000;
3647         audio_channels = 2;
3648
3649     } else {
3650         fprintf(stderr, "Unknown target: %s\n", arg);
3651         exit(1);
3652     }
3653 }
3654
3655 static void opt_vstats_file (const char *arg)
3656 {
3657     av_free (vstats_filename);
3658     vstats_filename=av_strdup (arg);
3659 }
3660
3661 static void opt_vstats (void)
3662 {
3663     char filename[40];
3664     time_t today2 = time(NULL);
3665     struct tm *today = localtime(&today2);
3666
3667     snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3668              today->tm_sec);
3669     opt_vstats_file(filename);
3670 }
3671
3672 static void opt_bsf(const char *opt, const char *arg)
3673 {
3674     AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3675     AVBitStreamFilterContext **bsfp;
3676
3677     if(!bsfc){
3678         fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3679         exit(1);
3680     }
3681
3682     bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3683     while(*bsfp)
3684         bsfp= &(*bsfp)->next;
3685
3686     *bsfp= bsfc;
3687 }
3688
3689 static void opt_show_license(void)
3690 {
3691     show_license();
3692     exit(0);
3693 }
3694
3695 static void opt_show_version(void)
3696 {
3697     show_version(program_name);
3698     exit(0);
3699 }
3700
3701 const OptionDef options[] = {
3702     /* main options */
3703     { "L", 0, {(void*)opt_show_license}, "show license" },
3704     { "h", 0, {(void*)opt_show_help}, "show help" },
3705     { "version", 0, {(void*)opt_show_version}, "show version" },
3706     { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3707     { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3708     { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3709     { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3710     { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3711     { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3712     { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3713     { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3714     { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3715     { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3716     { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3717     { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3718     { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3719     { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3720     { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3721     { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3722     { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3723       "add timings for benchmarking" },
3724     { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3725       "dump each input packet" },
3726     { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3727       "when dumping packets, also dump the payload" },
3728     { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3729     { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3730     { "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)", "" },
3731     { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3732     { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3733     { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3734     { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3735     { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3736     { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3737     { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3738     { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3739     { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3740     { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3741     { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3742
3743     /* video options */
3744     { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3745     { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3746     { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3747     { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3748     { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3749     { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3750     { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3751     { "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" },
3752     { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3753     { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3754     { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3755     { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3756     { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3757     { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3758     { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3759     { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3760     { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3761     { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3762     { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3763     { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3764     { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3765     { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3766     { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3767     { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3768     { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold",  "" },
3769     { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3770     { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3771       "use same video quality as source (implies VBR)" },
3772     { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3773     { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3774     { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3775       "deinterlace pictures" },
3776     { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3777     { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3778     { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3779 #ifdef CONFIG_VHOOK
3780     { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3781 #endif
3782     { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3783     { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3784     { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3785     { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3786     { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3787     { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3788     { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3789
3790     /* audio options */
3791     { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3792     { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3793     { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3794     { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3795     { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3796     { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3797     { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3798     { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3799     { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3800     { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3801     { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3802
3803     /* subtitle options */
3804     { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3805     { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3806     { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3807     { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3808
3809     /* grab options */
3810     { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3811     { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3812     { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3813
3814     /* muxer options */
3815     { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3816     { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3817
3818     { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3819     { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3820
3821     { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3822     { NULL, },
3823 };
3824
3825 static int av_exit()
3826 {
3827     int i;
3828
3829     /* close files */
3830     for(i=0;i<nb_output_files;i++) {
3831         /* maybe av_close_output_file ??? */
3832         AVFormatContext *s = output_files[i];
3833         int j;
3834         if (!(s->oformat->flags & AVFMT_NOFILE))
3835             url_fclose(s->pb);
3836         for(j=0;j<s->nb_streams;j++) {
3837             av_free(s->streams[j]->codec);
3838             av_free(s->streams[j]);
3839         }
3840         av_free(s);
3841     }
3842     for(i=0;i<nb_input_files;i++)
3843         av_close_input_file(input_files[i]);
3844
3845     av_free_static();
3846
3847     av_free(intra_matrix);
3848     av_free(inter_matrix);
3849
3850     if (vstats_file)
3851         fclose(vstats_file);
3852     av_free(vstats_filename);
3853
3854     av_free(opt_names);
3855
3856     av_free(video_codec_name);
3857     av_free(audio_codec_name);
3858     av_free(subtitle_codec_name);
3859
3860     av_free(video_standard);
3861
3862 #ifdef CONFIG_POWERPC_PERF
3863     extern void powerpc_display_perf_report(void);
3864     powerpc_display_perf_report();
3865 #endif /* CONFIG_POWERPC_PERF */
3866
3867     if (received_sigterm) {
3868         fprintf(stderr,
3869             "Received signal %d: terminating.\n",
3870             (int) received_sigterm);
3871         exit (255);
3872     }
3873
3874     exit(0); /* not all OS-es handle main() return value */
3875     return 0;
3876 }
3877
3878 int main(int argc, char **argv)
3879 {
3880     int i;
3881     int64_t ti;
3882
3883     avcodec_register_all();
3884     avdevice_register_all();
3885     av_register_all();
3886
3887     for(i=0; i<CODEC_TYPE_NB; i++){
3888         avctx_opts[i]= avcodec_alloc_context2(i);
3889     }
3890     avformat_opts = av_alloc_format_context();
3891     sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3892
3893     show_banner(program_name, program_birth_year);
3894     if (argc <= 1) {
3895         show_help();
3896         exit(1);
3897     }
3898
3899     /* parse options */
3900     parse_options(argc, argv, options, opt_output_file);
3901
3902     /* file converter / grab */
3903     if (nb_output_files <= 0) {
3904         fprintf(stderr, "Must supply at least one output file\n");
3905         exit(1);
3906     }
3907
3908     if (nb_input_files == 0) {
3909         fprintf(stderr, "Must supply at least one input file\n");
3910         exit(1);
3911     }
3912
3913     ti = getutime();
3914     av_encode(output_files, nb_output_files, input_files, nb_input_files,
3915               stream_maps, nb_stream_maps);
3916     ti = getutime() - ti;
3917     if (do_benchmark) {
3918         printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3919     }
3920
3921     return av_exit();
3922 }