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