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