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