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