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