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