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