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