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