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