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