Split CLEANFILES variable into CLEANSUFFIXES and LIBSUFFIXES.
[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 #undef exit
63
64 static const char program_name[] = "FFmpeg";
65 static const int program_birth_year = 2000;
66
67 /* select an input stream for an output stream */
68 typedef struct AVStreamMap {
69     int file_index;
70     int stream_index;
71     int sync_file_index;
72     int sync_stream_index;
73 } AVStreamMap;
74
75 /** select an input file for an output file */
76 typedef struct AVMetaDataMap {
77     int out_file;
78     int in_file;
79 } AVMetaDataMap;
80
81 extern const OptionDef options[];
82
83 #define MAX_FILES 20
84
85 static AVFormatContext *input_files[MAX_FILES];
86 static int64_t input_files_ts_offset[MAX_FILES];
87 static int nb_input_files = 0;
88
89 static AVFormatContext *output_files[MAX_FILES];
90 static int nb_output_files = 0;
91
92 static AVStreamMap stream_maps[MAX_FILES];
93 static int nb_stream_maps;
94
95 static AVMetaDataMap meta_data_maps[MAX_FILES];
96 static int nb_meta_data_maps;
97
98 static AVInputFormat *file_iformat;
99 static AVOutputFormat *file_oformat;
100 static int frame_width  = 0;
101 static int frame_height = 0;
102 static float frame_aspect_ratio = 0;
103 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
104 static int frame_padtop  = 0;
105 static int frame_padbottom = 0;
106 static int frame_padleft  = 0;
107 static int frame_padright = 0;
108 static int padcolor[3] = {16,128,128}; /* default to black */
109 static int frame_topBand  = 0;
110 static int frame_bottomBand = 0;
111 static int frame_leftBand  = 0;
112 static int frame_rightBand = 0;
113 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
114 static AVRational frame_rate = (AVRational) {0,0};
115 static float video_qscale = 0;
116 static int video_qdiff = 3;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
123 #endif
124 static const char *video_rc_override_string=NULL;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static char *video_codec_name = NULL;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
138
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static char  *audio_codec_name = NULL;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
148
149 static int subtitle_disable = 0;
150 static char *subtitle_codec_name = NULL;
151 static char *subtitle_language = NULL;
152
153 static float mux_preload= 0.5;
154 static float mux_max_delay= 0.7;
155
156 static int64_t recording_time = 0;
157 static int64_t start_time = 0;
158 static int64_t rec_timestamp = 0;
159 static int64_t input_ts_offset = 0;
160 static int file_overwrite = 0;
161 static char *str_title = NULL;
162 static char *str_author = NULL;
163 static char *str_copyright = NULL;
164 static char *str_comment = NULL;
165 static char *str_genre = NULL;
166 static char *str_album = NULL;
167 static int do_benchmark = 0;
168 static int do_hex_dump = 0;
169 static int do_pkt_dump = 0;
170 static int do_psnr = 0;
171 static int do_pass = 0;
172 static char *pass_logfilename = NULL;
173 static int audio_stream_copy = 0;
174 static int video_stream_copy = 0;
175 static int subtitle_stream_copy = 0;
176 static int video_sync_method= 1;
177 static int audio_sync_method= 0;
178 static float audio_drift_threshold= 0.1;
179 static int copy_ts= 0;
180 static int opt_shortest = 0; //
181 static int video_global_header = 0;
182 static char *vstats_filename;
183 static FILE *vstats_file;
184 static int opt_programid = 0;
185
186 static int rate_emu = 0;
187
188 static int  video_channel = 0;
189 static char *video_standard;
190
191 static int audio_volume = 256;
192
193 static int using_stdin = 0;
194 static int using_vhook = 0;
195 static int verbose = 1;
196 static int thread_count= 1;
197 static int q_pressed = 0;
198 static int64_t video_size = 0;
199 static int64_t audio_size = 0;
200 static int64_t extra_size = 0;
201 static int nb_frames_dup = 0;
202 static int nb_frames_drop = 0;
203 static int input_sync;
204 static uint64_t limit_filesize = 0; //
205
206 static int pgmyuv_compatibility_hack=0;
207 static float dts_delta_threshold = 10;
208
209 static unsigned int sws_flags = SWS_BICUBIC;
210
211 static const char **opt_names;
212 static int opt_name_count;
213 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
214 static AVFormatContext *avformat_opts;
215 static struct SwsContext *sws_opts;
216 static int64_t timer_start;
217
218 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
219 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
220 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
222
223 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
224
225 struct AVInputStream;
226
227 typedef struct AVOutputStream {
228     int file_index;          /* file index */
229     int index;               /* stream index in the output file */
230     int source_index;        /* AVInputStream index */
231     AVStream *st;            /* stream in the output file */
232     int encoding_needed;     /* true if encoding needed for this stream */
233     int frame_number;
234     /* input pts and corresponding output pts
235        for A/V sync */
236     //double sync_ipts;        /* dts from the AVPacket of the demuxer in second units */
237     struct AVInputStream *sync_ist; /* input stream to sync against */
238     int64_t sync_opts;       /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
239     /* video only */
240     int video_resample;
241     AVFrame pict_tmp;      /* temporary image for resampling */
242     struct SwsContext *img_resample_ctx; /* for image resampling */
243     int resample_height;
244
245     int video_crop;
246     int topBand;             /* cropping area sizes */
247     int leftBand;
248
249     int video_pad;
250     int padtop;              /* padding area sizes */
251     int padbottom;
252     int padleft;
253     int padright;
254
255     /* audio only */
256     int audio_resample;
257     ReSampleContext *resample; /* for audio resampling */
258     AVFifoBuffer fifo;     /* for compression: one audio fifo per codec */
259     FILE *logfile;
260 } AVOutputStream;
261
262 typedef struct AVInputStream {
263     int file_index;
264     int index;
265     AVStream *st;
266     int discard;             /* true if stream data should be discarded */
267     int decoding_needed;     /* true if the packets must be decoded in 'raw_fifo' */
268     int64_t sample_index;      /* current sample */
269
270     int64_t       start;     /* time when read started */
271     unsigned long frame;     /* current frame */
272     int64_t       next_pts;  /* synthetic pts for cases where pkt.pts
273                                 is not defined */
274     int64_t       pts;       /* current pts */
275     int is_start;            /* is 1 at the start and after a discontinuity */
276 } AVInputStream;
277
278 typedef struct AVInputFile {
279     int eof_reached;      /* true if eof reached */
280     int ist_index;        /* index of first stream in ist_table */
281     int buffer_size;      /* current total buffer size */
282     int nb_streams;       /* nb streams we are aware of */
283 } AVInputFile;
284
285 #ifdef HAVE_TERMIOS_H
286
287 /* init terminal so that we can grab keys */
288 static struct termios oldtty;
289 #endif
290
291 static void term_exit(void)
292 {
293 #ifdef HAVE_TERMIOS_H
294     tcsetattr (0, TCSANOW, &oldtty);
295 #endif
296 }
297
298 static volatile sig_atomic_t received_sigterm = 0;
299
300 static void
301 sigterm_handler(int sig)
302 {
303     received_sigterm = sig;
304     term_exit();
305 }
306
307 static void term_init(void)
308 {
309 #ifdef HAVE_TERMIOS_H
310     struct termios tty;
311
312     tcgetattr (0, &tty);
313     oldtty = tty;
314
315     tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
316                           |INLCR|IGNCR|ICRNL|IXON);
317     tty.c_oflag |= OPOST;
318     tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
319     tty.c_cflag &= ~(CSIZE|PARENB);
320     tty.c_cflag |= CS8;
321     tty.c_cc[VMIN] = 1;
322     tty.c_cc[VTIME] = 0;
323
324     tcsetattr (0, TCSANOW, &tty);
325     signal(SIGQUIT, sigterm_handler); /* Quit (POSIX).  */
326 #endif
327
328     signal(SIGINT , sigterm_handler); /* Interrupt (ANSI).  */
329     signal(SIGTERM, sigterm_handler); /* Termination (ANSI).  */
330     /*
331     register a function to be called at normal program termination
332     */
333     atexit(term_exit);
334 #ifdef CONFIG_BEOS_NETSERVER
335     fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
336 #endif
337 }
338
339 /* read a key without blocking */
340 static int read_key(void)
341 {
342 #if defined(HAVE_TERMIOS_H)
343     int n = 1;
344     unsigned char ch;
345 #ifndef CONFIG_BEOS_NETSERVER
346     struct timeval tv;
347     fd_set rfds;
348
349     FD_ZERO(&rfds);
350     FD_SET(0, &rfds);
351     tv.tv_sec = 0;
352     tv.tv_usec = 0;
353     n = select(1, &rfds, NULL, NULL, &tv);
354 #endif
355     if (n > 0) {
356         n = read(0, &ch, 1);
357         if (n == 1)
358             return ch;
359
360         return n;
361     }
362 #elif defined(HAVE_CONIO_H)
363     if(kbhit())
364         return(getch());
365 #endif
366     return -1;
367 }
368
369 static int decode_interrupt_cb(void)
370 {
371     return q_pressed || (q_pressed = read_key() == 'q');
372 }
373
374 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
375 {
376     int i, err;
377     AVFormatContext *ic;
378
379     err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
380     if (err < 0)
381         return err;
382     /* copy stream format */
383     s->nb_streams = ic->nb_streams;
384     for(i=0;i<ic->nb_streams;i++) {
385         AVStream *st;
386
387         // FIXME: a more elegant solution is needed
388         st = av_mallocz(sizeof(AVStream));
389         memcpy(st, ic->streams[i], sizeof(AVStream));
390         st->codec = avcodec_alloc_context();
391         memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
392         s->streams[i] = st;
393     }
394
395     av_close_input_file(ic);
396     return 0;
397 }
398
399 static double
400 get_sync_ipts(const AVOutputStream *ost)
401 {
402     const AVInputStream *ist = ost->sync_ist;
403     return (double)(ist->pts - start_time)/AV_TIME_BASE;
404 }
405
406 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
407     int ret;
408
409     while(bsfc){
410         AVPacket new_pkt= *pkt;
411         int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
412                                           &new_pkt.data, &new_pkt.size,
413                                           pkt->data, pkt->size,
414                                           pkt->flags & PKT_FLAG_KEY);
415         if(a>0){
416             av_free_packet(pkt);
417             new_pkt.destruct= av_destruct_packet;
418         } else if(a<0){
419             fprintf(stderr, "%s failed for stream %d, codec %s",
420                     bsfc->filter->name, pkt->stream_index,
421                     avctx->codec ? avctx->codec->name : "copy");
422             print_error("", a);
423         }
424         *pkt= new_pkt;
425
426         bsfc= bsfc->next;
427     }
428
429     ret= av_interleaved_write_frame(s, pkt);
430     if(ret < 0){
431         print_error("av_interleaved_write_frame()", ret);
432         exit(1);
433     }
434 }
435
436 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
437
438 static void do_audio_out(AVFormatContext *s,
439                          AVOutputStream *ost,
440                          AVInputStream *ist,
441                          unsigned char *buf, int size)
442 {
443     uint8_t *buftmp;
444     static uint8_t *audio_buf = NULL;
445     static uint8_t *audio_out = NULL;
446     const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
447
448     int size_out, frame_bytes, ret;
449     AVCodecContext *enc= ost->st->codec;
450     AVCodecContext *dec= ist->st->codec;
451
452     /* SC: dynamic allocation of buffers */
453     if (!audio_buf)
454         audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
455     if (!audio_out)
456         audio_out = av_malloc(audio_out_size);
457     if (!audio_buf || !audio_out)
458         return;               /* Should signal an error ! */
459
460     if (enc->channels != dec->channels)
461         ost->audio_resample = 1;
462
463     if (ost->audio_resample && !ost->resample) {
464         ost->resample = audio_resample_init(enc->channels,    dec->channels,
465                                             enc->sample_rate, dec->sample_rate);
466         if (!ost->resample) {
467             fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
468                     dec->channels, dec->sample_rate,
469                     enc->channels, enc->sample_rate);
470             exit(1);
471         }
472     }
473
474     if(audio_sync_method){
475         double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
476                 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
477         double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
478         int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
479
480         //FIXME resample delay
481         if(fabs(delta) > 50){
482             if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
483                 if(byte_delta < 0){
484                     byte_delta= FFMAX(byte_delta, -size);
485                     size += byte_delta;
486                     buf  -= byte_delta;
487                     if(verbose > 2)
488                         fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
489                     if(!size)
490                         return;
491                     ist->is_start=0;
492                 }else{
493                     static uint8_t *input_tmp= NULL;
494                     input_tmp= av_realloc(input_tmp, byte_delta + size);
495
496                     if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
497                         ist->is_start=0;
498                     else
499                         byte_delta= MAX_AUDIO_PACKET_SIZE - size;
500
501                     memset(input_tmp, 0, byte_delta);
502                     memcpy(input_tmp + byte_delta, buf, size);
503                     buf= input_tmp;
504                     size += byte_delta;
505                     if(verbose > 2)
506                         fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
507                 }
508             }else if(audio_sync_method>1){
509                 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
510                 assert(ost->audio_resample);
511                 if(verbose > 2)
512                     fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
513 //                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));
514                 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
515             }
516         }
517     }else
518         ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
519                         - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
520
521     if (ost->audio_resample) {
522         buftmp = audio_buf;
523         size_out = audio_resample(ost->resample,
524                                   (short *)buftmp, (short *)buf,
525                                   size / (ist->st->codec->channels * 2));
526         size_out = size_out * enc->channels * 2;
527     } else {
528         buftmp = buf;
529         size_out = size;
530     }
531
532     /* now encode as many frames as possible */
533     if (enc->frame_size > 1) {
534         /* output resampled raw samples */
535         av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1);
536         av_fifo_write(&ost->fifo, buftmp, size_out);
537
538         frame_bytes = enc->frame_size * 2 * enc->channels;
539
540         while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
541             AVPacket pkt;
542             av_init_packet(&pkt);
543
544             //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
545
546             ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
547                                        (short *)audio_buf);
548             audio_size += ret;
549             pkt.stream_index= ost->index;
550             pkt.data= audio_out;
551             pkt.size= ret;
552             if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
553                 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
554             pkt.flags |= PKT_FLAG_KEY;
555             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
556
557             ost->sync_opts += enc->frame_size;
558         }
559     } else {
560         AVPacket pkt;
561         av_init_packet(&pkt);
562
563         ost->sync_opts += size_out / (2 * enc->channels);
564
565         /* output a pcm frame */
566         /* XXX: change encoding codec API to avoid this ? */
567         switch(enc->codec->id) {
568         case CODEC_ID_PCM_S32LE:
569         case CODEC_ID_PCM_S32BE:
570         case CODEC_ID_PCM_U32LE:
571         case CODEC_ID_PCM_U32BE:
572             size_out = size_out << 1;
573             break;
574         case CODEC_ID_PCM_S24LE:
575         case CODEC_ID_PCM_S24BE:
576         case CODEC_ID_PCM_U24LE:
577         case CODEC_ID_PCM_U24BE:
578         case CODEC_ID_PCM_S24DAUD:
579             size_out = size_out / 2 * 3;
580             break;
581         case CODEC_ID_PCM_S16LE:
582         case CODEC_ID_PCM_S16BE:
583         case CODEC_ID_PCM_U16LE:
584         case CODEC_ID_PCM_U16BE:
585             break;
586         default:
587             size_out = size_out >> 1;
588             break;
589         }
590         //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
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 (video_sync_method == 2)
737             ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
738         else if (vdelta > 1.1)
739             nb_frames = lrintf(vdelta);
740 //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);
741         if (nb_frames == 0){
742             ++nb_frames_drop;
743             if (verbose>2)
744                 fprintf(stderr, "*** drop!\n");
745         }else if (nb_frames > 1) {
746             nb_frames_dup += nb_frames;
747             if (verbose>2)
748                 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
749         }
750     }else
751         ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
752
753     nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
754     if (nb_frames <= 0)
755         return;
756
757     if (ost->video_crop) {
758         if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
759             av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
760             return;
761         }
762         formatted_picture = &picture_crop_temp;
763     } else {
764         formatted_picture = in_picture;
765     }
766
767     final_picture = formatted_picture;
768     padding_src = formatted_picture;
769     resampling_dst = &ost->pict_tmp;
770     if (ost->video_pad) {
771         final_picture = &ost->pict_tmp;
772         if (ost->video_resample) {
773             if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
774                 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
775                 return;
776             }
777             resampling_dst = &picture_pad_temp;
778         }
779     }
780
781     if (ost->video_resample) {
782         padding_src = NULL;
783         final_picture = &ost->pict_tmp;
784         sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
785               0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
786     }
787
788     if (ost->video_pad) {
789         av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
790                 enc->height, enc->width, enc->pix_fmt,
791                 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
792     }
793
794     /* duplicates frame if needed */
795     for(i=0;i<nb_frames;i++) {
796         AVPacket pkt;
797         av_init_packet(&pkt);
798         pkt.stream_index= ost->index;
799
800         if (s->oformat->flags & AVFMT_RAWPICTURE) {
801             /* raw pictures are written as AVPicture structure to
802                avoid any copies. We support temorarily the older
803                method. */
804             AVFrame* old_frame = enc->coded_frame;
805             enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
806             pkt.data= (uint8_t *)final_picture;
807             pkt.size=  sizeof(AVPicture);
808             pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
809             pkt.flags |= PKT_FLAG_KEY;
810
811             write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
812             enc->coded_frame = old_frame;
813         } else {
814             AVFrame big_picture;
815
816             big_picture= *final_picture;
817             /* better than nothing: use input picture interlaced
818                settings */
819             big_picture.interlaced_frame = in_picture->interlaced_frame;
820             if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
821                 if(top_field_first == -1)
822                     big_picture.top_field_first = in_picture->top_field_first;
823                 else
824                     big_picture.top_field_first = top_field_first;
825             }
826
827             /* handles sameq here. This is not correct because it may
828                not be a global option */
829             if (same_quality) {
830                 big_picture.quality = ist->st->quality;
831             }else
832                 big_picture.quality = ost->st->quality;
833             if(!me_threshold)
834                 big_picture.pict_type = 0;
835 //            big_picture.pts = AV_NOPTS_VALUE;
836             big_picture.pts= ost->sync_opts;
837 //            big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
838 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
839             ret = avcodec_encode_video(enc,
840                                        bit_buffer, bit_buffer_size,
841                                        &big_picture);
842             if (ret == -1) {
843                 fprintf(stderr, "Video encoding failed\n");
844                 exit(1);
845             }
846             //enc->frame_number = enc->real_pict_num;
847             if(ret>0){
848                 pkt.data= bit_buffer;
849                 pkt.size= ret;
850                 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
851                     pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
852 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
853    pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
854    pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
855
856                 if(enc->coded_frame && enc->coded_frame->key_frame)
857                     pkt.flags |= PKT_FLAG_KEY;
858                 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
859                 *frame_size = ret;
860                 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
861                 //        enc->frame_number-1, enc->real_pict_num, ret,
862                 //        enc->pict_type);
863                 /* if two pass, output log */
864                 if (ost->logfile && enc->stats_out) {
865                     fprintf(ost->logfile, "%s", enc->stats_out);
866                 }
867             }
868         }
869         ost->sync_opts++;
870         ost->frame_number++;
871     }
872 }
873
874 static double psnr(double d){
875     return -10.0*log(d)/log(10.0);
876 }
877
878 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
879                            int frame_size)
880 {
881     AVCodecContext *enc;
882     int frame_number;
883     double ti1, bitrate, avg_bitrate;
884
885     /* this is executed just the first time do_video_stats is called */
886     if (!vstats_file) {
887         vstats_file = fopen(vstats_filename, "w");
888         if (!vstats_file) {
889             perror("fopen");
890             exit(1);
891         }
892     }
893
894     enc = ost->st->codec;
895     if (enc->codec_type == CODEC_TYPE_VIDEO) {
896         frame_number = ost->frame_number;
897         fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
898         if (enc->flags&CODEC_FLAG_PSNR)
899             fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
900
901         fprintf(vstats_file,"f_size= %6d ", frame_size);
902         /* compute pts value */
903         ti1 = ost->sync_opts * av_q2d(enc->time_base);
904         if (ti1 < 0.01)
905             ti1 = 0.01;
906
907         bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
908         avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
909         fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
910             (double)video_size / 1024, ti1, bitrate, avg_bitrate);
911         fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
912     }
913 }
914
915 static void print_report(AVFormatContext **output_files,
916                          AVOutputStream **ost_table, int nb_ostreams,
917                          int is_last_report)
918 {
919     char buf[1024];
920     AVOutputStream *ost;
921     AVFormatContext *oc, *os;
922     int64_t total_size;
923     AVCodecContext *enc;
924     int frame_number, vid, i;
925     double bitrate, ti1, pts;
926     static int64_t last_time = -1;
927     static int qp_histogram[52];
928
929     if (!is_last_report) {
930         int64_t cur_time;
931         /* display the report every 0.5 seconds */
932         cur_time = av_gettime();
933         if (last_time == -1) {
934             last_time = cur_time;
935             return;
936         }
937         if ((cur_time - last_time) < 500000)
938             return;
939         last_time = cur_time;
940     }
941
942
943     oc = output_files[0];
944
945     total_size = url_fsize(oc->pb);
946     if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
947         total_size= url_ftell(oc->pb);
948
949     buf[0] = '\0';
950     ti1 = 1e10;
951     vid = 0;
952     for(i=0;i<nb_ostreams;i++) {
953         ost = ost_table[i];
954         os = output_files[ost->file_index];
955         enc = ost->st->codec;
956         if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
958                      enc->coded_frame && !ost->st->stream_copy ?
959                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
960         }
961         if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
962             float t = (av_gettime()-timer_start) / 1000000.0;
963
964             frame_number = ost->frame_number;
965             snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
966                      frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
967                      enc->coded_frame && !ost->st->stream_copy ?
968                      enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
969             if(is_last_report)
970                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
971             if(qp_hist && enc->coded_frame){
972                 int j;
973                 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
974                 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
975                     qp_histogram[qp]++;
976                 for(j=0; j<32; j++)
977                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
978             }
979             if (enc->flags&CODEC_FLAG_PSNR){
980                 int j;
981                 double error, error_sum=0;
982                 double scale, scale_sum=0;
983                 char type[3]= {'Y','U','V'};
984                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
985                 for(j=0; j<3; j++){
986                     if(is_last_report){
987                         error= enc->error[j];
988                         scale= enc->width*enc->height*255.0*255.0*frame_number;
989                     }else{
990                         error= enc->coded_frame->error[j];
991                         scale= enc->width*enc->height*255.0*255.0;
992                     }
993                     if(j) scale/=4;
994                     error_sum += error;
995                     scale_sum += scale;
996                     snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
997                 }
998                 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
999             }
1000             vid = 1;
1001         }
1002         /* compute min output value */
1003         pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1004         if ((pts < ti1) && (pts > 0))
1005             ti1 = pts;
1006     }
1007     if (ti1 < 0.01)
1008         ti1 = 0.01;
1009
1010     if (verbose || is_last_report) {
1011         bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1012
1013         snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1014             "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1015             (double)total_size / 1024, ti1, bitrate);
1016
1017         if (verbose > 1)
1018           snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1019                   nb_frames_dup, nb_frames_drop);
1020
1021         if (verbose >= 0)
1022             fprintf(stderr, "%s    \r", buf);
1023
1024         fflush(stderr);
1025     }
1026
1027     if (is_last_report && verbose >= 0){
1028         int64_t raw= audio_size + video_size + extra_size;
1029         fprintf(stderr, "\n");
1030         fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1031                 video_size/1024.0,
1032                 audio_size/1024.0,
1033                 extra_size/1024.0,
1034                 100.0*(total_size - raw)/raw
1035         );
1036     }
1037 }
1038
1039 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1040 static int output_packet(AVInputStream *ist, int ist_index,
1041                          AVOutputStream **ost_table, int nb_ostreams,
1042                          const AVPacket *pkt)
1043 {
1044     AVFormatContext *os;
1045     AVOutputStream *ost;
1046     uint8_t *ptr;
1047     int len, ret, i;
1048     uint8_t *data_buf;
1049     int data_size, got_picture;
1050     AVFrame picture;
1051     void *buffer_to_free;
1052     static unsigned int samples_size= 0;
1053     static short *samples= NULL;
1054     AVSubtitle subtitle, *subtitle_to_free;
1055     int got_subtitle;
1056
1057     if(ist->next_pts == AV_NOPTS_VALUE)
1058         ist->next_pts= ist->pts;
1059
1060     if (pkt == NULL) {
1061         /* EOF handling */
1062         ptr = NULL;
1063         len = 0;
1064         goto handle_eof;
1065     }
1066
1067     if(pkt->dts != AV_NOPTS_VALUE)
1068         ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1069
1070     len = pkt->size;
1071     ptr = pkt->data;
1072     while (len > 0) {
1073     handle_eof:
1074         ist->pts= ist->next_pts;
1075
1076         if(len && len != pkt->size && verbose>0)
1077             fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1078
1079         /* decode the packet if needed */
1080         data_buf = NULL; /* fail safe */
1081         data_size = 0;
1082         subtitle_to_free = NULL;
1083         if (ist->decoding_needed) {
1084             switch(ist->st->codec->codec_type) {
1085             case CODEC_TYPE_AUDIO:{
1086                 if(pkt)
1087                     samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1088                 data_size= samples_size;
1089                     /* XXX: could avoid copy if PCM 16 bits with same
1090                        endianness as CPU */
1091                 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1092                                            ptr, len);
1093                 if (ret < 0)
1094                     goto fail_decode;
1095                 ptr += ret;
1096                 len -= ret;
1097                 /* Some bug in mpeg audio decoder gives */
1098                 /* data_size < 0, it seems they are overflows */
1099                 if (data_size <= 0) {
1100                     /* no audio frame */
1101                     continue;
1102                 }
1103                 data_buf = (uint8_t *)samples;
1104                 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1105                     (ist->st->codec->sample_rate * ist->st->codec->channels);
1106                 break;}
1107             case CODEC_TYPE_VIDEO:
1108                     data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1109                     /* XXX: allocate picture correctly */
1110                     avcodec_get_frame_defaults(&picture);
1111
1112                     ret = avcodec_decode_video(ist->st->codec,
1113                                                &picture, &got_picture, ptr, len);
1114                     ist->st->quality= picture.quality;
1115                     if (ret < 0)
1116                         goto fail_decode;
1117                     if (!got_picture) {
1118                         /* no picture yet */
1119                         goto discard_packet;
1120                     }
1121                     if (ist->st->codec->time_base.num != 0) {
1122                         ist->next_pts += ((int64_t)AV_TIME_BASE *
1123                                           ist->st->codec->time_base.num) /
1124                             ist->st->codec->time_base.den;
1125                     }
1126                     len = 0;
1127                     break;
1128             case CODEC_TYPE_SUBTITLE:
1129                 ret = avcodec_decode_subtitle(ist->st->codec,
1130                                               &subtitle, &got_subtitle, ptr, len);
1131                 if (ret < 0)
1132                     goto fail_decode;
1133                 if (!got_subtitle) {
1134                     goto discard_packet;
1135                 }
1136                 subtitle_to_free = &subtitle;
1137                 len = 0;
1138                 break;
1139             default:
1140                 goto fail_decode;
1141             }
1142         } else {
1143             switch(ist->st->codec->codec_type) {
1144             case CODEC_TYPE_AUDIO:
1145                 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1146                     ist->st->codec->sample_rate;
1147                 break;
1148             case CODEC_TYPE_VIDEO:
1149                 if (ist->st->codec->time_base.num != 0) {
1150                     ist->next_pts += ((int64_t)AV_TIME_BASE *
1151                                       ist->st->codec->time_base.num) /
1152                         ist->st->codec->time_base.den;
1153                 }
1154                 break;
1155             }
1156             data_buf = ptr;
1157             data_size = len;
1158             ret = len;
1159             len = 0;
1160         }
1161
1162         buffer_to_free = NULL;
1163         if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1164             pre_process_video_frame(ist, (AVPicture *)&picture,
1165                                     &buffer_to_free);
1166         }
1167
1168         // preprocess audio (volume)
1169         if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1170             if (audio_volume != 256) {
1171                 short *volp;
1172                 volp = samples;
1173                 for(i=0;i<(data_size / sizeof(short));i++) {
1174                     int v = ((*volp) * audio_volume + 128) >> 8;
1175                     if (v < -32768) v = -32768;
1176                     if (v >  32767) v = 32767;
1177                     *volp++ = v;
1178                 }
1179             }
1180         }
1181
1182         /* frame rate emulation */
1183         if (ist->st->codec->rate_emu) {
1184             int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1185             int64_t now = av_gettime() - ist->start;
1186             if (pts > now)
1187                 usleep(pts - now);
1188
1189             ist->frame++;
1190         }
1191
1192 #if 0
1193         /* mpeg PTS deordering : if it is a P or I frame, the PTS
1194            is the one of the next displayed one */
1195         /* XXX: add mpeg4 too ? */
1196         if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1197             if (ist->st->codec->pict_type != B_TYPE) {
1198                 int64_t tmp;
1199                 tmp = ist->last_ip_pts;
1200                 ist->last_ip_pts  = ist->frac_pts.val;
1201                 ist->frac_pts.val = tmp;
1202             }
1203         }
1204 #endif
1205         /* if output time reached then transcode raw format,
1206            encode packets and output them */
1207         if (start_time == 0 || ist->pts >= start_time)
1208             for(i=0;i<nb_ostreams;i++) {
1209                 int frame_size;
1210
1211                 ost = ost_table[i];
1212                 if (ost->source_index == ist_index) {
1213                     os = output_files[ost->file_index];
1214
1215 #if 0
1216                     printf("%d: got pts=%0.3f %0.3f\n", i,
1217                            (double)pkt->pts / AV_TIME_BASE,
1218                            ((double)ist->pts / AV_TIME_BASE) -
1219                            ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1220 #endif
1221                     /* set the input output pts pairs */
1222                     //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1223
1224                     if (ost->encoding_needed) {
1225                         switch(ost->st->codec->codec_type) {
1226                         case CODEC_TYPE_AUDIO:
1227                             do_audio_out(os, ost, ist, data_buf, data_size);
1228                             break;
1229                         case CODEC_TYPE_VIDEO:
1230                             do_video_out(os, ost, ist, &picture, &frame_size);
1231                             video_size += frame_size;
1232                             if (vstats_filename && frame_size)
1233                                 do_video_stats(os, ost, frame_size);
1234                             break;
1235                         case CODEC_TYPE_SUBTITLE:
1236                             do_subtitle_out(os, ost, ist, &subtitle,
1237                                             pkt->pts);
1238                             break;
1239                         default:
1240                             abort();
1241                         }
1242                     } else {
1243                         AVFrame avframe; //FIXME/XXX remove this
1244                         AVPacket opkt;
1245                         av_init_packet(&opkt);
1246
1247                         if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1248                             continue;
1249
1250                         /* no reencoding needed : output the packet directly */
1251                         /* force the input stream PTS */
1252
1253                         avcodec_get_frame_defaults(&avframe);
1254                         ost->st->codec->coded_frame= &avframe;
1255                         avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1256
1257                         if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1258                             audio_size += data_size;
1259                         else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1260                             video_size += data_size;
1261                             ost->sync_opts++;
1262                         }
1263
1264                         opkt.stream_index= ost->index;
1265                         if(pkt->pts != AV_NOPTS_VALUE)
1266                             opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1267                         else
1268                             opkt.pts= AV_NOPTS_VALUE;
1269
1270                             if (pkt->dts == AV_NOPTS_VALUE)
1271                                 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1272                             else
1273                                 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1274
1275                         opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1276                         opkt.flags= pkt->flags;
1277
1278                         //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1279                         if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1280                             opkt.destruct= av_destruct_packet;
1281
1282                         write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1283                         ost->st->codec->frame_number++;
1284                         ost->frame_number++;
1285                         av_free_packet(&opkt);
1286                     }
1287                 }
1288             }
1289         av_free(buffer_to_free);
1290         /* XXX: allocate the subtitles in the codec ? */
1291         if (subtitle_to_free) {
1292             if (subtitle_to_free->rects != NULL) {
1293                 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1294                     av_free(subtitle_to_free->rects[i].bitmap);
1295                     av_free(subtitle_to_free->rects[i].rgba_palette);
1296                 }
1297                 av_freep(&subtitle_to_free->rects);
1298             }
1299             subtitle_to_free->num_rects = 0;
1300             subtitle_to_free = NULL;
1301         }
1302     }
1303  discard_packet:
1304     if (pkt == NULL) {
1305         /* EOF handling */
1306
1307         for(i=0;i<nb_ostreams;i++) {
1308             ost = ost_table[i];
1309             if (ost->source_index == ist_index) {
1310                 AVCodecContext *enc= ost->st->codec;
1311                 os = output_files[ost->file_index];
1312
1313                 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1314                     continue;
1315                 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1316                     continue;
1317
1318                 if (ost->encoding_needed) {
1319                     for(;;) {
1320                         AVPacket pkt;
1321                         int fifo_bytes;
1322                         av_init_packet(&pkt);
1323                         pkt.stream_index= ost->index;
1324
1325                         switch(ost->st->codec->codec_type) {
1326                         case CODEC_TYPE_AUDIO:
1327                             fifo_bytes = av_fifo_size(&ost->fifo);
1328                             ret = 0;
1329                             /* encode any samples remaining in fifo */
1330                             if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1331                                 int fs_tmp = enc->frame_size;
1332                                 enc->frame_size = fifo_bytes / (2 * enc->channels);
1333                                 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1334                                     ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1335                                 }
1336                                 enc->frame_size = fs_tmp;
1337                             }
1338                             if(ret <= 0) {
1339                                 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1340                             }
1341                             audio_size += ret;
1342                             pkt.flags |= PKT_FLAG_KEY;
1343                             break;
1344                         case CODEC_TYPE_VIDEO:
1345                             ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1346                             video_size += ret;
1347                             if(enc->coded_frame && enc->coded_frame->key_frame)
1348                                 pkt.flags |= PKT_FLAG_KEY;
1349                             if (ost->logfile && enc->stats_out) {
1350                                 fprintf(ost->logfile, "%s", enc->stats_out);
1351                             }
1352                             break;
1353                         default:
1354                             ret=-1;
1355                         }
1356
1357                         if(ret<=0)
1358                             break;
1359                         pkt.data= bit_buffer;
1360                         pkt.size= ret;
1361                         if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1362                             pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1363                         write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1364                     }
1365                 }
1366             }
1367         }
1368     }
1369
1370     return 0;
1371  fail_decode:
1372     return -1;
1373 }
1374
1375 static void print_sdp(AVFormatContext **avc, int n)
1376 {
1377     char sdp[2048];
1378
1379     avf_sdp_create(avc, n, sdp, sizeof(sdp));
1380     printf("SDP:\n%s\n", sdp);
1381 }
1382
1383 static int stream_index_from_inputs(AVFormatContext **input_files,
1384                                     int nb_input_files,
1385                                     AVInputFile *file_table,
1386                                     AVInputStream **ist_table,
1387                                     enum CodecType type,
1388                                     int programid)
1389 {
1390     int p, q, z;
1391     for(z=0; z<nb_input_files; z++) {
1392         AVFormatContext *ic = input_files[z];
1393         for(p=0; p<ic->nb_programs; p++) {
1394             AVProgram *program = ic->programs[p];
1395             if(program->id != programid)
1396                 continue;
1397             for(q=0; q<program->nb_stream_indexes; q++) {
1398                 int sidx = program->stream_index[q];
1399                 int ris = file_table[z].ist_index + sidx;
1400                 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1401                     return ris;
1402             }
1403         }
1404     }
1405
1406     return -1;
1407 }
1408
1409 /*
1410  * The following code is the main loop of the file converter
1411  */
1412 static int av_encode(AVFormatContext **output_files,
1413                      int nb_output_files,
1414                      AVFormatContext **input_files,
1415                      int nb_input_files,
1416                      AVStreamMap *stream_maps, int nb_stream_maps)
1417 {
1418     int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1419     AVFormatContext *is, *os;
1420     AVCodecContext *codec, *icodec;
1421     AVOutputStream *ost, **ost_table = NULL;
1422     AVInputStream *ist, **ist_table = NULL;
1423     AVInputFile *file_table;
1424     int key;
1425     int want_sdp = 1;
1426
1427     file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1428     if (!file_table)
1429         goto fail;
1430
1431     /* input stream init */
1432     j = 0;
1433     for(i=0;i<nb_input_files;i++) {
1434         is = input_files[i];
1435         file_table[i].ist_index = j;
1436         file_table[i].nb_streams = is->nb_streams;
1437         j += is->nb_streams;
1438     }
1439     nb_istreams = j;
1440
1441     ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1442     if (!ist_table)
1443         goto fail;
1444
1445     for(i=0;i<nb_istreams;i++) {
1446         ist = av_mallocz(sizeof(AVInputStream));
1447         if (!ist)
1448             goto fail;
1449         ist_table[i] = ist;
1450     }
1451     j = 0;
1452     for(i=0;i<nb_input_files;i++) {
1453         is = input_files[i];
1454         for(k=0;k<is->nb_streams;k++) {
1455             ist = ist_table[j++];
1456             ist->st = is->streams[k];
1457             ist->file_index = i;
1458             ist->index = k;
1459             ist->discard = 1; /* the stream is discarded by default
1460                                  (changed later) */
1461
1462             if (ist->st->codec->rate_emu) {
1463                 ist->start = av_gettime();
1464                 ist->frame = 0;
1465             }
1466         }
1467     }
1468
1469     /* output stream init */
1470     nb_ostreams = 0;
1471     for(i=0;i<nb_output_files;i++) {
1472         os = output_files[i];
1473         if (!os->nb_streams) {
1474             fprintf(stderr, "Output file does not contain any stream\n");
1475             exit(1);
1476         }
1477         nb_ostreams += os->nb_streams;
1478     }
1479     if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1480         fprintf(stderr, "Number of stream maps must match number of output streams\n");
1481         exit(1);
1482     }
1483
1484     /* Sanity check the mapping args -- do the input files & streams exist? */
1485     for(i=0;i<nb_stream_maps;i++) {
1486         int fi = stream_maps[i].file_index;
1487         int si = stream_maps[i].stream_index;
1488
1489         if (fi < 0 || fi > nb_input_files - 1 ||
1490             si < 0 || si > file_table[fi].nb_streams - 1) {
1491             fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1492             exit(1);
1493         }
1494         fi = stream_maps[i].sync_file_index;
1495         si = stream_maps[i].sync_stream_index;
1496         if (fi < 0 || fi > nb_input_files - 1 ||
1497             si < 0 || si > file_table[fi].nb_streams - 1) {
1498             fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1499             exit(1);
1500         }
1501     }
1502
1503     ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1504     if (!ost_table)
1505         goto fail;
1506     for(i=0;i<nb_ostreams;i++) {
1507         ost = av_mallocz(sizeof(AVOutputStream));
1508         if (!ost)
1509             goto fail;
1510         ost_table[i] = ost;
1511     }
1512
1513     n = 0;
1514     for(k=0;k<nb_output_files;k++) {
1515         os = output_files[k];
1516         for(i=0;i<os->nb_streams;i++) {
1517             int found;
1518             ost = ost_table[n++];
1519             ost->file_index = k;
1520             ost->index = i;
1521             ost->st = os->streams[i];
1522             if (nb_stream_maps > 0) {
1523                 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1524                     stream_maps[n-1].stream_index;
1525
1526                 /* Sanity check that the stream types match */
1527                 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1528                     fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1529                         stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1530                         ost->file_index, ost->index);
1531                     exit(1);
1532                 }
1533
1534             } else {
1535                 if(opt_programid) {
1536                     found = 0;
1537                     j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1538                     if(j != -1) {
1539                         ost->source_index = j;
1540                         found = 1;
1541                     }
1542                 } else {
1543                     /* get corresponding input stream index : we select the first one with the right type */
1544                     found = 0;
1545                     for(j=0;j<nb_istreams;j++) {
1546                         ist = ist_table[j];
1547                         if (ist->discard &&
1548                             ist->st->codec->codec_type == ost->st->codec->codec_type) {
1549                             ost->source_index = j;
1550                             found = 1;
1551                             break;
1552                         }
1553                     }
1554                 }
1555
1556                 if (!found) {
1557                     if(! opt_programid) {
1558                         /* try again and reuse existing stream */
1559                         for(j=0;j<nb_istreams;j++) {
1560                             ist = ist_table[j];
1561                             if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1562                                 ost->source_index = j;
1563                                 found = 1;
1564                             }
1565                         }
1566                     }
1567                     if (!found) {
1568                         fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1569                                 ost->file_index, ost->index);
1570                         exit(1);
1571                     }
1572                 }
1573             }
1574             ist = ist_table[ost->source_index];
1575             ist->discard = 0;
1576             ost->sync_ist = (nb_stream_maps > 0) ?
1577                 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1578                          stream_maps[n-1].sync_stream_index] : ist;
1579         }
1580     }
1581
1582     /* for each output stream, we compute the right encoding parameters */
1583     for(i=0;i<nb_ostreams;i++) {
1584         ost = ost_table[i];
1585         os = output_files[ost->file_index];
1586         ist = ist_table[ost->source_index];
1587
1588         codec = ost->st->codec;
1589         icodec = ist->st->codec;
1590
1591         if (!ost->st->language[0])
1592             av_strlcpy(ost->st->language, ist->st->language,
1593                        sizeof(ost->st->language));
1594
1595         ost->st->disposition = ist->st->disposition;
1596
1597         if (ost->st->stream_copy) {
1598             /* if stream_copy is selected, no need to decode or encode */
1599             codec->codec_id = icodec->codec_id;
1600             codec->codec_type = icodec->codec_type;
1601
1602             if(!codec->codec_tag){
1603                 if(   !os->oformat->codec_tag
1604                    || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1605                    || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1606                     codec->codec_tag = icodec->codec_tag;
1607             }
1608
1609             codec->bit_rate = icodec->bit_rate;
1610             codec->extradata= icodec->extradata;
1611             codec->extradata_size= icodec->extradata_size;
1612             if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1613                 codec->time_base = icodec->time_base;
1614             else
1615                 codec->time_base = ist->st->time_base;
1616             switch(codec->codec_type) {
1617             case CODEC_TYPE_AUDIO:
1618                 codec->sample_rate = icodec->sample_rate;
1619                 codec->channels = icodec->channels;
1620                 codec->frame_size = icodec->frame_size;
1621                 codec->block_align= icodec->block_align;
1622                 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1623                     codec->block_align= 0;
1624                 break;
1625             case CODEC_TYPE_VIDEO:
1626                 if(using_vhook) {
1627                     fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1628                     exit(1);
1629                 }
1630                 codec->pix_fmt = icodec->pix_fmt;
1631                 codec->width = icodec->width;
1632                 codec->height = icodec->height;
1633                 codec->has_b_frames = icodec->has_b_frames;
1634                 break;
1635             case CODEC_TYPE_SUBTITLE:
1636                 break;
1637             default:
1638                 abort();
1639             }
1640         } else {
1641             switch(codec->codec_type) {
1642             case CODEC_TYPE_AUDIO:
1643                 if (av_fifo_init(&ost->fifo, 1024))
1644                     goto fail;
1645                 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1646                 icodec->request_channels = codec->channels;
1647                 ist->decoding_needed = 1;
1648                 ost->encoding_needed = 1;
1649                 break;
1650             case CODEC_TYPE_VIDEO:
1651                 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1652                 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1653                 ost->video_resample = ((codec->width != icodec->width -
1654                                 (frame_leftBand + frame_rightBand) +
1655                                 (frame_padleft + frame_padright)) ||
1656                         (codec->height != icodec->height -
1657                                 (frame_topBand  + frame_bottomBand) +
1658                                 (frame_padtop + frame_padbottom)) ||
1659                         (codec->pix_fmt != icodec->pix_fmt));
1660                 if (ost->video_crop) {
1661                     ost->topBand = frame_topBand;
1662                     ost->leftBand = frame_leftBand;
1663                 }
1664                 if (ost->video_pad) {
1665                     ost->padtop = frame_padtop;
1666                     ost->padleft = frame_padleft;
1667                     ost->padbottom = frame_padbottom;
1668                     ost->padright = frame_padright;
1669                     if (!ost->video_resample) {
1670                         avcodec_get_frame_defaults(&ost->pict_tmp);
1671                         if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1672                                          codec->width, codec->height ) )
1673                             goto fail;
1674                     }
1675                 }
1676                 if (ost->video_resample) {
1677                     avcodec_get_frame_defaults(&ost->pict_tmp);
1678                     if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1679                                          codec->width, codec->height ) ) {
1680                         fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1681                         exit(1);
1682                     }
1683                     sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1684                     ost->img_resample_ctx = sws_getContext(
1685                             icodec->width - (frame_leftBand + frame_rightBand),
1686                             icodec->height - (frame_topBand + frame_bottomBand),
1687                             icodec->pix_fmt,
1688                             codec->width - (frame_padleft + frame_padright),
1689                             codec->height - (frame_padtop + frame_padbottom),
1690                             codec->pix_fmt,
1691                             sws_flags, NULL, NULL, NULL);
1692                     if (ost->img_resample_ctx == NULL) {
1693                         fprintf(stderr, "Cannot get resampling context\n");
1694                         exit(1);
1695                     }
1696                     ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1697                 }
1698                 ost->encoding_needed = 1;
1699                 ist->decoding_needed = 1;
1700                 break;
1701             case CODEC_TYPE_SUBTITLE:
1702                 ost->encoding_needed = 1;
1703                 ist->decoding_needed = 1;
1704                 break;
1705             default:
1706                 abort();
1707                 break;
1708             }
1709             /* two pass mode */
1710             if (ost->encoding_needed &&
1711                 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1712                 char logfilename[1024];
1713                 FILE *f;
1714                 int size;
1715                 char *logbuffer;
1716
1717                 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1718                          pass_logfilename ?
1719                          pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1720                 if (codec->flags & CODEC_FLAG_PASS1) {
1721                     f = fopen(logfilename, "w");
1722                     if (!f) {
1723                         perror(logfilename);
1724                         exit(1);
1725                     }
1726                     ost->logfile = f;
1727                 } else {
1728                     /* read the log file */
1729                     f = fopen(logfilename, "r");
1730                     if (!f) {
1731                         perror(logfilename);
1732                         exit(1);
1733                     }
1734                     fseek(f, 0, SEEK_END);
1735                     size = ftell(f);
1736                     fseek(f, 0, SEEK_SET);
1737                     logbuffer = av_malloc(size + 1);
1738                     if (!logbuffer) {
1739                         fprintf(stderr, "Could not allocate log buffer\n");
1740                         exit(1);
1741                     }
1742                     size = fread(logbuffer, 1, size, f);
1743                     fclose(f);
1744                     logbuffer[size] = '\0';
1745                     codec->stats_in = logbuffer;
1746                 }
1747             }
1748         }
1749         if(codec->codec_type == CODEC_TYPE_VIDEO){
1750             int size= codec->width * codec->height;
1751             bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1752         }
1753     }
1754
1755     if (!bit_buffer)
1756         bit_buffer = av_malloc(bit_buffer_size);
1757     if (!bit_buffer)
1758         goto fail;
1759
1760     /* dump the file output parameters - cannot be done before in case
1761        of stream copy */
1762     for(i=0;i<nb_output_files;i++) {
1763         dump_format(output_files[i], i, output_files[i]->filename, 1);
1764     }
1765
1766     /* dump the stream mapping */
1767     if (verbose >= 0) {
1768         fprintf(stderr, "Stream mapping:\n");
1769         for(i=0;i<nb_ostreams;i++) {
1770             ost = ost_table[i];
1771             fprintf(stderr, "  Stream #%d.%d -> #%d.%d",
1772                     ist_table[ost->source_index]->file_index,
1773                     ist_table[ost->source_index]->index,
1774                     ost->file_index,
1775                     ost->index);
1776             if (ost->sync_ist != ist_table[ost->source_index])
1777                 fprintf(stderr, " [sync #%d.%d]",
1778                         ost->sync_ist->file_index,
1779                         ost->sync_ist->index);
1780             fprintf(stderr, "\n");
1781         }
1782     }
1783
1784     /* open each encoder */
1785     for(i=0;i<nb_ostreams;i++) {
1786         ost = ost_table[i];
1787         if (ost->encoding_needed) {
1788             AVCodec *codec;
1789             codec = avcodec_find_encoder(ost->st->codec->codec_id);
1790             if (!codec) {
1791                 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1792                         ost->file_index, ost->index);
1793                 exit(1);
1794             }
1795             if (avcodec_open(ost->st->codec, codec) < 0) {
1796                 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1797                         ost->file_index, ost->index);
1798                 exit(1);
1799             }
1800             extra_size += ost->st->codec->extradata_size;
1801         }
1802     }
1803
1804     /* open each decoder */
1805     for(i=0;i<nb_istreams;i++) {
1806         ist = ist_table[i];
1807         if (ist->decoding_needed) {
1808             AVCodec *codec;
1809             codec = avcodec_find_decoder(ist->st->codec->codec_id);
1810             if (!codec) {
1811                 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1812                         ist->st->codec->codec_id, ist->file_index, ist->index);
1813                 exit(1);
1814             }
1815             if (avcodec_open(ist->st->codec, codec) < 0) {
1816                 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1817                         ist->file_index, ist->index);
1818                 exit(1);
1819             }
1820             //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1821             //    ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1822         }
1823     }
1824
1825     /* init pts */
1826     for(i=0;i<nb_istreams;i++) {
1827         ist = ist_table[i];
1828         is = input_files[ist->file_index];
1829         ist->pts = 0;
1830         ist->next_pts = AV_NOPTS_VALUE;
1831         ist->is_start = 1;
1832     }
1833
1834     /* set meta data information from input file if required */
1835     for (i=0;i<nb_meta_data_maps;i++) {
1836         AVFormatContext *out_file;
1837         AVFormatContext *in_file;
1838
1839         int out_file_index = meta_data_maps[i].out_file;
1840         int in_file_index = meta_data_maps[i].in_file;
1841         if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1842             fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1843             ret = AVERROR(EINVAL);
1844             goto fail;
1845         }
1846         if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1847             fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1848             ret = AVERROR(EINVAL);
1849             goto fail;
1850         }
1851
1852         out_file = output_files[out_file_index];
1853         in_file = input_files[in_file_index];
1854
1855         strcpy(out_file->title, in_file->title);
1856         strcpy(out_file->author, in_file->author);
1857         strcpy(out_file->copyright, in_file->copyright);
1858         strcpy(out_file->comment, in_file->comment);
1859         strcpy(out_file->album, in_file->album);
1860         out_file->year = in_file->year;
1861         out_file->track = in_file->track;
1862         strcpy(out_file->genre, in_file->genre);
1863     }
1864
1865     /* open files and write file headers */
1866     for(i=0;i<nb_output_files;i++) {
1867         os = output_files[i];
1868         if (av_write_header(os) < 0) {
1869             fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1870             ret = AVERROR(EINVAL);
1871             goto fail;
1872         }
1873         if (strcmp(output_files[i]->oformat->name, "rtp")) {
1874             want_sdp = 0;
1875         }
1876     }
1877     if (want_sdp) {
1878         print_sdp(output_files, nb_output_files);
1879     }
1880
1881     if ( !using_stdin && verbose >= 0) {
1882         fprintf(stderr, "Press [q] to stop encoding\n");
1883         url_set_interrupt_cb(decode_interrupt_cb);
1884     }
1885     term_init();
1886
1887     key = -1;
1888     timer_start = av_gettime();
1889
1890     for(; received_sigterm == 0;) {
1891         int file_index, ist_index;
1892         AVPacket pkt;
1893         double ipts_min;
1894         double opts_min;
1895
1896     redo:
1897         ipts_min= 1e100;
1898         opts_min= 1e100;
1899         /* if 'q' pressed, exits */
1900         if (!using_stdin) {
1901             if (q_pressed)
1902                 break;
1903             /* read_key() returns 0 on EOF */
1904             key = read_key();
1905             if (key == 'q')
1906                 break;
1907         }
1908
1909         /* select the stream that we must read now by looking at the
1910            smallest output pts */
1911         file_index = -1;
1912         for(i=0;i<nb_ostreams;i++) {
1913             double ipts, opts;
1914             ost = ost_table[i];
1915             os = output_files[ost->file_index];
1916             ist = ist_table[ost->source_index];
1917             if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1918                 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1919             else
1920                 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1921             ipts = (double)ist->pts;
1922             if (!file_table[ist->file_index].eof_reached){
1923                 if(ipts < ipts_min) {
1924                     ipts_min = ipts;
1925                     if(input_sync ) file_index = ist->file_index;
1926                 }
1927                 if(opts < opts_min) {
1928                     opts_min = opts;
1929                     if(!input_sync) file_index = ist->file_index;
1930                 }
1931             }
1932             if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1933                 file_index= -1;
1934                 break;
1935             }
1936         }
1937         /* if none, if is finished */
1938         if (file_index < 0) {
1939             break;
1940         }
1941
1942         /* finish if recording time exhausted */
1943         if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1944             break;
1945
1946         /* finish if limit size exhausted */
1947         if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1948             break;
1949
1950         /* read a frame from it and output it in the fifo */
1951         is = input_files[file_index];
1952         if (av_read_frame(is, &pkt) < 0) {
1953             file_table[file_index].eof_reached = 1;
1954             if (opt_shortest)
1955                 break;
1956             else
1957                 continue;
1958         }
1959
1960         if (do_pkt_dump) {
1961             av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1962         }
1963         /* the following test is needed in case new streams appear
1964            dynamically in stream : we ignore them */
1965         if (pkt.stream_index >= file_table[file_index].nb_streams)
1966             goto discard_packet;
1967         ist_index = file_table[file_index].ist_index + pkt.stream_index;
1968         ist = ist_table[ist_index];
1969         if (ist->discard)
1970             goto discard_packet;
1971
1972         if (pkt.dts != AV_NOPTS_VALUE)
1973             pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1974         if (pkt.pts != AV_NOPTS_VALUE)
1975             pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1976
1977 //        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);
1978         if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1979             int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1980             int64_t delta= pkt_dts - ist->next_pts;
1981             if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1982                 input_files_ts_offset[ist->file_index]-= delta;
1983                 if (verbose > 2)
1984                     fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1985                 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1986                 if(pkt.pts != AV_NOPTS_VALUE)
1987                     pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1988             }
1989         }
1990
1991         //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1992         if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1993
1994             if (verbose >= 0)
1995                 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1996                         ist->file_index, ist->index);
1997
1998             av_free_packet(&pkt);
1999             goto redo;
2000         }
2001
2002     discard_packet:
2003         av_free_packet(&pkt);
2004
2005         /* dump report by using the output first video and audio streams */
2006         print_report(output_files, ost_table, nb_ostreams, 0);
2007     }
2008
2009     /* at the end of stream, we must flush the decoder buffers */
2010     for(i=0;i<nb_istreams;i++) {
2011         ist = ist_table[i];
2012         if (ist->decoding_needed) {
2013             output_packet(ist, i, ost_table, nb_ostreams, NULL);
2014         }
2015     }
2016
2017     term_exit();
2018
2019     /* write the trailer if needed and close file */
2020     for(i=0;i<nb_output_files;i++) {
2021         os = output_files[i];
2022         av_write_trailer(os);
2023     }
2024
2025     /* dump report by using the first video and audio streams */
2026     print_report(output_files, ost_table, nb_ostreams, 1);
2027
2028     /* close each encoder */
2029     for(i=0;i<nb_ostreams;i++) {
2030         ost = ost_table[i];
2031         if (ost->encoding_needed) {
2032             av_freep(&ost->st->codec->stats_in);
2033             avcodec_close(ost->st->codec);
2034         }
2035     }
2036
2037     /* close each decoder */
2038     for(i=0;i<nb_istreams;i++) {
2039         ist = ist_table[i];
2040         if (ist->decoding_needed) {
2041             avcodec_close(ist->st->codec);
2042         }
2043     }
2044
2045     /* finished ! */
2046
2047     ret = 0;
2048  fail1:
2049     av_freep(&bit_buffer);
2050     av_free(file_table);
2051
2052     if (ist_table) {
2053         for(i=0;i<nb_istreams;i++) {
2054             ist = ist_table[i];
2055             av_free(ist);
2056         }
2057         av_free(ist_table);
2058     }
2059     if (ost_table) {
2060         for(i=0;i<nb_ostreams;i++) {
2061             ost = ost_table[i];
2062             if (ost) {
2063                 if (ost->logfile) {
2064                     fclose(ost->logfile);
2065                     ost->logfile = NULL;
2066                 }
2067                 av_fifo_free(&ost->fifo); /* works even if fifo is not
2068                                              initialized but set to zero */
2069                 av_free(ost->pict_tmp.data[0]);
2070                 if (ost->video_resample)
2071                     sws_freeContext(ost->img_resample_ctx);
2072                 if (ost->resample)
2073                     audio_resample_close(ost->resample);
2074                 av_free(ost);
2075             }
2076         }
2077         av_free(ost_table);
2078     }
2079     return ret;
2080  fail:
2081     ret = AVERROR(ENOMEM);
2082     goto fail1;
2083 }
2084
2085 #if 0
2086 int file_read(const char *filename)
2087 {
2088     URLContext *h;
2089     unsigned char buffer[1024];
2090     int len, i;
2091
2092     if (url_open(&h, filename, O_RDONLY) < 0) {
2093         printf("could not open '%s'\n", filename);
2094         return -1;
2095     }
2096     for(;;) {
2097         len = url_read(h, buffer, sizeof(buffer));
2098         if (len <= 0)
2099             break;
2100         for(i=0;i<len;i++) putchar(buffer[i]);
2101     }
2102     url_close(h);
2103     return 0;
2104 }
2105 #endif
2106
2107 static void opt_format(const char *arg)
2108 {
2109     /* compatibility stuff for pgmyuv */
2110     if (!strcmp(arg, "pgmyuv")) {
2111         pgmyuv_compatibility_hack=1;
2112 //        opt_image_format(arg);
2113         arg = "image2";
2114         fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2115     }
2116
2117     file_iformat = av_find_input_format(arg);
2118     file_oformat = guess_format(arg, NULL, NULL);
2119     if (!file_iformat && !file_oformat) {
2120         fprintf(stderr, "Unknown input or output format: %s\n", arg);
2121         exit(1);
2122     }
2123 }
2124
2125 extern int ffm_nopts;
2126
2127 static int opt_default(const char *opt, const char *arg){
2128     int type;
2129     const AVOption *o= NULL;
2130     int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2131
2132     for(type=0; type<CODEC_TYPE_NB; type++){
2133         const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2134         if(o2)
2135             o = av_set_string(avctx_opts[type], opt, arg);
2136     }
2137     if(!o)
2138         o = av_set_string(avformat_opts, opt, arg);
2139     if(!o)
2140         o = av_set_string(sws_opts, opt, arg);
2141     if(!o){
2142         if(opt[0] == 'a')
2143             o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2144         else if(opt[0] == 'v')
2145             o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2146         else if(opt[0] == 's')
2147             o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2148     }
2149     if(!o)
2150         return -1;
2151
2152 //    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));
2153
2154     //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2155     opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2156     opt_names[opt_name_count++]= o->name;
2157
2158 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2159     /* disable generate of real time pts in ffm (need to be supressed anyway) */
2160     if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2161         ffm_nopts = 1;
2162 #endif
2163
2164     if(avctx_opts[0]->debug)
2165         av_log_set_level(AV_LOG_DEBUG);
2166     return 0;
2167 }
2168
2169 static void opt_video_rc_override_string(const char *arg)
2170 {
2171     video_rc_override_string = arg;
2172 }
2173
2174 static void opt_me_threshold(const char *arg)
2175 {
2176     me_threshold = atoi(arg);
2177 }
2178
2179 static void opt_verbose(const char *arg)
2180 {
2181     verbose = atoi(arg);
2182     av_log_set_level(verbose);
2183 }
2184
2185 static void opt_frame_rate(const char *arg)
2186 {
2187     if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2188         fprintf(stderr, "Incorrect frame rate\n");
2189         exit(1);
2190     }
2191 }
2192
2193 static int opt_bitrate(const char *opt, const char *arg)
2194 {
2195     int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2196
2197     opt_default(opt, arg);
2198
2199     if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2200         fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2201
2202     return 0;
2203 }
2204
2205 static void opt_frame_crop_top(const char *arg)
2206 {
2207     frame_topBand = atoi(arg);
2208     if (frame_topBand < 0) {
2209         fprintf(stderr, "Incorrect top crop size\n");
2210         exit(1);
2211     }
2212     if ((frame_topBand % 2) != 0) {
2213         fprintf(stderr, "Top crop size must be a multiple of 2\n");
2214         exit(1);
2215     }
2216     if ((frame_topBand) >= frame_height){
2217         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2218         exit(1);
2219     }
2220     frame_height -= frame_topBand;
2221 }
2222
2223 static void opt_frame_crop_bottom(const char *arg)
2224 {
2225     frame_bottomBand = atoi(arg);
2226     if (frame_bottomBand < 0) {
2227         fprintf(stderr, "Incorrect bottom crop size\n");
2228         exit(1);
2229     }
2230     if ((frame_bottomBand % 2) != 0) {
2231         fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2232         exit(1);
2233     }
2234     if ((frame_bottomBand) >= frame_height){
2235         fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2236         exit(1);
2237     }
2238     frame_height -= frame_bottomBand;
2239 }
2240
2241 static void opt_frame_crop_left(const char *arg)
2242 {
2243     frame_leftBand = atoi(arg);
2244     if (frame_leftBand < 0) {
2245         fprintf(stderr, "Incorrect left crop size\n");
2246         exit(1);
2247     }
2248     if ((frame_leftBand % 2) != 0) {
2249         fprintf(stderr, "Left crop size must be a multiple of 2\n");
2250         exit(1);
2251     }
2252     if ((frame_leftBand) >= frame_width){
2253         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2254         exit(1);
2255     }
2256     frame_width -= frame_leftBand;
2257 }
2258
2259 static void opt_frame_crop_right(const char *arg)
2260 {
2261     frame_rightBand = atoi(arg);
2262     if (frame_rightBand < 0) {
2263         fprintf(stderr, "Incorrect right crop size\n");
2264         exit(1);
2265     }
2266     if ((frame_rightBand % 2) != 0) {
2267         fprintf(stderr, "Right crop size must be a multiple of 2\n");
2268         exit(1);
2269     }
2270     if ((frame_rightBand) >= frame_width){
2271         fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2272         exit(1);
2273     }
2274     frame_width -= frame_rightBand;
2275 }
2276
2277 static void opt_frame_size(const char *arg)
2278 {
2279     if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2280         fprintf(stderr, "Incorrect frame size\n");
2281         exit(1);
2282     }
2283     if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2284         fprintf(stderr, "Frame size must be a multiple of 2\n");
2285         exit(1);
2286     }
2287 }
2288
2289
2290 #define SCALEBITS 10
2291 #define ONE_HALF  (1 << (SCALEBITS - 1))
2292 #define FIX(x)    ((int) ((x) * (1<<SCALEBITS) + 0.5))
2293
2294 #define RGB_TO_Y(r, g, b) \
2295 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2296   FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2297
2298 #define RGB_TO_U(r1, g1, b1, shift)\
2299 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 +         \
2300      FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2301
2302 #define RGB_TO_V(r1, g1, b1, shift)\
2303 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 -           \
2304    FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2305
2306 static void opt_pad_color(const char *arg) {
2307     /* Input is expected to be six hex digits similar to
2308        how colors are expressed in html tags (but without the #) */
2309     int rgb = strtol(arg, NULL, 16);
2310     int r,g,b;
2311
2312     r = (rgb >> 16);
2313     g = ((rgb >> 8) & 255);
2314     b = (rgb & 255);
2315
2316     padcolor[0] = RGB_TO_Y(r,g,b);
2317     padcolor[1] = RGB_TO_U(r,g,b,0);
2318     padcolor[2] = RGB_TO_V(r,g,b,0);
2319 }
2320
2321 static void opt_frame_pad_top(const char *arg)
2322 {
2323     frame_padtop = atoi(arg);
2324     if (frame_padtop < 0) {
2325         fprintf(stderr, "Incorrect top pad size\n");
2326         exit(1);
2327     }
2328     if ((frame_padtop % 2) != 0) {
2329         fprintf(stderr, "Top pad size must be a multiple of 2\n");
2330         exit(1);
2331     }
2332 }
2333
2334 static void opt_frame_pad_bottom(const char *arg)
2335 {
2336     frame_padbottom = atoi(arg);
2337     if (frame_padbottom < 0) {
2338         fprintf(stderr, "Incorrect bottom pad size\n");
2339         exit(1);
2340     }
2341     if ((frame_padbottom % 2) != 0) {
2342         fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2343         exit(1);
2344     }
2345 }
2346
2347
2348 static void opt_frame_pad_left(const char *arg)
2349 {
2350     frame_padleft = atoi(arg);
2351     if (frame_padleft < 0) {
2352         fprintf(stderr, "Incorrect left pad size\n");
2353         exit(1);
2354     }
2355     if ((frame_padleft % 2) != 0) {
2356         fprintf(stderr, "Left pad size must be a multiple of 2\n");
2357         exit(1);
2358     }
2359 }
2360
2361
2362 static void opt_frame_pad_right(const char *arg)
2363 {
2364     frame_padright = atoi(arg);
2365     if (frame_padright < 0) {
2366         fprintf(stderr, "Incorrect right pad size\n");
2367         exit(1);
2368     }
2369     if ((frame_padright % 2) != 0) {
2370         fprintf(stderr, "Right pad size must be a multiple of 2\n");
2371         exit(1);
2372     }
2373 }
2374
2375 void list_pix_fmts(void)
2376 {
2377     int i;
2378     char pix_fmt_str[128];
2379     for (i=-1; i < PIX_FMT_NB; i++) {
2380         avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2381         fprintf(stdout, "%s\n", pix_fmt_str);
2382     }
2383 }
2384
2385 static void opt_frame_pix_fmt(const char *arg)
2386 {
2387     if (strcmp(arg, "list"))
2388         frame_pix_fmt = avcodec_get_pix_fmt(arg);
2389     else {
2390         list_pix_fmts();
2391         exit(0);
2392     }
2393 }
2394
2395 static void opt_frame_aspect_ratio(const char *arg)
2396 {
2397     int x = 0, y = 0;
2398     double ar = 0;
2399     const char *p;
2400     char *end;
2401
2402     p = strchr(arg, ':');
2403     if (p) {
2404         x = strtol(arg, &end, 10);
2405         if (end == p)
2406             y = strtol(end+1, &end, 10);
2407         if (x > 0 && y > 0)
2408             ar = (double)x / (double)y;
2409     } else
2410         ar = strtod(arg, NULL);
2411
2412     if (!ar) {
2413         fprintf(stderr, "Incorrect aspect ratio specification.\n");
2414         exit(1);
2415     }
2416     frame_aspect_ratio = ar;
2417 }
2418
2419 static void opt_qscale(const char *arg)
2420 {
2421     video_qscale = atof(arg);
2422     if (video_qscale <= 0 ||
2423         video_qscale > 255) {
2424         fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2425         exit(1);
2426     }
2427 }
2428
2429 static void opt_qdiff(const char *arg)
2430 {
2431     video_qdiff = atoi(arg);
2432     if (video_qdiff < 0 ||
2433         video_qdiff > 31) {
2434         fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2435         exit(1);
2436     }
2437 }
2438
2439 static void opt_strict(const char *arg)
2440 {
2441     strict= atoi(arg);
2442 }
2443
2444 static void opt_top_field_first(const char *arg)
2445 {
2446     top_field_first= atoi(arg);
2447 }
2448
2449 static void opt_thread_count(const char *arg)
2450 {
2451     thread_count= atoi(arg);
2452 #if !defined(HAVE_THREADS)
2453     if (verbose >= 0)
2454         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2455 #endif
2456 }
2457
2458 static void opt_audio_rate(const char *arg)
2459 {
2460     audio_sample_rate = atoi(arg);
2461 }
2462
2463 static void opt_audio_channels(const char *arg)
2464 {
2465     audio_channels = atoi(arg);
2466 }
2467
2468 static void opt_video_channel(const char *arg)
2469 {
2470     video_channel = strtol(arg, NULL, 0);
2471 }
2472
2473 static void opt_video_standard(const char *arg)
2474 {
2475     video_standard = av_strdup(arg);
2476 }
2477
2478 static void opt_codec(int *pstream_copy, char **pcodec_name,
2479                       int codec_type, const char *arg)
2480 {
2481     av_freep(pcodec_name);
2482     if (!strcmp(arg, "copy")) {
2483         *pstream_copy = 1;
2484     } else {
2485         *pcodec_name = av_strdup(arg);
2486     }
2487 }
2488
2489 static void opt_audio_codec(const char *arg)
2490 {
2491     opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2492 }
2493
2494 static void opt_audio_tag(const char *arg)
2495 {
2496     char *tail;
2497     audio_codec_tag= strtol(arg, &tail, 0);
2498
2499     if(!tail || *tail)
2500         audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2501 }
2502
2503 static void opt_video_tag(const char *arg)
2504 {
2505     char *tail;
2506     video_codec_tag= strtol(arg, &tail, 0);
2507
2508     if(!tail || *tail)
2509         video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2510 }
2511
2512 #ifdef CONFIG_VHOOK
2513 static void add_frame_hooker(const char *arg)
2514 {
2515     int argc = 0;
2516     char *argv[64];
2517     int i;
2518     char *args = av_strdup(arg);
2519
2520     using_vhook = 1;
2521
2522     argv[0] = strtok(args, " ");
2523     while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2524     }
2525
2526     i = frame_hook_add(argc, argv);
2527
2528     if (i != 0) {
2529         fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2530         exit(1);
2531     }
2532 }
2533 #endif
2534
2535 static void opt_video_codec(const char *arg)
2536 {
2537     opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2538 }
2539
2540 static void opt_subtitle_codec(const char *arg)
2541 {
2542     opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2543 }
2544
2545 static void opt_map(const char *arg)
2546 {
2547     AVStreamMap *m;
2548     char *p;
2549
2550     m = &stream_maps[nb_stream_maps++];
2551
2552     m->file_index = strtol(arg, &p, 0);
2553     if (*p)
2554         p++;
2555
2556     m->stream_index = strtol(p, &p, 0);
2557     if (*p) {
2558         p++;
2559         m->sync_file_index = strtol(p, &p, 0);
2560         if (*p)
2561             p++;
2562         m->sync_stream_index = strtol(p, &p, 0);
2563     } else {
2564         m->sync_file_index = m->file_index;
2565         m->sync_stream_index = m->stream_index;
2566     }
2567 }
2568
2569 static void opt_map_meta_data(const char *arg)
2570 {
2571     AVMetaDataMap *m;
2572     char *p;
2573
2574     m = &meta_data_maps[nb_meta_data_maps++];
2575
2576     m->out_file = strtol(arg, &p, 0);
2577     if (*p)
2578         p++;
2579
2580     m->in_file = strtol(p, &p, 0);
2581 }
2582
2583 static int opt_recording_time(const char *opt, const char *arg)
2584 {
2585     recording_time = parse_time_or_die(opt, arg, 1);
2586     return 0;
2587 }
2588
2589 static int opt_start_time(const char *opt, const char *arg)
2590 {
2591     start_time = parse_time_or_die(opt, arg, 1);
2592     return 0;
2593 }
2594
2595 static int opt_rec_timestamp(const char *opt, const char *arg)
2596 {
2597     rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2598     return 0;
2599 }
2600
2601 static int opt_input_ts_offset(const char *opt, const char *arg)
2602 {
2603     input_ts_offset = parse_time_or_die(opt, arg, 1);
2604     return 0;
2605 }
2606
2607 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2608 {
2609     const char *codec_string = encoder ? "encoder" : "decoder";
2610     AVCodec *codec;
2611
2612     if(!name)
2613         return CODEC_ID_NONE;
2614     codec = encoder ?
2615         avcodec_find_encoder_by_name(name) :
2616         avcodec_find_decoder_by_name(name);
2617     if(!codec) {
2618         av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2619         exit(1);
2620     }
2621     if(codec->type != type) {
2622         av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2623         exit(1);
2624     }
2625     return codec->id;
2626 }
2627
2628 static void opt_input_file(const char *filename)
2629 {
2630     AVFormatContext *ic;
2631     AVFormatParameters params, *ap = &params;
2632     int err, i, ret, rfps, rfps_base;
2633     int64_t timestamp;
2634
2635     if (!strcmp(filename, "-"))
2636         filename = "pipe:";
2637
2638     using_stdin |= !strncmp(filename, "pipe:", 5) ||
2639                    !strcmp( filename, "/dev/stdin" );
2640
2641     /* get default parameters from command line */
2642     ic = av_alloc_format_context();
2643
2644     memset(ap, 0, sizeof(*ap));
2645     ap->prealloced_context = 1;
2646     ap->sample_rate = audio_sample_rate;
2647     ap->channels = audio_channels;
2648     ap->time_base.den = frame_rate.num;
2649     ap->time_base.num = frame_rate.den;
2650     ap->width = frame_width + frame_padleft + frame_padright;
2651     ap->height = frame_height + frame_padtop + frame_padbottom;
2652     ap->pix_fmt = frame_pix_fmt;
2653     ap->channel = video_channel;
2654     ap->standard = video_standard;
2655     ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2656     ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2657     if(pgmyuv_compatibility_hack)
2658         ap->video_codec_id= CODEC_ID_PGMYUV;
2659
2660     for(i=0; i<opt_name_count; i++){
2661         char buf[256];
2662         const AVOption *opt;
2663         const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2664         if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2665             av_set_string(ic, opt_names[i], str);
2666     }
2667
2668     ic->video_codec_id   = find_codec_or_die(video_codec_name   , CODEC_TYPE_VIDEO   , 0);
2669     ic->audio_codec_id   = find_codec_or_die(audio_codec_name   , CODEC_TYPE_AUDIO   , 0);
2670     ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2671
2672     /* open the input file with generic libav function */
2673     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2674     if (err < 0) {
2675         print_error(filename, err);
2676         exit(1);
2677     }
2678     if(opt_programid) {
2679         int i;
2680         for(i=0; i<ic->nb_programs; i++)
2681             if(ic->programs[i]->id != opt_programid)
2682                 ic->programs[i]->discard = AVDISCARD_ALL;
2683     }
2684
2685     ic->loop_input = loop_input;
2686
2687     /* If not enough info to get the stream parameters, we decode the
2688        first frames to get it. (used in mpeg case for example) */
2689     ret = av_find_stream_info(ic);
2690     if (ret < 0 && verbose >= 0) {
2691         fprintf(stderr, "%s: could not find codec parameters\n", filename);
2692         exit(1);
2693     }
2694
2695     timestamp = start_time;
2696     /* add the stream start time */
2697     if (ic->start_time != AV_NOPTS_VALUE)
2698         timestamp += ic->start_time;
2699
2700     /* if seeking requested, we execute it */
2701     if (start_time != 0) {
2702         ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2703         if (ret < 0) {
2704             fprintf(stderr, "%s: could not seek to position %0.3f\n",
2705                     filename, (double)timestamp / AV_TIME_BASE);
2706         }
2707         /* reset seek info */
2708         start_time = 0;
2709     }
2710
2711     /* update the current parameters so that they match the one of the input stream */
2712     for(i=0;i<ic->nb_streams;i++) {
2713         int j;
2714         AVCodecContext *enc = ic->streams[i]->codec;
2715         if(thread_count>1)
2716             avcodec_thread_init(enc, thread_count);
2717         enc->thread_count= thread_count;
2718         switch(enc->codec_type) {
2719         case CODEC_TYPE_AUDIO:
2720             for(j=0; j<opt_name_count; j++){
2721                 char buf[256];
2722                 const AVOption *opt;
2723                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2724                 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2725                     av_set_string(enc, opt_names[j], str);
2726             }
2727             //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2728             audio_channels = enc->channels;
2729             audio_sample_rate = enc->sample_rate;
2730             if(audio_disable)
2731                 ic->streams[i]->discard= AVDISCARD_ALL;
2732             break;
2733         case CODEC_TYPE_VIDEO:
2734             for(j=0; j<opt_name_count; j++){
2735                 char buf[256];
2736                 const AVOption *opt;
2737                 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2738                 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2739                     av_set_string(enc, opt_names[j], str);
2740             }
2741             frame_height = enc->height;
2742             frame_width = enc->width;
2743             frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2744             frame_pix_fmt = enc->pix_fmt;
2745             rfps      = ic->streams[i]->r_frame_rate.num;
2746             rfps_base = ic->streams[i]->r_frame_rate.den;
2747             if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2748             if(me_threshold)
2749                 enc->debug |= FF_DEBUG_MV;
2750
2751             if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2752
2753                 if (verbose >= 0)
2754                     fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2755                             i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2756
2757                     (float)rfps / rfps_base, rfps, rfps_base);
2758             }
2759             /* update the current frame rate to match the stream frame rate */
2760             frame_rate.num = rfps;
2761             frame_rate.den = rfps_base;
2762
2763             enc->rate_emu = rate_emu;
2764             if(video_disable)
2765                 ic->streams[i]->discard= AVDISCARD_ALL;
2766             else if(video_discard)
2767                 ic->streams[i]->discard= video_discard;
2768             break;
2769         case CODEC_TYPE_DATA:
2770             break;
2771         case CODEC_TYPE_SUBTITLE:
2772             if(subtitle_disable)
2773                 ic->streams[i]->discard = AVDISCARD_ALL;
2774             break;
2775         case CODEC_TYPE_ATTACHMENT:
2776         case CODEC_TYPE_UNKNOWN:
2777             break;
2778         default:
2779             abort();
2780         }
2781     }
2782
2783     input_files[nb_input_files] = ic;
2784     input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2785     /* dump the file content */
2786     if (verbose >= 0)
2787         dump_format(ic, nb_input_files, filename, 0);
2788
2789     nb_input_files++;
2790     file_iformat = NULL;
2791     file_oformat = NULL;
2792
2793     video_channel = 0;
2794
2795     rate_emu = 0;
2796     av_freep(&video_codec_name);
2797     av_freep(&audio_codec_name);
2798     av_freep(&subtitle_codec_name);
2799 }
2800
2801 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2802                                          int *has_subtitle_ptr)
2803 {
2804     int has_video, has_audio, has_subtitle, i, j;
2805     AVFormatContext *ic;
2806
2807     has_video = 0;
2808     has_audio = 0;
2809     has_subtitle = 0;
2810     for(j=0;j<nb_input_files;j++) {
2811         ic = input_files[j];
2812         for(i=0;i<ic->nb_streams;i++) {
2813             AVCodecContext *enc = ic->streams[i]->codec;
2814             switch(enc->codec_type) {
2815             case CODEC_TYPE_AUDIO:
2816                 has_audio = 1;
2817                 break;
2818             case CODEC_TYPE_VIDEO:
2819                 has_video = 1;
2820                 break;
2821             case CODEC_TYPE_SUBTITLE:
2822                 has_subtitle = 1;
2823                 break;
2824             case CODEC_TYPE_DATA:
2825             case CODEC_TYPE_ATTACHMENT:
2826             case CODEC_TYPE_UNKNOWN:
2827                 break;
2828             default:
2829                 abort();
2830             }
2831         }
2832     }
2833     *has_video_ptr = has_video;
2834     *has_audio_ptr = has_audio;
2835     *has_subtitle_ptr = has_subtitle;
2836 }
2837
2838 static void new_video_stream(AVFormatContext *oc)
2839 {
2840     AVStream *st;
2841     AVCodecContext *video_enc;
2842     int codec_id;
2843
2844     st = av_new_stream(oc, oc->nb_streams);
2845     if (!st) {
2846         fprintf(stderr, "Could not alloc stream\n");
2847         exit(1);
2848     }
2849     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2850     bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2851     video_bitstream_filters= NULL;
2852
2853     if(thread_count>1)
2854         avcodec_thread_init(st->codec, thread_count);
2855
2856     video_enc = st->codec;
2857
2858     if(video_codec_tag)
2859         video_enc->codec_tag= video_codec_tag;
2860
2861     if(   (video_global_header&1)
2862        || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2863         video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2864         avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2865     }
2866     if(video_global_header&2){
2867         video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2868         avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2869     }
2870
2871     if (video_stream_copy) {
2872         st->stream_copy = 1;
2873         video_enc->codec_type = CODEC_TYPE_VIDEO;
2874     } else {
2875         const char *p;
2876         int i;
2877         AVCodec *codec;
2878         AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2879
2880         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2881         if (video_codec_name)
2882             codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2883
2884         video_enc->codec_id = codec_id;
2885         codec = avcodec_find_encoder(codec_id);
2886
2887         for(i=0; i<opt_name_count; i++){
2888             char buf[256];
2889             const AVOption *opt;
2890             const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2891             if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2892                 av_set_string(video_enc, opt_names[i], str);
2893         }
2894
2895         video_enc->time_base.den = fps.num;
2896         video_enc->time_base.num = fps.den;
2897         if(codec && codec->supported_framerates){
2898             const AVRational *p= codec->supported_framerates;
2899             const AVRational *best=NULL;
2900             AVRational best_error= (AVRational){INT_MAX, 1};
2901             for(; p->den!=0; p++){
2902                 AVRational error= av_sub_q(fps, *p);
2903                 if(error.num <0) error.num *= -1;
2904                 if(av_cmp_q(error, best_error) < 0){
2905                     best_error= error;
2906                     best= p;
2907                 }
2908             }
2909             video_enc->time_base.den= best->num;
2910             video_enc->time_base.num= best->den;
2911         }
2912
2913         video_enc->width = frame_width + frame_padright + frame_padleft;
2914         video_enc->height = frame_height + frame_padtop + frame_padbottom;
2915         video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2916         video_enc->pix_fmt = frame_pix_fmt;
2917
2918         if(codec && codec->pix_fmts){
2919             const enum PixelFormat *p= codec->pix_fmts;
2920             for(; *p!=-1; p++){
2921                 if(*p == video_enc->pix_fmt)
2922                     break;
2923             }
2924             if(*p == -1)
2925                 video_enc->pix_fmt = codec->pix_fmts[0];
2926         }
2927
2928         if (intra_only)
2929             video_enc->gop_size = 0;
2930         if (video_qscale || same_quality) {
2931             video_enc->flags |= CODEC_FLAG_QSCALE;
2932             video_enc->global_quality=
2933                 st->quality = FF_QP2LAMBDA * video_qscale;
2934         }
2935
2936         if(intra_matrix)
2937             video_enc->intra_matrix = intra_matrix;
2938         if(inter_matrix)
2939             video_enc->inter_matrix = inter_matrix;
2940
2941         video_enc->max_qdiff = video_qdiff;
2942         video_enc->thread_count = thread_count;
2943         p= video_rc_override_string;
2944         for(i=0; p; i++){
2945             int start, end, q;
2946             int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2947             if(e!=3){
2948                 fprintf(stderr, "error parsing rc_override\n");
2949                 exit(1);
2950             }
2951             video_enc->rc_override=
2952                 av_realloc(video_enc->rc_override,
2953                            sizeof(RcOverride)*(i+1));
2954             video_enc->rc_override[i].start_frame= start;
2955             video_enc->rc_override[i].end_frame  = end;
2956             if(q>0){
2957                 video_enc->rc_override[i].qscale= q;
2958                 video_enc->rc_override[i].quality_factor= 1.0;
2959             }
2960             else{
2961                 video_enc->rc_override[i].qscale= 0;
2962                 video_enc->rc_override[i].quality_factor= -q/100.0;
2963             }
2964             p= strchr(p, '/');
2965             if(p) p++;
2966         }
2967         video_enc->rc_override_count=i;
2968         if (!video_enc->rc_initial_buffer_occupancy)
2969             video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2970         video_enc->me_threshold= me_threshold;
2971         video_enc->intra_dc_precision= intra_dc_precision - 8;
2972         video_enc->strict_std_compliance = strict;
2973
2974         if (do_psnr)
2975             video_enc->flags|= CODEC_FLAG_PSNR;
2976
2977         /* two pass mode */
2978         if (do_pass) {
2979             if (do_pass == 1) {
2980                 video_enc->flags |= CODEC_FLAG_PASS1;
2981             } else {
2982                 video_enc->flags |= CODEC_FLAG_PASS2;
2983             }
2984         }
2985     }
2986
2987     /* reset some key parameters */
2988     video_disable = 0;
2989     av_freep(&video_codec_name);
2990     video_stream_copy = 0;
2991 }
2992
2993 static void new_audio_stream(AVFormatContext *oc)
2994 {
2995     AVStream *st;
2996     AVCodecContext *audio_enc;
2997     int codec_id, i;
2998
2999     st = av_new_stream(oc, oc->nb_streams);
3000     if (!st) {
3001         fprintf(stderr, "Could not alloc stream\n");
3002         exit(1);
3003     }
3004     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3005
3006     bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3007     audio_bitstream_filters= NULL;
3008
3009     if(thread_count>1)
3010         avcodec_thread_init(st->codec, thread_count);
3011
3012     audio_enc = st->codec;
3013     audio_enc->codec_type = CODEC_TYPE_AUDIO;
3014     audio_enc->strict_std_compliance = strict;
3015
3016     if(audio_codec_tag)
3017         audio_enc->codec_tag= audio_codec_tag;
3018
3019     if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3020         audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3021         avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3022     }
3023     if (audio_stream_copy) {
3024         st->stream_copy = 1;
3025         audio_enc->channels = audio_channels;
3026     } else {
3027         codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3028
3029         for(i=0; i<opt_name_count; i++){
3030             char buf[256];
3031             const AVOption *opt;
3032             const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3033             if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3034                 av_set_string(audio_enc, opt_names[i], str);
3035         }
3036
3037         if (audio_codec_name)
3038             codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3039         audio_enc->codec_id = codec_id;
3040
3041         if (audio_qscale > QSCALE_NONE) {
3042             audio_enc->flags |= CODEC_FLAG_QSCALE;
3043             audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3044         }
3045         audio_enc->thread_count = thread_count;
3046         audio_enc->channels = audio_channels;
3047     }
3048     audio_enc->sample_rate = audio_sample_rate;
3049     audio_enc->time_base= (AVRational){1, audio_sample_rate};
3050     if (audio_language) {
3051         av_strlcpy(st->language, audio_language, sizeof(st->language));
3052         av_free(audio_language);
3053         audio_language = NULL;
3054     }
3055
3056     /* reset some key parameters */
3057     audio_disable = 0;
3058     av_freep(&audio_codec_name);
3059     audio_stream_copy = 0;
3060 }
3061
3062 static void new_subtitle_stream(AVFormatContext *oc)
3063 {
3064     AVStream *st;
3065     AVCodecContext *subtitle_enc;
3066     int i;
3067
3068     st = av_new_stream(oc, oc->nb_streams);
3069     if (!st) {
3070         fprintf(stderr, "Could not alloc stream\n");
3071         exit(1);
3072     }
3073     avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3074
3075     bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3076     subtitle_bitstream_filters= NULL;
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 :
3696           *opt == 'a' ? &audio_bitstream_filters :
3697                         &subtitle_bitstream_filters;
3698     while(*bsfp)
3699         bsfp= &(*bsfp)->next;
3700
3701     *bsfp= bsfc;
3702
3703     return 0;
3704 }
3705
3706 static void opt_show_license(void)
3707 {
3708     show_license();
3709     exit(0);
3710 }
3711
3712 static void opt_show_version(void)
3713 {
3714     show_version(program_name);
3715     exit(0);
3716 }
3717
3718 const OptionDef options[] = {
3719     /* main options */
3720     { "L", 0, {(void*)opt_show_license}, "show license" },
3721     { "h", 0, {(void*)opt_show_help}, "show help" },
3722     { "version", 0, {(void*)opt_show_version}, "show version" },